--- old/src/java.base/share/classes/java/lang/System.java 2016-04-15 16:33:03.000000000 +0200 +++ new/src/java.base/share/classes/java/lang/System.java 2016-04-15 16:33:03.000000000 +0200 @@ -1155,8 +1155,9 @@ * @param level the log message level. * @param msg the string message (or a key in the message catalog, if * this logger is a {@link - * LoggerFinder#getLocalizedLogger(java.lang.String, java.util.ResourceBundle, java.lang.Class) - * localized logger}); can be {@code null}. + * LoggerFinder#getLocalizedLogger(java.lang.String, + * java.util.ResourceBundle, java.lang.reflect.Module) localized logger}); + * can be {@code null}. * * @throws NullPointerException if {@code level} is {@code null}. */ @@ -1222,8 +1223,9 @@ * @param level the log message level. * @param msg the string message (or a key in the message catalog, if * this logger is a {@link - * LoggerFinder#getLocalizedLogger(java.lang.String, java.util.ResourceBundle, java.lang.Class) - * localized logger}); can be {@code null}. + * LoggerFinder#getLocalizedLogger(java.lang.String, + * java.util.ResourceBundle, java.lang.reflect.Module) localized logger}); + * can be {@code null}. * @param thrown a {@code Throwable} associated with the log message; * can be {@code null}. * @@ -1270,8 +1272,9 @@ * @param format the string message format in {@link * java.text.MessageFormat} format, (or a key in the message * catalog, if this logger is a {@link - * LoggerFinder#getLocalizedLogger(java.lang.String, java.util.ResourceBundle, java.lang.Class) - * localized logger}); can be {@code null}. + * LoggerFinder#getLocalizedLogger(java.lang.String, + * java.util.ResourceBundle, java.lang.reflect.Module) localized logger}); + * can be {@code null}. * @param params an optional list of parameters to the message (may be * none). * @@ -1453,30 +1456,30 @@ /** * Returns an instance of {@link Logger Logger} - * for the given {@code caller}. + * for the given {@code module}. * * @param name the name of the logger. - * @param caller the class for which the logger is being requested. + * @param module the module for which the logger is being requested. * - * @return a {@link Logger logger} suitable for the given caller's - * use. + * @return a {@link Logger logger} suitable for use within the given + * module. * @throws NullPointerException if {@code name} is {@code null} or - * {@code caller} is {@code null}. + * {@code module} is {@code null}. * @throws SecurityException if a security manager is present and its * {@code checkPermission} method doesn't allow the * {@code RuntimePermission("loggerFinder")}. */ - public abstract Logger getLogger(String name, /* Module */ Class caller); + public abstract Logger getLogger(String name, Module module); /** * Returns a localizable instance of {@link Logger Logger} - * for the given {@code caller}. + * for the given {@code module}. * The returned logger will use the provided resource bundle for * message localization. * * @implSpec By default, this method calls {@link - * #getLogger(java.lang.String, java.lang.Class) - * this.getLogger(name, caller)} to obtain a logger, then wraps that + * #getLogger(java.lang.String, java.lang.reflect.Module) + * this.getLogger(name, module)} to obtain a logger, then wraps that * logger in a {@link Logger} instance where all methods that do not * take a {@link ResourceBundle} as parameter are redirected to one * which does - passing the given {@code bundle} for @@ -1499,19 +1502,19 @@ * * @param name the name of the logger. * @param bundle a resource bundle; can be {@code null}. - * @param caller the class for which the logger is being requested. + * @param module the module for which the logger is being requested. * @return an instance of {@link Logger Logger} which will use the * provided resource bundle for message localization. * * @throws NullPointerException if {@code name} is {@code null} or - * {@code caller} is {@code null}. + * {@code module} is {@code null}. * @throws SecurityException if a security manager is present and its * {@code checkPermission} method doesn't allow the * {@code RuntimePermission("loggerFinder")}. */ public Logger getLocalizedLogger(String name, ResourceBundle bundle, - /* Module */ Class caller) { - return new LocalizedLoggerWrapper<>(getLogger(name, caller), bundle); + Module module) { + return new LocalizedLoggerWrapper<>(getLogger(name, module), bundle); } /** @@ -1558,12 +1561,13 @@ * * @implSpec * Instances returned by this method route messages to loggers - * obtained by calling {@link LoggerFinder#getLogger(java.lang.String, java.lang.Class) - * LoggerFinder.getLogger(name, caller)}. + * obtained by calling {@link LoggerFinder#getLogger(java.lang.String, + * java.lang.reflect.Module) LoggerFinder.getLogger(name, module)}, where + * {@code module} is the caller's module. * * @apiNote * This method may defer calling the {@link - * LoggerFinder#getLogger(java.lang.String, java.lang.Class) + * LoggerFinder#getLogger(java.lang.String, java.lang.reflect.Module) * LoggerFinder.getLogger} method to create an actual logger supplied by * the logging backend, for instance, to allow loggers to be obtained during * the system initialization time. @@ -1579,7 +1583,7 @@ public static Logger getLogger(String name) { Objects.requireNonNull(name); final Class caller = Reflection.getCallerClass(); - return LazyLoggers.getLogger(name, caller); + return LazyLoggers.getLogger(name, caller.getModule()); } /** @@ -1591,8 +1595,9 @@ * @implSpec * The returned logger will perform message localization as specified * by {@link LoggerFinder#getLocalizedLogger(java.lang.String, - * java.util.ResourceBundle, java.lang.Class) - * LoggerFinder.getLocalizedLogger(name, bundle, caller}. + * java.util.ResourceBundle, java.lang.reflect.Module) + * LoggerFinder.getLocalizedLogger(name, bundle, module}, where + * {@code module} is the caller's module. * * @apiNote * This method is intended to be used after the system is fully initialized. @@ -1624,12 +1629,14 @@ // Bootstrap sensitive classes in the JDK do not use resource bundles // when logging. This could be revisited later, if it needs to. if (sm != null) { - return AccessController.doPrivileged((PrivilegedAction) - () -> LoggerFinder.accessProvider().getLocalizedLogger(name, rb, caller), - null, - LoggerFinder.LOGGERFINDER_PERMISSION); + final PrivilegedAction pa = + () -> LoggerFinder.accessProvider() + .getLocalizedLogger(name, rb, caller.getModule()); + return AccessController.doPrivileged(pa, null, + LoggerFinder.LOGGERFINDER_PERMISSION); } - return LoggerFinder.accessProvider().getLocalizedLogger(name, rb, caller); + return LoggerFinder.accessProvider() + .getLocalizedLogger(name, rb, caller.getModule()); } /** --- old/src/java.base/share/classes/jdk/internal/logger/DefaultLoggerFinder.java 2016-04-15 16:33:04.000000000 +0200 +++ new/src/java.base/share/classes/jdk/internal/logger/DefaultLoggerFinder.java 2016-04-15 16:33:03.000000000 +0200 @@ -33,6 +33,9 @@ import java.lang.System.LoggerFinder; import java.lang.System.Logger; import java.lang.ref.ReferenceQueue; +import java.lang.reflect.Module; +import java.security.AccessController; +import java.security.PrivilegedAction; import java.util.Collection; import java.util.ResourceBundle; @@ -129,41 +132,49 @@ return w; } - final static SharedLoggers system = new SharedLoggers(); final static SharedLoggers application = new SharedLoggers(); } + public static boolean isSystem(Module m) { + ClassLoader cl = AccessController.doPrivileged(new PrivilegedAction<>() { + @Override + public ClassLoader run() { + return m.getClassLoader(); + } + }); + return cl == null; + } + @Override - public final Logger getLogger(String name, /* Module */ Class caller) { + public final Logger getLogger(String name, Module module) { checkPermission(); - return demandLoggerFor(name, caller); + return demandLoggerFor(name, module); } @Override public final Logger getLocalizedLogger(String name, ResourceBundle bundle, - /* Module */ Class caller) { - return super.getLocalizedLogger(name, bundle, caller); + Module module) { + return super.getLocalizedLogger(name, bundle, module); } - - /** - * Returns a {@link Logger logger} suitable for the caller usage. + * Returns a {@link Logger logger} suitable for use within the + * given {@code module}. * * @implSpec The default implementation for this method is to return a * simple logger that will print all messages of INFO level and above * to the console. That simple logger is not configurable. * * @param name The name of the logger. - * @param caller The class on behalf of which the logger is created. + * @param module The module on behalf of which the logger is created. * @return A {@link Logger logger} suitable for the application usage. * @throws SecurityException if the calling code does not have the * {@code RuntimePermission("loggerFinder")}. */ - protected Logger demandLoggerFor(String name, /* Module */ Class caller) { + protected Logger demandLoggerFor(String name, Module module) { checkPermission(); - if (caller.getClassLoader() == null) { + if (isSystem(module)) { return SharedLoggers.system.get(SimpleConsoleLogger::makeSimpleLogger, name); } else { return SharedLoggers.application.get(SimpleConsoleLogger::makeSimpleLogger, name); --- old/src/java.base/share/classes/jdk/internal/logger/LazyLoggers.java 2016-04-15 16:33:04.000000000 +0200 +++ new/src/java.base/share/classes/jdk/internal/logger/LazyLoggers.java 2016-04-15 16:33:04.000000000 +0200 @@ -31,6 +31,7 @@ import java.lang.System.LoggerFinder; import java.lang.System.Logger; import java.lang.ref.WeakReference; +import java.lang.reflect.Module; import java.util.Objects; import jdk.internal.misc.VM; import sun.util.logging.PlatformLogger; @@ -59,15 +60,15 @@ * A factory method to create an SPI logger. * Usually, this will be something like LazyLoggers::getSystemLogger. */ - final BiFunction, L> loggerSupplier; + final BiFunction loggerSupplier; - public LazyLoggerFactories(BiFunction, L> loggerSupplier) { + public LazyLoggerFactories(BiFunction loggerSupplier) { this(Objects.requireNonNull(loggerSupplier), (Void)null); } - private LazyLoggerFactories(BiFunction, L> loggerSupplier, + private LazyLoggerFactories(BiFunction loggerSupplier, Void unused) { this.loggerSupplier = loggerSupplier; } @@ -107,8 +108,8 @@ // The factories that will be used to create the logger lazyly final LazyLoggerFactories factories; - // We need to pass the actual caller when creating the logger. - private final WeakReference> callerRef; + // We need to pass the actual caller module when creating the logger. + private final WeakReference moduleRef; // The name of the logger that will be created lazyly final String name; @@ -121,17 +122,17 @@ private LazyLoggerAccessor(String name, LazyLoggerFactories factories, - Class caller) { + Module module) { this(Objects.requireNonNull(name), Objects.requireNonNull(factories), - Objects.requireNonNull(caller), null); + Objects.requireNonNull(module), null); } private LazyLoggerAccessor(String name, LazyLoggerFactories factories, - Class caller, Void unused) { + Module module, Void unused) { this.name = name; this.factories = factories; - this.callerRef = new WeakReference>(caller); + this.moduleRef = new WeakReference<>(module); } /** @@ -270,12 +271,12 @@ // Creates the wrapped logger by invoking the SPI. Logger createLogger() { - final Class caller = callerRef.get(); - if (caller == null) { - throw new IllegalStateException("The class for which this logger" + final Module module = moduleRef.get(); + if (module == null) { + throw new IllegalStateException("The module for which this logger" + " was created has been garbage collected"); } - return this.factories.loggerSupplier.apply(name, caller); + return this.factories.loggerSupplier.apply(name, module); } /** @@ -289,8 +290,8 @@ * @return A new LazyLoggerAccessor. */ public static LazyLoggerAccessor makeAccessor(String name, - LazyLoggerFactories factories, Class caller) { - return new LazyLoggerAccessor(name, factories, caller); + LazyLoggerFactories factories, Module module) { + return new LazyLoggerAccessor(name, factories, module); } } @@ -346,11 +347,11 @@ // Avoid using lambda here as lazy loggers could be created early // in the bootstrap sequence... - private static final BiFunction, Logger> loggerSupplier = + private static final BiFunction loggerSupplier = new BiFunction<>() { @Override - public Logger apply(String name, Class caller) { - return LazyLoggers.getLoggerFromFinder(name, caller); + public Logger apply(String name, Module module) { + return LazyLoggers.getLoggerFromFinder(name, module); } }; @@ -367,8 +368,8 @@ // logger provider until the VM has finished booting. // private static final class JdkLazyLogger extends LazyLoggerWrapper { - JdkLazyLogger(String name, Class caller) { - this(LazyLoggerAccessor.makeAccessor(name, factories, caller), + JdkLazyLogger(String name, Module module) { + this(LazyLoggerAccessor.makeAccessor(name, factories, module), (Void)null); } private JdkLazyLogger(LazyLoggerAccessor holder, Void unused) { @@ -380,16 +381,16 @@ * Gets a logger from the LoggerFinder. Creates the actual concrete * logger. * @param name name of the logger - * @param caller class on behalf of which the logger is created + * @param module module on behalf of which the logger is created * @return The logger returned by the LoggerFinder. */ - static Logger getLoggerFromFinder(String name, Class caller) { + static Logger getLoggerFromFinder(String name, Module module) { final SecurityManager sm = System.getSecurityManager(); if (sm == null) { - return accessLoggerFinder().getLogger(name, caller); + return accessLoggerFinder().getLogger(name, module); } else { return AccessController.doPrivileged((PrivilegedAction) - () -> {return accessLoggerFinder().getLogger(name, caller);}, + () -> {return accessLoggerFinder().getLogger(name, module);}, null, LOGGERFINDER_PERMISSION); } } @@ -398,22 +399,22 @@ * Returns a (possibly lazy) Logger for the caller. * * @param name the logger name - * @param caller The class on behalf of which the logger is created. - * If the caller is not loaded from the Boot ClassLoader, + * @param module The module on behalf of which the logger is created. + * If the module is not loaded from the Boot ClassLoader, * the LoggerFinder is accessed and the logger returned - * by {@link LoggerFinder#getLogger(java.lang.String, java.lang.Class)} + * by {@link LoggerFinder#getLogger(java.lang.String, java.lang.reflect.Module)} * is returned to the caller directly. * Otherwise, the logger returned by - * {@link #getLazyLogger(java.lang.String, java.lang.Class)} + * {@link #getLazyLogger(java.lang.String, java.lang.reflect.Module)} * is returned to the caller. * * @return a (possibly lazy) Logger instance. */ - public static final Logger getLogger(String name, Class caller) { - if (caller.getClassLoader() == null) { - return getLazyLogger(name, caller); + public static final Logger getLogger(String name, Module module) { + if (DefaultLoggerFinder.isSystem(module)) { + return getLazyLogger(name, module); } else { - return getLoggerFromFinder(name, caller); + return getLoggerFromFinder(name, module); } } @@ -423,10 +424,10 @@ * returned by {@link BootstrapLogger#useLazyLoggers()}. * * @param name the logger name - * @param caller the class on behalf of which the logger is created. + * @param module the module on behalf of which the logger is created. * @return a (possibly lazy) Logger instance. */ - public static final Logger getLazyLogger(String name, Class caller) { + public static final Logger getLazyLogger(String name, Module module) { // BootstrapLogger has the logic to determine whether a LazyLogger // should be used. Usually, it is worth it only if: @@ -438,10 +439,10 @@ // configuration, we're not going to delay the creation of loggers... final boolean useLazyLogger = BootstrapLogger.useLazyLoggers(); if (useLazyLogger) { - return new JdkLazyLogger(name, caller); + return new JdkLazyLogger(name, module); } else { // Directly invoke the LoggerFinder. - return getLoggerFromFinder(name, caller); + return getLoggerFromFinder(name, module); } } --- old/src/java.base/share/classes/sun/util/logging/PlatformLogger.java 2016-04-15 16:33:05.000000000 +0200 +++ new/src/java.base/share/classes/sun/util/logging/PlatformLogger.java 2016-04-15 16:33:05.000000000 +0200 @@ -286,12 +286,15 @@ } if (log == null) { log = new PlatformLogger(PlatformLogger.Bridge.convert( - // We pass PlatformLogger.class rather than the actual caller + // We pass PlatformLogger.class.getModule() (java.base) + // rather than the actual module of the caller // because we want PlatformLoggers to be system loggers: we // won't need to resolve any resource bundles anyway. // Note: Many unit tests depend on the fact that - // PlatformLogger.getLoggerFromFinder is not caller sensitive. - LazyLoggers.getLazyLogger(name, PlatformLogger.class))); + // PlatformLogger.getLoggerFromFinder is not caller + // sensitive, and this strategy ensure that the tests + // still pass. + LazyLoggers.getLazyLogger(name, PlatformLogger.class.getModule()))); loggers.put(name, new WeakReference<>(log)); } return log; --- old/src/java.logging/share/classes/java/util/logging/LogManager.java 2016-04-15 16:33:06.000000000 +0200 +++ new/src/java.logging/share/classes/java/util/logging/LogManager.java 2016-04-15 16:33:06.000000000 +0200 @@ -44,6 +44,8 @@ import jdk.internal.misc.SharedSecrets; import sun.misc.ManagedLocalsThread; import sun.util.logging.internal.LoggingProviderImpl; +import java.lang.reflect.Module; +import static jdk.internal.logger.DefaultLoggerFinder.isSystem; /** * There is a single global LogManager object that is used to @@ -503,10 +505,16 @@ // as a LogManager subclass may override the addLogger, getLogger, // readConfiguration, and other methods. Logger demandLogger(String name, String resourceBundleName, Class caller) { + final Module module = caller == null ? null : caller.getModule(); + return demandLogger(name, resourceBundleName, module); + } + + Logger demandLogger(String name, String resourceBundleName, Module module) { Logger result = getLogger(name); if (result == null) { // only allocate the new logger once - Logger newLogger = new Logger(name, resourceBundleName, caller, this, false); + Logger newLogger = new Logger(name, resourceBundleName, + module == null ? null : module, this, false); do { if (addLogger(newLogger)) { // We successfully added the new Logger that we @@ -532,9 +540,14 @@ } Logger demandSystemLogger(String name, String resourceBundleName, Class caller) { + final Module module = caller == null ? null : caller.getModule(); + return demandSystemLogger(name, resourceBundleName, module); + } + + Logger demandSystemLogger(String name, String resourceBundleName, Module module) { // Add a system logger in the system context's namespace final Logger sysLogger = getSystemContext() - .demandLogger(name, resourceBundleName, caller); + .demandLogger(name, resourceBundleName, module); // Add the system logger to the LogManager's namespace if not exist // so that there is only one single logger of the given name. @@ -619,11 +632,11 @@ return global; } - Logger demandLogger(String name, String resourceBundleName, Class caller) { + Logger demandLogger(String name, String resourceBundleName, Module module) { // a LogManager subclass may have its own implementation to add and // get a Logger. So delegate to the LogManager to do the work. final LogManager owner = getOwner(); - return owner.demandLogger(name, resourceBundleName, caller); + return owner.demandLogger(name, resourceBundleName, module); } @@ -907,11 +920,13 @@ // one single logger of the given name. System loggers are visible // to applications unless a logger of the same name has been added. @Override - Logger demandLogger(String name, String resourceBundleName, Class caller) { + Logger demandLogger(String name, String resourceBundleName, + Module module) { Logger result = findLogger(name); if (result == null) { // only allocate the new system logger once - Logger newLogger = new Logger(name, resourceBundleName, caller, getOwner(), true); + Logger newLogger = new Logger(name, resourceBundleName, + module, getOwner(), true); do { if (addLocalLogger(newLogger)) { // We successfully added the new Logger that we @@ -2622,18 +2637,18 @@ } /** - * Demands a logger on behalf of the given {@code caller}. + * Demands a logger on behalf of the given {@code module}. *

- * If a named logger suitable for the given caller is found + * If a named logger suitable for the given module is found * returns it. - * Otherwise, creates a new logger suitable for the given caller. + * Otherwise, creates a new logger suitable for the given module. * * @param name The logger name. - * @param caller The caller on which behalf the logger is created/retrieved. - * @return A logger for the given {@code caller}. + * @param module The module on which behalf the logger is created/retrieved. + * @return A logger for the given {@code module}. * * @throws NullPointerException if {@code name} is {@code null} - * or {@code caller} is {@code null}. + * or {@code module} is {@code null}. * @throws IllegalArgumentException if {@code manager} is not the default * LogManager. * @throws SecurityException if a security manager is present and the @@ -2641,7 +2656,7 @@ * {@link LoggingPermission LoggingPermission("demandLogger", null)}. */ @Override - public Logger demandLoggerFor(LogManager manager, String name, /* Module */ Class caller) { + public Logger demandLoggerFor(LogManager manager, String name, Module module) { if (manager != getLogManager()) { // having LogManager as parameter just ensures that the // caller will have initialized the LogManager before reaching @@ -2649,15 +2664,16 @@ throw new IllegalArgumentException("manager"); } Objects.requireNonNull(name); + Objects.requireNonNull(module); SecurityManager sm = System.getSecurityManager(); if (sm != null) { sm.checkPermission(controlPermission); } - if (caller.getClassLoader() == null) { + if (isSystem(module)) { return manager.demandSystemLogger(name, - Logger.SYSTEM_LOGGER_RB_NAME, caller); + Logger.SYSTEM_LOGGER_RB_NAME, module); } else { - return manager.demandLogger(name, null, caller); + return manager.demandLogger(name, null, module); } } --- old/src/java.logging/share/classes/java/util/logging/Logger.java 2016-04-15 16:33:07.000000000 +0200 +++ new/src/java.logging/share/classes/java/util/logging/Logger.java 2016-04-15 16:33:07.000000000 +0200 @@ -40,6 +40,7 @@ import java.util.function.Supplier; import sun.reflect.CallerSensitive; import sun.reflect.Reflection; +import static jdk.internal.logger.DefaultLoggerFinder.isSystem; /** * A Logger object is used to log messages for a specific @@ -379,7 +380,8 @@ this(name, resourceBundleName, null, LogManager.getLogManager(), false); } - Logger(String name, String resourceBundleName, Class caller, LogManager manager, boolean isSystemLogger) { + Logger(String name, String resourceBundleName, Module caller, + LogManager manager, boolean isSystemLogger) { this.manager = manager; this.isSystemLogger = isSystemLogger; setupResourceInfo(resourceBundleName, caller); @@ -387,10 +389,7 @@ levelValue = Level.INFO.intValue(); } - private void setCallerModuleRef(Class caller) { - Module callerModule = ((caller != null) - ? caller.getModule() - : null); + private void setCallerModuleRef(Module callerModule) { if (callerModule != null) { this.callerModuleRef = new WeakReference<>(callerModule); } @@ -618,7 +617,7 @@ // all loggers in the system context will default to // the system logger's resource bundle - therefore the caller won't // be needed and can be null. - Logger result = manager.demandSystemLogger(name, SYSTEM_LOGGER_RB_NAME, null); + Logger result = manager.demandSystemLogger(name, SYSTEM_LOGGER_RB_NAME, (Module)null); return result; } @@ -681,8 +680,10 @@ LogManager manager = LogManager.getLogManager(); // cleanup some Loggers that have been GC'ed manager.drainLoggerRefQueueBounded(); + final Class callerClass = Reflection.getCallerClass(); + final Module module = callerClass.getModule(); Logger result = new Logger(null, resourceBundleName, - Reflection.getCallerClass(), manager, false); + module, manager, false); result.anonymous = true; Logger root = manager.getLogger(""); result.doSetParent(root); @@ -2046,6 +2047,11 @@ } } + private void setupResourceInfo(String name, Class caller) { + final Module module = caller == null ? null : caller.getModule(); + setupResourceInfo(name, module); + } + // Private utility method to initialize our one entry // resource bundle name cache and the callers Module // Note: for consistency reasons, we are careful to check @@ -2053,7 +2059,7 @@ // resourceBundleName field. // Synchronized to prevent races in setting the fields. private synchronized void setupResourceInfo(String name, - Class callerClass) { + Module callerModule) { final LoggerBundle lb = loggerBundle; if (lb.resourceBundleName != null) { // this Logger already has a ResourceBundle @@ -2072,8 +2078,9 @@ return; } - setCallerModuleRef(callerClass); - if (isSystemLogger && (callerClass != null && callerClass.getClassLoader() != null)) { + setCallerModuleRef(callerModule); + + if (isSystemLogger && (callerModule != null && !isSystem(callerModule))) { checkPermission(); } --- old/src/java.logging/share/classes/sun/util/logging/internal/LoggingProviderImpl.java 2016-04-15 16:33:08.000000000 +0200 +++ new/src/java.logging/share/classes/sun/util/logging/internal/LoggingProviderImpl.java 2016-04-15 16:33:07.000000000 +0200 @@ -32,6 +32,7 @@ import java.util.function.Supplier; import java.lang.System.LoggerFinder; import java.lang.System.Logger; +import java.lang.reflect.Module; import java.util.Objects; import java.util.logging.LogManager; import jdk.internal.logger.DefaultLoggerFinder; @@ -398,21 +399,20 @@ } /** - * Creates a java.util.logging.Logger for the given caller. + * Creates a java.util.logging.Logger for the given module. * @param name the logger name. - * @param caller the caller for which the logger should be created. - * @return a Logger suitable for use in the given caller. + * @param module the module for which the logger should be created. + * @return a Logger suitable for use in the given module. */ private static java.util.logging.Logger demandJULLoggerFor(final String name, - /* Module */ - final Class caller) { + Module module) { final LogManager manager = LogManager.getLogManager(); final SecurityManager sm = System.getSecurityManager(); if (sm == null) { - return logManagerAccess.demandLoggerFor(manager, name, caller); + return logManagerAccess.demandLoggerFor(manager, name, module); } else { final PrivilegedAction pa = - () -> logManagerAccess.demandLoggerFor(manager, name, caller); + () -> logManagerAccess.demandLoggerFor(manager, name, module); return AccessController.doPrivileged(pa, null, LOGGING_CONTROL_PERMISSION); } } @@ -429,17 +429,17 @@ * {@code RuntimePermission("loggerFinder")}. */ @Override - protected Logger demandLoggerFor(String name, /* Module */ Class caller) { + protected Logger demandLoggerFor(String name, Module module) { final SecurityManager sm = System.getSecurityManager(); if (sm != null) { sm.checkPermission(LOGGERFINDER_PERMISSION); } - return JULWrapper.of(demandJULLoggerFor(name,caller)); + return JULWrapper.of(demandJULLoggerFor(name,module)); } public static interface LogManagerAccess { java.util.logging.Logger demandLoggerFor(LogManager manager, - String name, /* Module */ Class caller); + String name, Module module); } // Hook for tests --- old/test/java/lang/System/Logger/custom/CustomLoggerTest.java 2016-04-15 16:33:08.000000000 +0200 +++ new/test/java/lang/System/Logger/custom/CustomLoggerTest.java 2016-04-15 16:33:08.000000000 +0200 @@ -46,6 +46,8 @@ import java.lang.System.Logger; import java.lang.System.Logger.Level; import java.util.stream.Stream; +import java.lang.reflect.Module; +import java.security.AllPermission; /** * @test @@ -70,6 +72,12 @@ return new AtomicBoolean(false); } }; + static final ThreadLocal allowAll = new ThreadLocal() { + @Override + protected AtomicBoolean initialValue() { + return new AtomicBoolean(false); + } + }; public static class MyBundle extends ResourceBundle { @@ -241,7 +249,7 @@ } @Override - public Logger getLogger(String name, Class caller) { + public Logger getLogger(String name, Module caller) { // We should check the permission to obey the API contract, but // what happens if we don't? // This is the main difference compared with what we test in @@ -251,8 +259,13 @@ sm.checkPermission(SimplePolicy.LOGGERFINDER_PERMISSION); } - PrivilegedAction pa = () -> caller.getClassLoader(); - ClassLoader callerLoader = AccessController.doPrivileged(pa); + final boolean before = allowAll.get().getAndSet(true); + final ClassLoader callerLoader; + try { + callerLoader = caller.getClassLoader(); + } finally { + allowAll.get().set(before); + } if (callerLoader == null) { return system.computeIfAbsent(name, (n) -> new LoggerImpl(n)); } else { @@ -267,7 +280,7 @@ static void setSecurityManager() { if (System.getSecurityManager() == null) { - Policy.setPolicy(new SimplePolicy(allowControl)); + Policy.setPolicy(new SimplePolicy(allowControl, allowAll)); System.setSecurityManager(new SecurityManager()); } } @@ -284,9 +297,9 @@ BaseLoggerFinder provider = BaseLoggerFinder.class.cast(LoggerFinder.getLoggerFinder()); BaseLoggerFinder.LoggerImpl appSink = - BaseLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", CustomLoggerTest.class)); + BaseLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", CustomLoggerTest.class.getModule())); BaseLoggerFinder.LoggerImpl sysSink = - BaseLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class)); + BaseLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class.getModule())); Stream.of(args).map(TestCases::valueOf).forEach((testCase) -> { @@ -695,34 +708,46 @@ static final RuntimePermission LOGGERFINDER_PERMISSION = new RuntimePermission("loggerFinder"); final Permissions permissions; + final Permissions controlPermissions; final Permissions allPermissions; final ThreadLocal allowControl; - public SimplePolicy(ThreadLocal allowControl) { + final ThreadLocal allowAll; + public SimplePolicy(ThreadLocal allowControl, ThreadLocal allowAll) { this.allowControl = allowControl; + this.allowAll = allowAll; permissions = new Permissions(); // these are used for configuring the test itself... + controlPermissions = new Permissions(); + controlPermissions.add(LOGGERFINDER_PERMISSION); + + // these are used for simulating a doPrivileged call from + // a class in the BCL allPermissions = new Permissions(); - allPermissions.add(LOGGERFINDER_PERMISSION); + allPermissions.add(new AllPermission()); + + } + + Permissions permissions() { + if (allowAll.get().get()) return allPermissions; + if (allowControl.get().get()) return controlPermissions; + return permissions; } @Override public boolean implies(ProtectionDomain domain, Permission permission) { - if (allowControl.get().get()) return allPermissions.implies(permission); - return permissions.implies(permission); + return permissions().implies(permission); } @Override public PermissionCollection getPermissions(CodeSource codesource) { - return new PermissionsBuilder().addAll(allowControl.get().get() - ? allPermissions : permissions).toPermissions(); + return new PermissionsBuilder().addAll(permissions()).toPermissions(); } @Override public PermissionCollection getPermissions(ProtectionDomain domain) { - return new PermissionsBuilder().addAll(allowControl.get().get() - ? allPermissions : permissions).toPermissions(); + return new PermissionsBuilder().addAll(permissions()).toPermissions(); } } } --- old/test/java/lang/System/LoggerFinder/BaseLoggerFinderTest/BaseLoggerFinder.java 2016-04-15 16:33:09.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/BaseLoggerFinderTest/BaseLoggerFinder.java 2016-04-15 16:33:09.000000000 +0200 @@ -25,13 +25,14 @@ import java.security.PrivilegedAction; import java.lang.System.LoggerFinder; import java.lang.System.Logger; +import java.lang.reflect.Module; public class BaseLoggerFinder extends LoggerFinder implements TestLoggerFinder { static final RuntimePermission LOGGERFINDER_PERMISSION = new RuntimePermission("loggerFinder"); @Override - public Logger getLogger(String name, Class caller) { + public Logger getLogger(String name, Module caller) { SecurityManager sm = System.getSecurityManager(); if (sm != null) { sm.checkPermission(LOGGERFINDER_PERMISSION); --- old/test/java/lang/System/LoggerFinder/BaseLoggerFinderTest/BaseLoggerFinderTest.java 2016-04-15 16:33:10.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/BaseLoggerFinderTest/BaseLoggerFinderTest.java 2016-04-15 16:33:10.000000000 +0200 @@ -182,8 +182,8 @@ TestLoggerFinder.LoggerImpl appLogger1 = null; try { appLogger1 = - TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerFinderTest.class)); - loggerDescMap.put(appLogger1, "provider.getLogger(\"foo\", BaseLoggerFinderTest.class)"); + TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerFinderTest.class.getModule())); + loggerDescMap.put(appLogger1, "provider.getLogger(\"foo\", BaseLoggerFinderTest.class.getModule())"); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a logger without permission"); } @@ -199,8 +199,8 @@ allowControl.get().set(true); try { appLogger1 = - TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerFinderTest.class)); - loggerDescMap.put(appLogger1, "provider.getLogger(\"foo\", BaseLoggerFinderTest.class)"); + TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerFinderTest.class.getModule())); + loggerDescMap.put(appLogger1, "provider.getLogger(\"foo\", BaseLoggerFinderTest.class.getModule())"); } finally { allowControl.get().set(old); } @@ -208,8 +208,8 @@ TestLoggerFinder.LoggerImpl sysLogger1 = null; try { - sysLogger1 = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class)); - loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class)"); + sysLogger1 = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class.getModule())); + loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class.getModule())"); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a system logger without permission"); } @@ -224,8 +224,8 @@ final boolean old = allowControl.get().get(); allowControl.get().set(true); try { - sysLogger1 = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class)); - loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class)"); + sysLogger1 = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class.getModule())); + loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class.getModule())"); } finally { allowControl.get().set(old); } @@ -254,8 +254,8 @@ // callers and non system callers Logger appLogger2 = null; try { - appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, BaseLoggerFinderTest.class); - loggerDescMap.put(appLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, BaseLoggerFinderTest.class)"); + appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, BaseLoggerFinderTest.class.getModule()); + loggerDescMap.put(appLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, BaseLoggerFinderTest.class.getModule())"); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a logger without permission"); } @@ -270,8 +270,8 @@ final boolean old = allowControl.get().get(); allowControl.get().set(true); try { - appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, BaseLoggerFinderTest.class); - loggerDescMap.put(appLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, BaseLoggerFinderTest.class)"); + appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, BaseLoggerFinderTest.class.getModule()); + loggerDescMap.put(appLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, BaseLoggerFinderTest.class.getModule())"); } finally { allowControl.get().set(old); } @@ -279,8 +279,8 @@ Logger sysLogger2 = null; try { - sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class); - loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class)"); + sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class.getModule()); + loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class.getModule())"); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a system logger without permission"); } @@ -295,8 +295,8 @@ final boolean old = allowControl.get().get(); allowControl.get().set(true); try { - sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class); - loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class))"); + sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class.getModule()); + loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class.getModule()))"); } finally { allowControl.get().set(old); } --- old/test/java/lang/System/LoggerFinder/BaseLoggerFinderTest/TestLoggerFinder.java 2016-04-15 16:33:11.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/BaseLoggerFinderTest/TestLoggerFinder.java 2016-04-15 16:33:10.000000000 +0200 @@ -30,6 +30,7 @@ import java.util.concurrent.atomic.AtomicLong; import java.util.function.Supplier; import java.lang.System.Logger; +import java.lang.reflect.Module; /** * What our test provider needs to implement. @@ -176,6 +177,6 @@ } } - public Logger getLogger(String name, Class caller); - public Logger getLocalizedLogger(String name, ResourceBundle bundle, Class caller); + public Logger getLogger(String name, Module caller); + public Logger getLocalizedLogger(String name, ResourceBundle bundle, Module caller); } --- old/test/java/lang/System/LoggerFinder/DefaultLoggerFinderTest/DefaultLoggerFinderTest.java 2016-04-15 16:33:12.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/DefaultLoggerFinderTest/DefaultLoggerFinderTest.java 2016-04-15 16:33:11.000000000 +0200 @@ -364,8 +364,8 @@ Logger appLogger1 = null; try { - appLogger1 = provider.getLogger("foo", DefaultLoggerFinderTest.class); - loggerDescMap.put(appLogger1, "provider.getApplicationLogger(\"foo\")"); + appLogger1 = provider.getLogger("foo", DefaultLoggerFinderTest.class.getModule()); + loggerDescMap.put(appLogger1, "provider.getLogger(\"foo\", DefaultLoggerFinderTest.class.getModule())"); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a logger without permission"); } @@ -380,8 +380,8 @@ boolean old = allowControl.get().get(); allowControl.get().set(true); try { - appLogger1 =provider.getLogger("foo", DefaultLoggerFinderTest.class); - loggerDescMap.put(appLogger1, "provider.getApplicationLogger(\"foo\")"); + appLogger1 =provider.getLogger("foo", DefaultLoggerFinderTest.class.getModule()); + loggerDescMap.put(appLogger1, "provider.getLogger(\"foo\", DefaultLoggerFinderTest.class.getModule())"); } finally { allowControl.get().set(old); } @@ -389,8 +389,8 @@ Logger sysLogger1 = null; try { - sysLogger1 = provider.getLogger("foo", Thread.class); - loggerDescMap.put(sysLogger1, "provider.getSystemLogger(\"foo\")"); + sysLogger1 = provider.getLogger("foo", Thread.class.getModule()); + loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class.getModule())"); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a system logger without permission"); } @@ -405,8 +405,8 @@ boolean old = allowControl.get().get(); allowControl.get().set(true); try { - sysLogger1 = provider.getLogger("foo", Thread.class); - loggerDescMap.put(sysLogger1, "provider.getSystemLogger(\"foo\")"); + sysLogger1 = provider.getLogger("foo", Thread.class.getModule()); + loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class.getModule())"); } finally { allowControl.get().set(old); } @@ -417,8 +417,8 @@ Logger appLogger2 = null; try { - appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, DefaultLoggerFinderTest.class); - loggerDescMap.put(appLogger2, "provider.getLocalizedApplicationLogger(\"foo\", loggerBundle)"); + appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, DefaultLoggerFinderTest.class.getModule()); + loggerDescMap.put(appLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, DefaultLoggerFinderTest.class.getModule())"); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a logger without permission"); } @@ -433,8 +433,8 @@ boolean old = allowControl.get().get(); allowControl.get().set(true); try { - appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, DefaultLoggerFinderTest.class); - loggerDescMap.put(appLogger2, "provider.getLocalizedApplicationLogger(\"foo\", loggerBundle)"); + appLogger2 = provider.getLocalizedLogger("foo", loggerBundle, DefaultLoggerFinderTest.class.getModule()); + loggerDescMap.put(appLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, DefaultLoggerFinderTest.class.getModule())"); } finally { allowControl.get().set(old); } @@ -442,8 +442,8 @@ Logger sysLogger2 = null; try { - sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class); - loggerDescMap.put(sysLogger2, "provider.getLocalizedSystemLogger(\"foo\", loggerBundle)"); + sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class.getModule()); + loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class.getModule())"); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a system logger without permission"); } @@ -458,8 +458,8 @@ boolean old = allowControl.get().get(); allowControl.get().set(true); try { - sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class); - loggerDescMap.put(sysLogger2, "provider.getLocalizedSystemLogger(\"foo\", loggerBundle)"); + sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class.getModule()); + loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class.getModule())"); } finally { allowControl.get().set(old); } --- old/test/java/lang/System/LoggerFinder/internal/BaseDefaultLoggerFinderTest/BaseDefaultLoggerFinderTest.java 2016-04-15 16:33:13.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/internal/BaseDefaultLoggerFinderTest/BaseDefaultLoggerFinderTest.java 2016-04-15 16:33:12.000000000 +0200 @@ -55,6 +55,7 @@ import jdk.internal.logger.DefaultLoggerFinder; import jdk.internal.logger.SimpleConsoleLogger; import sun.util.logging.PlatformLogger; +import java.lang.reflect.Module; /** * @test @@ -112,10 +113,10 @@ public final static AtomicLong sequencer = new AtomicLong(); - public Logger getLogger(String name, Class caller); - public Logger getLocalizedLogger(String name, ResourceBundle bundle, Class caller); - void setLevel(Logger logger, Level level, Class caller); - void setLevel(Logger logger, PlatformLogger.Level level, Class caller); + public Logger getLogger(String name, Module caller); + public Logger getLocalizedLogger(String name, ResourceBundle bundle, Module caller); + void setLevel(Logger logger, Level level, Module caller); + void setLevel(Logger logger, PlatformLogger.Level level, Module caller); PlatformLogger.Bridge asPlatformLoggerBridge(Logger logger); } @@ -130,7 +131,7 @@ } @Override - public void setLevel(Logger logger, Level level, Class caller) { + public void setLevel(Logger logger, Level level, Module caller) { PrivilegedAction pa = () -> { setLevel(logger, PlatformLogger.toPlatformLevel(level), caller); return null; @@ -139,7 +140,7 @@ } @Override - public void setLevel(Logger logger, PlatformLogger.Level level, Class caller) { + public void setLevel(Logger logger, PlatformLogger.Level level, Module caller) { PrivilegedAction pa = () -> demandLoggerFor(logger.getName(), caller); Logger impl = AccessController.doPrivileged(pa); SimpleConsoleLogger.class.cast(impl) @@ -606,11 +607,12 @@ String name, ResourceBundle loggerBundle, Logger logger, - Class caller) { + Class callerClass) { System.out.println("Testing " + loggerDescMap.get(logger) + " [" + logger +"]"); AtomicLong sequencer = TestLoggerFinder.sequencer; + Module caller = callerClass.getModule(); Foo foo = new Foo(); String fooMsg = foo.toString(); for (Level loggerLevel : Level.values()) { --- old/test/java/lang/System/LoggerFinder/internal/BaseLoggerBridgeTest/BaseLoggerBridgeTest.java 2016-04-15 16:33:13.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/internal/BaseLoggerBridgeTest/BaseLoggerBridgeTest.java 2016-04-15 16:33:13.000000000 +0200 @@ -47,6 +47,7 @@ import java.lang.System.Logger; import java.lang.System.Logger.Level; import java.util.stream.Stream; +import java.lang.reflect.Module; /** * @test @@ -209,8 +210,6 @@ return Arrays.deepToString(toArray(false)); } - - @Override public boolean equals(Object obj) { return obj instanceof LogEvent @@ -342,15 +341,15 @@ } - public Logger getLogger(String name, Class caller); - public Logger getLocalizedLogger(String name, ResourceBundle bundle, Class caller); + public Logger getLogger(String name, Module caller); + public Logger getLocalizedLogger(String name, ResourceBundle bundle, Module caller); } public static class BaseLoggerFinder extends LoggerFinder implements TestLoggerFinder { static final RuntimePermission LOGGERFINDER_PERMISSION = new RuntimePermission("loggerFinder"); @Override - public Logger getLogger(String name, Class caller) { + public Logger getLogger(String name, Module caller) { SecurityManager sm = System.getSecurityManager(); if (sm != null) { sm.checkPermission(LOGGERFINDER_PERMISSION); @@ -375,7 +374,7 @@ } } - static Logger getLogger(String name, Class caller) { + static Logger getLogger(String name, Module caller) { boolean old = allowAll.get().get(); allowAccess.get().set(true); try { @@ -465,7 +464,7 @@ TestLoggerFinder.LoggerImpl appSink = null; try { - appSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerBridgeTest.class)); + appSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerBridgeTest.class.getModule())); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a system logger without permission"); } @@ -480,7 +479,7 @@ boolean old = allowControl.get().get(); allowControl.get().set(true); try { - appSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerBridgeTest.class)); + appSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", BaseLoggerBridgeTest.class.getModule())); } finally { allowControl.get().set(old); } @@ -489,7 +488,7 @@ TestLoggerFinder.LoggerImpl sysSink = null; try { - sysSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class)); + sysSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class.getModule())); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a system logger without permission"); } @@ -527,13 +526,13 @@ Logger sysLogger1 = null; try { - sysLogger1 = getLogger("foo", Thread.class); + sysLogger1 = getLogger("foo", Thread.class.getModule()); loggerDescMap.put(sysLogger1, - "jdk.internal.logger.LazyLoggers.getLogger(\"foo\", Thread.class)"); + "jdk.internal.logger.LazyLoggers.getLogger(\"foo\", Thread.class.getModule())"); if (!hasRequiredPermissions) { // check that the provider would have thrown an exception - provider.getLogger("foo", Thread.class); + provider.getLogger("foo", Thread.class.getModule()); throw new RuntimeException("Managed to obtain a system logger without permission"); } } catch (AccessControlException acx) { @@ -572,8 +571,8 @@ Logger sysLogger2 = null; try { - sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class); - loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class)"); + sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class.getModule()); + loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class.getModule())"); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a system logger without permission"); } --- old/test/java/lang/System/LoggerFinder/internal/BasePlatformLoggerTest/BasePlatformLoggerTest.java 2016-04-15 16:33:14.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/internal/BasePlatformLoggerTest/BasePlatformLoggerTest.java 2016-04-15 16:33:14.000000000 +0200 @@ -47,6 +47,7 @@ import java.security.AccessControlException; import java.util.stream.Stream; import sun.util.logging.PlatformLogger; +import java.lang.reflect.Module; /** * @test @@ -327,12 +328,12 @@ } } - public Logger getLogger(String name, Class caller); + public Logger getLogger(String name, Module caller); } public static class BaseLoggerFinder extends LoggerFinder implements TestLoggerFinder { @Override - public Logger getLogger(String name, Class caller) { + public Logger getLogger(String name, Module caller) { SecurityManager sm = System.getSecurityManager(); if (sm != null) { sm.checkPermission(LOGGERFINDER_PERMISSION); @@ -433,7 +434,7 @@ try { allowControl.get().set(true); appSink = TestLoggerFinder.LoggerImpl.class.cast( - provider.getLogger("foo", BasePlatformLoggerTest.class)); + provider.getLogger("foo", BasePlatformLoggerTest.class.getModule())); } finally { allowControl.get().set(before); } @@ -442,7 +443,8 @@ before = allowControl.get().get(); try { allowControl.get().set(true); - sysSink = TestLoggerFinder.LoggerImpl.class.cast(provider.getLogger("foo", Thread.class)); + sysSink = TestLoggerFinder.LoggerImpl.class.cast( + provider.getLogger("foo", Thread.class.getModule())); } finally { allowControl.get().set(before); } --- old/test/java/lang/System/LoggerFinder/internal/BootstrapLogger/BootstrapLoggerAPIsTest.java 2016-04-15 16:33:15.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/internal/BootstrapLogger/BootstrapLoggerAPIsTest.java 2016-04-15 16:33:15.000000000 +0200 @@ -30,7 +30,7 @@ import java.util.List; import java.util.ResourceBundle; import java.util.Set; - +import java.lang.reflect.Module; import jdk.internal.logger.BootstrapLogger; import jdk.internal.logger.LazyLoggers; @@ -69,7 +69,7 @@ } final Logger LOGGER = - LazyLoggers.getLogger("foo.bar", Thread.class); + LazyLoggers.getLogger("foo.bar", Thread.class.getModule()); final sun.util.logging.PlatformLogger.Level PLATFORM_LEVEL = sun.util.logging.PlatformLogger.Level.SEVERE; final MyResources BUNDLE = new MyResources(); --- old/test/java/lang/System/LoggerFinder/internal/BootstrapLogger/BootstrapLoggerTest.java 2016-04-15 16:33:16.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/internal/BootstrapLogger/BootstrapLoggerTest.java 2016-04-15 16:33:16.000000000 +0200 @@ -43,6 +43,7 @@ import java.util.stream.Stream; import jdk.internal.logger.BootstrapLogger; import jdk.internal.logger.LazyLoggers; +import java.lang.reflect.Module; /* * @test @@ -105,7 +106,7 @@ if (BootstrapLogger.isBooted()) { throw new RuntimeException("VM should not be booted!"); } - Logger logger = LazyLoggers.getLogger("foo.bar", Thread.class); + Logger logger = LazyLoggers.getLogger("foo.bar", Thread.class.getModule()); if (test != TestCase.NO_SECURITY) { LogStream.err.println("Setting security manager"); @@ -261,7 +262,7 @@ SimplePolicy.allowAll.set(Boolean.TRUE); try { bazbaz = java.lang.System.LoggerFinder - .getLoggerFinder().getLogger("foo.bar.baz.baz", BootstrapLoggerTest.class); + .getLoggerFinder().getLogger("foo.bar.baz.baz", BootstrapLoggerTest.class.getModule()); } finally { SimplePolicy.allowAll.set(Boolean.FALSE); } --- old/test/java/lang/System/LoggerFinder/internal/LoggerBridgeTest/LoggerBridgeTest.java 2016-04-15 16:33:16.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/internal/LoggerBridgeTest/LoggerBridgeTest.java 2016-04-15 16:33:16.000000000 +0200 @@ -51,6 +51,7 @@ import java.lang.System.Logger.Level; import java.util.stream.Stream; import sun.util.logging.PlatformLogger; +import java.lang.reflect.Module; /** * @test @@ -164,6 +165,7 @@ null, null, level, bundle, key, thrown, params); } + public static LogEvent of(long sequenceNumber, boolean isLoggable, String name, sun.util.logging.PlatformLogger.Level level, ResourceBundle bundle, @@ -231,7 +233,7 @@ try { // Preload classes before the security manager is on. providerClass = ClassLoader.getSystemClassLoader().loadClass("LoggerBridgeTest$LogProducerFinder"); - ((LoggerFinder)providerClass.newInstance()).getLogger("foo", providerClass); + ((LoggerFinder)providerClass.newInstance()).getLogger("foo", providerClass.getModule()); } catch (Exception ex) { throw new ExceptionInInitializerError(ex); } @@ -415,7 +417,7 @@ } @Override - public Logger getLogger(String name, Class caller) { + public Logger getLogger(String name, Module caller) { SecurityManager sm = System.getSecurityManager(); if (sm != null) { sm.checkPermission(LOGGERFINDER_PERMISSION); @@ -430,6 +432,15 @@ } } + static ClassLoader getClassLoader(Module m) { + final boolean before = allowAll.get().getAndSet(true); + try { + return m.getClassLoader(); + } finally { + allowAll.get().set(before); + } + } + static final sun.util.logging.PlatformLogger.Level[] julLevels = { sun.util.logging.PlatformLogger.Level.ALL, sun.util.logging.PlatformLogger.Level.FINEST, @@ -497,14 +508,14 @@ try { Class bridgeClass = Class.forName("jdk.internal.logger.LazyLoggers"); lazyGetLogger = bridgeClass.getDeclaredMethod("getLogger", - String.class, Class.class); + String.class, Module.class); lazyGetLogger.setAccessible(true); } catch (Throwable ex) { throw new ExceptionInInitializerError(ex); } } - static Logger getLogger(LoggerFinder provider, String name, Class caller) { + static Logger getLogger(LoggerFinder provider, String name, Module caller) { Logger logger; try { logger = Logger.class.cast(lazyGetLogger.invoke(null, name, caller)); @@ -522,14 +533,14 @@ // The method above does not throw exception... // call the provider here to verify that an exception would have // been thrown by the provider. - if (logger != null && caller == Thread.class) { + if (logger != null && caller == Thread.class.getModule()) { Logger log = provider.getLogger(name, caller); } return logger; } - static Logger getLogger(LoggerFinder provider, String name, ResourceBundle bundle, Class caller) { - if (caller.getClassLoader() != null) { + static Logger getLogger(LoggerFinder provider, String name, ResourceBundle bundle, Module caller) { + if (getClassLoader(caller) != null) { return System.getLogger(name,bundle); } else { return provider.getLocalizedLogger(name, bundle, caller); @@ -614,12 +625,12 @@ Logger appLogger1 = System.getLogger("foo"); - loggerDescMap.put(appLogger1, "LogProducer.getApplicationLogger(\"foo\")"); + loggerDescMap.put(appLogger1, "System.getLogger(\"foo\")"); Logger sysLogger1 = null; try { - sysLogger1 = getLogger(provider, "foo", Thread.class); - loggerDescMap.put(sysLogger1, "LogProducer.getSystemLogger(\"foo\")"); + sysLogger1 = getLogger(provider, "foo", Thread.class.getModule()); + loggerDescMap.put(sysLogger1, "provider.getLogger(\"foo\", Thread.class.getModule())"); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a system logger without permission"); } @@ -636,12 +647,12 @@ Logger appLogger2 = System.getLogger("foo", loggerBundle); - loggerDescMap.put(appLogger2, "LogProducer.getApplicationLogger(\"foo\", loggerBundle)"); + loggerDescMap.put(appLogger2, "System.getLogger(\"foo\", loggerBundle)"); Logger sysLogger2 = null; try { - sysLogger2 = getLogger(provider, "foo", loggerBundle, Thread.class); - loggerDescMap.put(sysLogger2, "provider.getSystemLogger(\"foo\", loggerBundle)"); + sysLogger2 = getLogger(provider, "foo", loggerBundle, Thread.class.getModule()); + loggerDescMap.put(sysLogger2, "provider.getLogger(\"foo\", loggerBundle, Thread.class.getModule())"); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a system logger without permission"); } @@ -671,9 +682,9 @@ allowControl.get().set(true); try { appSink = LogProducerFinder.LoggerImpl.class.cast( - provider.getLogger("foo", LoggerBridgeTest.class)); + provider.getLogger("foo", LoggerBridgeTest.class.getModule())); sysSink = LogProducerFinder.LoggerImpl.class.cast( - provider.getLogger("foo", Thread.class)); + provider.getLogger("foo", Thread.class.getModule())); } finally { allowControl.get().set(old); } --- old/test/java/lang/System/LoggerFinder/internal/LoggerFinderLoaderTest/LoggerFinderLoaderTest.java 2016-04-15 16:33:17.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/internal/LoggerFinderLoaderTest/LoggerFinderLoaderTest.java 2016-04-15 16:33:17.000000000 +0200 @@ -53,6 +53,7 @@ import java.util.ServiceLoader; import java.util.concurrent.atomic.AtomicReference; import jdk.internal.logger.SimpleConsoleLogger; +import java.lang.reflect.Module; /** * @test @@ -166,8 +167,8 @@ } - public Logger getLogger(String name, Class caller); - public Logger getLocalizedLogger(String name, ResourceBundle bundle, Class caller); + public Logger getLogger(String name, Module caller); + public Logger getLocalizedLogger(String name, ResourceBundle bundle, Module caller); } public static class BaseLoggerFinder extends LoggerFinder implements TestLoggerFinder { @@ -187,7 +188,7 @@ @Override - public Logger getLogger(String name, Class caller) { + public Logger getLogger(String name, Module caller) { SecurityManager sm = System.getSecurityManager(); if (sm != null) { sm.checkPermission(LOGGERFINDER_PERMISSION); @@ -210,7 +211,7 @@ throw new ServiceConfigurationError("Should not come here"); } @Override - public Logger getLogger(String name, Class caller) { + public Logger getLogger(String name, Module caller) { throw new ServiceConfigurationError("Should not come here"); } } --- old/test/java/lang/System/LoggerFinder/internal/PlatformLoggerBridgeTest/PlatformLoggerBridgeTest.java 2016-04-15 16:33:18.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/internal/PlatformLoggerBridgeTest/PlatformLoggerBridgeTest.java 2016-04-15 16:33:18.000000000 +0200 @@ -49,6 +49,7 @@ import java.lang.System.Logger.Level; import java.util.stream.Stream; import sun.util.logging.PlatformLogger; +import java.lang.reflect.Module; /** * @test @@ -94,7 +95,7 @@ try { // Preload classes before the security manager is on. providerClass = ClassLoader.getSystemClassLoader().loadClass("PlatformLoggerBridgeTest$LogProducerFinder"); - ((LoggerFinder)providerClass.newInstance()).getLogger("foo", providerClass); + ((LoggerFinder)providerClass.newInstance()).getLogger("foo", providerClass.getModule()); } catch (Exception ex) { throw new ExceptionInInitializerError(ex); } @@ -415,7 +416,7 @@ } @Override - public Logger getLogger(String name, Class caller) { + public Logger getLogger(String name, Module caller) { SecurityManager sm = System.getSecurityManager(); if (sm != null) { sm.checkPermission(LOGGERFINDER_PERMISSION); @@ -598,7 +599,7 @@ allowControl.get().set(true); try { sysSink = LogProducerFinder.LoggerImpl.class.cast( - provider.getLogger("foo", Thread.class)); + provider.getLogger("foo", Thread.class.getModule())); } finally { allowControl.get().set(old); } --- old/test/java/lang/System/LoggerFinder/internal/api/LoggerFinderAPITest.java 2016-04-15 16:33:19.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/internal/api/LoggerFinderAPITest.java 2016-04-15 16:33:19.000000000 +0200 @@ -469,12 +469,12 @@ errors.append(test.testGetLoggerOverriddenOnSpi()); java.lang.System.Logger julLogger = java.lang.System.LoggerFinder.getLoggerFinder() - .getLogger("foo", LoggerFinderAPITest.class); + .getLogger("foo", LoggerFinderAPITest.class.getModule()); errors.append(test.testDefaultJULLogger(julLogger)); if (errors.length() > 0) throw new RuntimeException(errors.toString()); java.lang.System.Logger julSystemLogger = java.lang.System.LoggerFinder.getLoggerFinder() - .getLogger("bar", Thread.class); + .getLogger("bar", Thread.class.getModule()); errors.append(test.testDefaultJULLogger(julSystemLogger)); if (errors.length() > 0) throw new RuntimeException(errors.toString()); java.lang.System.Logger julLocalizedLogger = @@ -482,7 +482,7 @@ System.getLogger("baz", bundleLocalized); java.lang.System.Logger julLocalizedSystemLogger = java.lang.System.LoggerFinder.getLoggerFinder() - .getLocalizedLogger("oof", bundleLocalized, Thread.class); + .getLocalizedLogger("oof", bundleLocalized, Thread.class.getModule()); final String error = errors.toString(); if (!error.isEmpty()) throw new RuntimeException(error); for (java.lang.System.Logger logger : new java.lang.System.Logger[] { --- old/test/java/lang/System/LoggerFinder/internal/backend/LoggerFinderBackendTest.java 2016-04-15 16:33:20.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/internal/backend/LoggerFinderBackendTest.java 2016-04-15 16:33:19.000000000 +0200 @@ -77,6 +77,7 @@ import java.util.logging.LogRecord; import java.util.logging.Logger; import sun.util.logging.internal.LoggingProviderImpl; +import java.lang.reflect.Module; /** * @author danielfuchs @@ -1506,7 +1507,7 @@ Logger getBackendLogger(String name) { if (isSystem) { return LoggingProviderImpl.getLogManagerAccess().demandLoggerFor( - LogManager.getLogManager(), name, Thread.class); + LogManager.getLogManager(), name, Thread.class.getModule()); } else { return Logger.getLogger(name); } @@ -1699,7 +1700,7 @@ Collections.synchronizedMap(new HashMap<>()); @Override - public java.lang.System.Logger getLogger(String name, Class caller) { + public java.lang.System.Logger getLogger(String name, Module caller) { ClassLoader callerLoader = caller.getClassLoader(); if (callerLoader == null) { systemLoggers.putIfAbsent(name, new CustomLogger(name)); @@ -1827,8 +1828,8 @@ public void setLevel(java.lang.System.Logger logger, Level level) { final CustomLoggerFinder.CustomLogger l = (CustomLoggerFinder.CustomLogger) - (isSystem ? provider.getLogger(logger.getName(), Thread.class) : - provider.getLogger(logger.getName(), LoggerFinderBackendTest.class)); + (isSystem ? provider.getLogger(logger.getName(), Thread.class.getModule()) : + provider.getLogger(logger.getName(), LoggerFinderBackendTest.class.getModule())); l.setLevel(provider.fromJul(level)); } @Override @@ -1840,8 +1841,8 @@ CustomLoggerFinder.CustomLevel getLevel(java.lang.System.Logger logger) { final CustomLoggerFinder.CustomLogger l = (CustomLoggerFinder.CustomLogger) - (isSystem ? provider.getLogger(logger.getName(), Thread.class) : - provider.getLogger(logger.getName(), LoggerFinderBackendTest.class)); + (isSystem ? provider.getLogger(logger.getName(), Thread.class.getModule()) : + provider.getLogger(logger.getName(), LoggerFinderBackendTest.class.getModule())); return l.level; } @@ -1962,7 +1963,7 @@ try { Class lazyLoggers = jdk.internal.logger.LazyLoggers.class; getLazyLogger = lazyLoggers.getMethod("getLazyLogger", - String.class, Class.class); + String.class, Module.class); getLazyLogger.setAccessible(true); Class loggerFinderLoader = Class.forName("java.lang.System$LoggerFinder"); @@ -1973,7 +1974,7 @@ } } - static java.lang.System.Logger getSystemLogger(String name, Class caller) throws Exception { + static java.lang.System.Logger getSystemLogger(String name, Module caller) throws Exception { try { return java.lang.System.Logger.class.cast(getLazyLogger.invoke(null, name, caller)); } catch (InvocationTargetException x) { @@ -1986,7 +1987,7 @@ } } static java.lang.System.Logger getSystemLogger(String name, - ResourceBundle bundle, Class caller) throws Exception { + ResourceBundle bundle, Module caller) throws Exception { try { LoggerFinder provider = LoggerFinder.class.cast(accessLoggerFinder.invoke(null)); return provider.getLocalizedLogger(name, bundle, caller); @@ -2047,14 +2048,14 @@ final BackendTester tester = factory.createBackendTester(false); final java.lang.System.Logger logger = java.lang.System.LoggerFinder.getLoggerFinder() - .getLogger("foo", LoggerFinderBackendTest.class); + .getLogger("foo", LoggerFinderBackendTest.class.getModule()); testLogger(tester, logger, nb); // Test a simple system logger with JUL backend final java.lang.System.Logger system = java.lang.System.LoggerFinder.getLoggerFinder() - .getLogger("bar", Thread.class); + .getLogger("bar", Thread.class.getModule()); final BackendTester systemTester = factory.createBackendTester(true); testLogger(systemTester, system, nb); @@ -2062,7 +2063,7 @@ // JUL backend final java.lang.System.Logger noBundleLogger = java.lang.System.LoggerFinder.getLoggerFinder() - .getLocalizedLogger("baz", null, LoggerFinderBackendTest.class); + .getLocalizedLogger("baz", null, LoggerFinderBackendTest.class.getModule()); final BackendTester noBundleTester = factory.createBackendTester(false, spiLoggerClass); testLogger(noBundleTester, noBundleLogger, nb); @@ -2071,7 +2072,7 @@ // backend final java.lang.System.Logger noBundleSysLogger = java.lang.System.LoggerFinder.getLoggerFinder() - .getLocalizedLogger("oof", null, Thread.class); + .getLocalizedLogger("oof", null, Thread.class.getModule()); final BackendTester noBundleSysTester = factory.createBackendTester(true, spiLoggerClass); testLogger(noBundleSysTester, noBundleSysLogger, nb); @@ -2085,14 +2086,14 @@ System.out.println("System.Loggers.getLogger(\"baz\", null): got expected " + x); } final java.lang.System.Logger noBundleExtensionLogger = - getSystemLogger("baz", null, LoggerFinderBackendTest.class); + getSystemLogger("baz", null, LoggerFinderBackendTest.class.getModule()); final BackendTester noBundleExtensionTester = factory.createBackendTester(false, jdkLoggerClass); testLogger(noBundleExtensionTester, noBundleExtensionLogger, nb); // Test a simple system logger with JUL backend final java.lang.System.Logger sysExtensionLogger = - getSystemLogger("oof", Thread.class); + getSystemLogger("oof", Thread.class.getModule()); final BackendTester sysExtensionTester = factory.createBackendTester(true, jdkLoggerClass); testLogger(sysExtensionTester, sysExtensionLogger, nb); @@ -2100,7 +2101,7 @@ // Test a localized system logger with null resource bundle and JUL // backend final java.lang.System.Logger noBundleSysExtensionLogger = - getSystemLogger("oof", null, Thread.class); + getSystemLogger("oof", null, Thread.class.getModule()); final BackendTester noBundleSysExtensionTester = factory.createBackendTester(true, jdkLoggerClass); testLogger(noBundleSysExtensionTester, noBundleSysExtensionLogger, nb); @@ -2127,7 +2128,7 @@ ResourceBundle.getBundle(ResourceBundeLocalized.class.getName()); final java.lang.System.Logger bundleLogger = java.lang.System.LoggerFinder.getLoggerFinder() - .getLocalizedLogger("toto", bundle, LoggerFinderBackendTest.class); + .getLocalizedLogger("toto", bundle, LoggerFinderBackendTest.class.getModule()); final BackendTester bundleTester = factory.createBackendTester(false, spiLoggerClass, bundle); testLogger(bundleTester, bundleLogger, nb); @@ -2135,7 +2136,7 @@ // Test a localized system logger with resource bundle and JUL backend final java.lang.System.Logger bundleSysLogger = java.lang.System.LoggerFinder.getLoggerFinder() - .getLocalizedLogger("titi", bundle, Thread.class); + .getLocalizedLogger("titi", bundle, Thread.class.getModule()); final BackendTester bundleSysTester = factory.createBackendTester(true, spiLoggerClass, bundle); testLogger(bundleSysTester, bundleSysLogger, nb); @@ -2151,7 +2152,7 @@ // Test a localized Jdk system logger with resource bundle and JUL // backend final java.lang.System.Logger bundleExtensionSysLogger = - getSystemLogger("titu", bundle, Thread.class); + getSystemLogger("titu", bundle, Thread.class.getModule()); final BackendTester bundleExtensionSysTester = factory.createBackendTester(true, jdkLoggerClass, bundle); testLogger(bundleExtensionSysTester, bundleExtensionSysLogger, nb); --- old/test/java/lang/System/LoggerFinder/jdk/DefaultLoggerBridgeTest/DefaultLoggerBridgeTest.java 2016-04-15 16:33:20.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/jdk/DefaultLoggerBridgeTest/DefaultLoggerBridgeTest.java 2016-04-15 16:33:20.000000000 +0200 @@ -48,6 +48,7 @@ import java.lang.System.Logger; import java.util.stream.Stream; import sun.util.logging.internal.LoggingProviderImpl; +import java.lang.reflect.Module; /** * @test @@ -246,7 +247,7 @@ } } - static Logger getLogger(String name, Class caller) { + static Logger getLogger(String name, Module caller) { boolean old = allowAccess.get().get(); allowAccess.get().set(true); try { @@ -311,8 +312,8 @@ ResourceBundle.getBundle(MyLoggerBundle.class.getName()); final Map loggerDescMap = new HashMap<>(); - Logger sysLogger1a = getLogger("foo", Thread.class); - loggerDescMap.put(sysLogger1a, "jdk.internal.logger.LazyLoggers.getLogger(\"foo\", Thread.class)"); + Logger sysLogger1a = getLogger("foo", Thread.class.getModule()); + loggerDescMap.put(sysLogger1a, "jdk.internal.logger.LazyLoggers.getLogger(\"foo\", Thread.class.getModule())"); Logger appLogger1 = System.getLogger("foo"); loggerDescMap.put(appLogger1, "System.getLogger(\"foo\")"); @@ -341,9 +342,9 @@ Logger sysLogger1b = null; try { - sysLogger1b = provider.getLogger("foo", Thread.class); + sysLogger1b = provider.getLogger("foo", Thread.class.getModule()); if (sysLogger1b != sysLogger1a) { - loggerDescMap.put(sysLogger1b, "provider.getLogger(\"foo\", Thread.class)"); + loggerDescMap.put(sysLogger1b, "provider.getLogger(\"foo\", Thread.class.getModule())"); } if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a system logger without permission"); @@ -367,8 +368,8 @@ Logger sysLogger2 = null; try { - sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class); - loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class)"); + sysLogger2 = provider.getLocalizedLogger("foo", loggerBundle, Thread.class.getModule()); + loggerDescMap.put(sysLogger2, "provider.getLocalizedLogger(\"foo\", loggerBundle, Thread.class.getModule())"); if (!hasRequiredPermissions) { throw new RuntimeException("Managed to obtain a system logger without permission"); } @@ -396,9 +397,9 @@ allowAll.get().set(true); try { sysSink = LoggingProviderImpl.getLogManagerAccess().demandLoggerFor( - LogManager.getLogManager(), "foo", Thread.class); + LogManager.getLogManager(), "foo", Thread.class.getModule()); appSink = LoggingProviderImpl.getLogManagerAccess().demandLoggerFor( - LogManager.getLogManager(), "foo", DefaultLoggerBridgeTest.class); + LogManager.getLogManager(), "foo", DefaultLoggerBridgeTest.class.getModule()); if (appSink == sysSink) { throw new RuntimeException("identical backend loggers"); } --- old/test/java/lang/System/LoggerFinder/jdk/DefaultPlatformLoggerTest/DefaultPlatformLoggerTest.java 2016-04-15 16:33:21.000000000 +0200 +++ new/test/java/lang/System/LoggerFinder/jdk/DefaultPlatformLoggerTest/DefaultPlatformLoggerTest.java 2016-04-15 16:33:21.000000000 +0200 @@ -44,6 +44,7 @@ import java.lang.System.LoggerFinder; import sun.util.logging.PlatformLogger; import sun.util.logging.internal.LoggingProviderImpl; +import java.lang.reflect.Module; /** * @test @@ -244,9 +245,9 @@ LoggerFinder provider = LoggerFinder.getLoggerFinder(); java.util.logging.Logger appSink = LoggingProviderImpl.getLogManagerAccess() .demandLoggerFor(LogManager.getLogManager(), "foo", - DefaultPlatformLoggerTest.class); + DefaultPlatformLoggerTest.class.getModule()); java.util.logging.Logger sysSink = LoggingProviderImpl.getLogManagerAccess() - .demandLoggerFor(LogManager.getLogManager(),"foo", Thread.class); + .demandLoggerFor(LogManager.getLogManager(),"foo", Thread.class.getModule()); appSink.addHandler(new MyHandler()); sysSink.addHandler(new MyHandler()); appSink.setUseParentHandlers(VERBOSE); --- old/test/sun/util/logging/PlatformLoggerTest.java 2016-04-15 16:33:22.000000000 +0200 +++ new/test/sun/util/logging/PlatformLoggerTest.java 2016-04-15 16:33:22.000000000 +0200 @@ -197,7 +197,7 @@ // create a brand new java logger Logger javaLogger = sun.util.logging.internal.LoggingProviderImpl.getLogManagerAccess() .demandLoggerFor(LogManager.getLogManager(), - logger.getName()+"."+level.getName(), Thread.class); + logger.getName()+"."+level.getName(), Thread.class.getModule()); // Set a non standard java.util.logging.Level on the java logger // (except for OFF & ALL - which will remain unchanged)