docs: private synchronized void parseTrustedPrivateHeaderOrigin(String[] trustedPrivateHeaderHosts, String[] trustedSensitiveHeaderHosts) {
          // bump the updated count every time we call this.
          updateCount.get().incrementAndGet();
  
          // restore defaults
          restrictPrivateHeaderOrigin = null;
          restrictSensitiveHeaderOrigin = null;
          usePrivateHeaders = true;
          useSensitivePrivateHeaders = false;
  
          // If trusted=false (non-default), don't allow private headers from any host, regardless of other settings
          if (!wcTrusted) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "webcontainer trusted=false; private headers are not trusted from any host");
              }
              usePrivateHeaders = false;
              return;
          }
  
          // Parse trustedHeaderOrigin.  The default value is * (any host)
          List<String> addrs = new ArrayList<String>();
          if (trustedPrivateHeaderHosts != null && trustedPrivateHeaderHosts.length > 0) {
              for (String ipaddr : trustedPrivateHeaderHosts) {
                  if ("none".equalsIgnoreCase(ipaddr)) {
                      // if "none" is listed, private headers are not trusted on any host.
                      // however any hosts listed in trustedSensitiveHeaderOrigin can still send private headers
                      usePrivateHeaders = false;
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "trusted private headers hosts: none");
                      }
                      break;
                  } else if ("*".equals(ipaddr)) {
                      // stop processing, empty the list, fall through to below.
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "trusted private headers hosts: *");
                      }
                      addrs.clear();
                      break;
                  } else {
                      addrs.add(ipaddr);
                  }
              }
          } else {
              // no trusted header hosts were defined, use defualt - "*"
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "trusted private headers hosts: *");
              }
          }
          if (usePrivateHeaders) {
              // if IP addresses were listed, only trust private headers from those hosts
              if (!addrs.isEmpty()) {
                  restrictPrivateHeaderOrigin = new HashSet<String>();
                  for (String s : addrs) {
                      if (s != null && !s.isEmpty()) {
                          restrictPrivateHeaderOrigin.add(s.toLowerCase());
                      }
                  }
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "trusted private headers hosts: " + Arrays.toString(addrs.toArray()));
                  }
              }
          }
          addrs.clear();
  
          // Parse trustedSensiveHeaderOrigin.  The default value is none (no hosts trusted)
          if (trustedSensitiveHeaderHosts != null && trustedSensitiveHeaderHosts.length > 0) {
              for (String ipaddr : trustedSensitiveHeaderHosts) {
                  if ("none".equalsIgnoreCase(ipaddr)) {
                      // don't trust sensitive private headers from any host
                      useSensitivePrivateHeaders = false;
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "trusted sensitive private headers hosts: none");
                      }
                      return;
                  } else if ("*".equals(ipaddr)) {
                      // sensitive private headers trusted from any host
                      addrs.clear();
                      useSensitivePrivateHeaders = true;
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "trusted sensitive private headers hosts: *");
                      }
                      break;
                  } else {
                      addrs.add(ipaddr);
                      useSensitivePrivateHeaders = true;
                  }
              }
          } else {
              // no trusted sensitive header hosts were defined, use defualt - "none"
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "trusted sensitive private headers hosts: none");
              }
              return;
          }
          // if IP addresses were listed, only trust sensitive private headers from those hosts
          if (!addrs.isEmpty()) {
              restrictSensitiveHeaderOrigin = new HashSet<String>();
              for (String s : addrs) {
                  if (s != null && !s.isEmpty()) {
                      restrictSensitiveHeaderOrigin.add(s.toLowerCase());
                  }
              }
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "trusted sensitive private headers hosts: " + Arrays.toString(addrs.toArray()));
              }
          }
      }