docs: protected void initializeExtensionProcessors(List extensionFactories) {
          // TODO: nameSpace preinvoke/postinvoke
  
          if (extensionFactories == null) {
              if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {
                      logger.logp(Level.FINE, CLASS_NAME, "initializeExtensionProcessors", "No extension processors");
              }
              return;
          } 
  
          // process the ExtensionFactories
          for (int i = 0; i < extensionFactories.size(); i++) {
              ExtensionFactory fac = (ExtensionFactory) extensionFactories.get(i);
              ExtensionProcessor processor = null;
              
              // Get the global patterns that this factory creates processors for
              List patterns = fac.getPatternList();
             
              // If extension processing is disabled ignore the factories which return a pattern list
              // Do this before calling createExensionPorcessor so we do not incure the overhead of the creation
              // unless needed.
              if (getExtensionProcessingDisabled() && !patterns.isEmpty()) {
                   if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {  
                       logger.logp(Level.FINE, CLASS_NAME, "initializeExtensionProcessors", "Extension factory with patterns ignored : " + fac.getClass());                   
                   }   
                   continue;
              }
  
              try {
                  processor = fac.createExtensionProcessor(this);
                  if (processor == null) {
                      if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {
                          logger.logp(Level.FINE, CLASS_NAME, "initializeExtensionProcessors", "Extension factory has no processor:" + fac.getClass());
                     }
  
                      // if the factory returns a null processor, it means
                      // that this factory doesn't want to be associated with
                      // this particular webapp.
                      continue;
                  }
  
              } catch (Throwable e) {
                  // Extension processor failed to initialize
                  com.ibm.wsspi.webcontainer.util.FFDCWrapper.processException(e, CLASS_NAME + ".initializeExtensionFactories", "883", this);
                  // e.printStackTrace(System.err); @283348D
                  // 435011
                  logger.logp(Level.SEVERE, CLASS_NAME, "initializeExtensionProcessors", "extension.processor.failed.to.initialize.in.factory",
                              new Object[] { fac, e }); /* 283348.1 */
                  continue;
              }
              
              if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {
                  logger.logp(Level.FINE, CLASS_NAME, "initializeExtensionProcessors", "Extension processor class =" + fac.getClass());
              }
  
              // Get the global patterns that this factory creates processors for
              Iterator it = patterns.iterator();
  
              StringBuffer mapStr = new StringBuffer(' ');
  
              while (it.hasNext()) {
                  String mapping = (String) it.next();
                  if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {
                      logger.logp(Level.FINE, CLASS_NAME, "initializeExtensionProcessors", "Add factory mappings =" + mapping);
                  }
                  try {
                      requestMapper.addMapping(mapping, processor);
                      mapStr.append(mapping);
                      mapStr.append(' ');
                  } catch (Exception exc) {
                      // TODO:
                      // processor already exists for specified pattern
                      // pk435011
                      logger.logp(Level.SEVERE, CLASS_NAME, "initializeExtensionProcessors", "request.processor.already.present.for.mapping", mapping);
                  }
              }
              
              // Get the additional patterns that the specific extension processor
              // might want to be associated with
          
              patterns = processor.getPatternList();
              
              if (getExtensionProcessingDisabled() &&!patterns.isEmpty()) {
                  if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {  
                      logger.logp(Level.FINE, CLASS_NAME, "initializeExtensionProcessors", "Extension processor with patterns ignored : " + processor.getClass());                   
                  }   
              } else {    
                  it = patterns.iterator();
  
                  while (it.hasNext()) {
                      String mapping = (String) it.next();
                      if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) {
                          logger.logp(Level.FINE, CLASS_NAME, "initializeExtensionProcessors", "Add processor mapping =" + mapping);
                      }
  
                      try {
                          requestMapper.addMapping(mapping, processor);
                      } catch (Exception exc) {
                      // TODO:
                      // processor already exists for specified pattern
                      // pk435011
                      // Alex TODO: This does not seem to me to be a problem, perhaps a timing artifact at
                      // worst.  Will revisit.
              //        logger.logp(Level.SEVERE, CLASS_NAME, "initializeExtensionProcessors", "error.adding.servlet.mapping.for.servlet", new Object[] {
              //                mapping, getApplicationName(), exc });
                      }
                  }
              }    
          }
  
      }