docs: static Object callSecurely(final CodeSource codeSource, Callable callable,
              Context cx, Scriptable scope, Scriptable thisObj, Object[] args)
      {
          final Thread thread = Thread.currentThread();
          // Run in doPrivileged as we might be checked for "getClassLoader"
          // runtime permission
          final ClassLoader classLoader = (ClassLoader)AccessController.doPrivileged(
              new PrivilegedAction<Object>() {
                  @Override
                  public Object run() {
                      return thread.getContextClassLoader();
                  }
              });
          Map<ClassLoader,SoftReference<SecureCaller>> classLoaderMap;
          synchronized(callers)
          {
              classLoaderMap = callers.get(codeSource);
              if(classLoaderMap == null)
              {
                  classLoaderMap = new WeakHashMap<ClassLoader,SoftReference<SecureCaller>>();
                  callers.put(codeSource, classLoaderMap);
              }
          }
          SecureCaller caller;
          synchronized(classLoaderMap)
          {
              SoftReference<SecureCaller> ref = classLoaderMap.get(classLoader);
              if (ref != null) {
                  caller = ref.get();
              } else {
                  caller = null;
              }
              if (caller == null) {
                  try
                  {
                      // Run in doPrivileged as we'll be checked for
                      // "createClassLoader" runtime permission
                      caller = (SecureCaller)AccessController.doPrivileged(
                              new PrivilegedExceptionAction<Object>()
                      {
                          @Override
                          public Object run() throws Exception
                          {
                              ClassLoader effectiveClassLoader;
                              Class<?> thisClass = getClass();
                              if(classLoader.loadClass(thisClass.getName()) != thisClass) {
                                  effectiveClassLoader = thisClass.getClassLoader();
                              } else {
                                  effectiveClassLoader = classLoader;
                              }
                              SecureClassLoaderImpl secCl =
                                  new SecureClassLoaderImpl(effectiveClassLoader);
                              Class<?> c = secCl.defineAndLinkClass(
                                      SecureCaller.class.getName() + "Impl",
                                      secureCallerImplBytecode, codeSource);
                              return c.newInstance();
                          }
                      });
                      classLoaderMap.put(classLoader, new SoftReference<SecureCaller>(caller));
                  }
                  catch(PrivilegedActionException ex)
                  {
                      throw new UndeclaredThrowableException(ex.getCause());
                  }
              }
          }
          return caller.call(callable, cx, scope, thisObj, args);
      }