docs: @Override
      @FFDCIgnore(PrivilegedActionException.class)
      protected void processInjectionMetaData(final ComponentNameSpaceConfiguration compNSConfig,
                                              List<Class<?>> annotatedClasses) throws InjectionException {
          // OSGI Injection uses the JavaColonCompEnvMap to performing naming lookups,
          // so the map needs to be created even if the caller didn't need it.
          Map<String, InjectionBinding<?>> bindings = compNSConfig.getJavaColonCompEnvMap();
          if (bindings == null) {
              bindings = new LinkedHashMap<String, InjectionBinding<?>>();
              compNSConfig.setJavaColonCompEnvMap(bindings);
          }
  
          if (annotatedClasses == null && !compNSConfig.isMetaDataComplete()) {
              annotatedClasses = compNSConfig.getInjectionClasses();
          }
          if (annotatedClasses == null) {
              annotatedClasses = Collections.emptyList();
          }
  
          InjectionProcessorContextImpl context = (InjectionProcessorContextImpl) compNSConfig.getInjectionProcessorContext();
          context.ivSaveNonCompInjectionBindings = true;
          context.ivSavedGlobalInjectionBindings = new HashMap<Class<?>, Map<String, InjectionBinding<?>>>();
          context.ivSavedAppInjectionBindings = new HashMap<Class<?>, Map<String, InjectionBinding<?>>>();
          context.ivSavedModuleInjectionBindings = new HashMap<Class<?>, Map<String, InjectionBinding<?>>>();
  
          OSGiInjectionScopeData compScopeData = getCompInjectionScopeData(compNSConfig);
          ModuleMetaData mmd = compNSConfig.getModuleMetaData();
          OSGiInjectionScopeData moduleScopeData = mmd == null ? null : getInjectionScopeData(mmd);
          OSGiInjectionScopeData appScopeData = getInjectionScopeData(compNSConfig.getApplicationMetaData());
          OSGiInjectionScopeData contributorScopeData = compScopeData != null ? compScopeData : appScopeData;
  
          Lock writeLock = compScopeData == null ? null : compScopeData.compLock().writeLock();
          if (writeLock != null) {
              writeLock.lock();
          }
          try {
              // If the scope data already has bindings, then we're dynamically
              // updating an existing java:comp with new annotations.
              if (compScopeData != null && compScopeData.compEnvBindings != null) {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "dynamic update to injection metadata");
                  }
  
                  // Set the (read-only) completed bindings.
                  context.ivCompletedInjectionBindings = compScopeData.compEnvBindings;
              }
  
              // Set to the registered factory before the super call; otherwise the
              // super call will override the registered factory with a different
              // one on Client Container, which should only occur on traditional WAS.
              if (compNSConfig.getMBLinkReferenceFactory() == null) {
                  compNSConfig.setMBLinkReferenceFactory(ivMBLinkRefFactory);
              }
  
              if (System.getSecurityManager() == null) {
                  super.processInjectionMetaData(compNSConfig, annotatedClasses);
              } else {
                  try {
                      final List<Class<?>> privAnnotatedClasses = annotatedClasses;
                      AccessController.doPrivileged(new PrivilegedExceptionAction<Void>() {
                          @Override
                          public Void run() throws InjectionException {
                              processInjectionMetaDataPrivileged(compNSConfig, privAnnotatedClasses);
                              return null;
                          }
                      });
                  } catch (PrivilegedActionException paex) {
                      Throwable cause = paex.getCause();
                      if (cause instanceof InjectionException) {
                          throw (InjectionException) cause;
                      }
                      throw new Error(cause);
                  }
              }
  
              if (!bindings.isEmpty() && compScopeData == null && !isManagedBean(compNSConfig)) {
                  // application.xml cannot add java:comp names.
                  applicationReferenceNameError(compNSConfig, bindings.keySet());
              }
  
              // Now that metadata has been processed, we can update the bindings.
  
              Lock nonCompWriteLock = nonCompLock.writeLock();
              nonCompWriteLock.lock();
              try {
                  // Verify that non-java:comp bindings won't conflict.
                  if (moduleScopeData != null) {
                      moduleScopeData.validateNonCompBindings(context.ivSavedModuleInjectionBindings);
                  } else if (!context.ivSavedModuleInjectionBindings.isEmpty()) {
                      // application.xml cannot add java:module names.
                      List<String> names = new ArrayList<String>();
                      for (Map<String, InjectionBinding<?>> newModuleBindings : context.ivSavedModuleInjectionBindings.values()) {
                          names.addAll(newModuleBindings.keySet());
                      }
                      applicationReferenceNameError(compNSConfig, names);
                  }
                  appScopeData.validateNonCompBindings(context.ivSavedAppInjectionBindings);
                  globalScopeData.validateNonCompBindings(context.ivSavedGlobalInjectionBindings);
  
                  // Finally, "commit" all new bindings.
                  if (compScopeData != null) {
                      compScopeData.addCompEnvBindings(bindings);
                  }
                  if (moduleScopeData != null) {
                      moduleScopeData.addNonCompBindings(context.ivSavedModuleInjectionBindings, contributorScopeData);
                  }
                  appScopeData.addNonCompBindings(context.ivSavedAppInjectionBindings, contributorScopeData);
                  globalScopeData.addNonCompBindings(context.ivSavedGlobalInjectionBindings, contributorScopeData);
              } finally {
                  nonCompWriteLock.unlock();
              }
          } finally {
              if (writeLock != null) {
                  writeLock.unlock();
              }
          }
      }