DevTools: Get rid of WebInspector.panels

Source/devtools/front_end/common/ModuleManager.js

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 42 matching lines @@
     this._cachedTypeClasses = {};
 
     /**
      * @type {!Object.<string, !WebInspector.ModuleManager.ModuleDescriptor>}
      */
     this._descriptorsMap = {};
     for (var i = 0; i < descriptors.length; ++i)
         this._descriptorsMap[descriptors[i]["name"]] = descriptors[i];
 }
 
-/**
- * @param {!WebInspector.ModuleManager.Extension} extension
- * @param {?function(!Function):boolean} predicate
- */
-WebInspector.ModuleManager._checkExtensionApplicability = function(extension, predicate)
-{
-    if (!predicate)
-        return false;
-    var contextTypes = /** @type {!Array.<string>|undefined} */ (extension.descriptor().contextTypes);
-    if (!contextTypes)
-        return true;
-    for (var i = 0; i < contextTypes.length; ++i) {
-        var contextType = /** @type {!Function} */ (window.eval(contextTypes[i]));
-        var isMatching = predicate(contextType);
-        if (isMatching)
-            return true;
-    }
-    return false;
-}
-
-/**
- * @param {!WebInspector.ModuleManager.Extension} extension
- * @param {?Object} context
- * @return {boolean}
- */
-WebInspector.ModuleManager.isExtensionApplicableToContext = function(extension, context)
-{
-    if (!context)
-        return true;
-    return WebInspector.ModuleManager._checkExtensionApplicability(extension, isInstanceOf);
-
-    /**
-     * @param {!Function} targetType
-     * @return {boolean}
-     */
-    function isInstanceOf(targetType)
-    {
-        return context instanceof targetType;
-    }
-}
-
-/**
- * @param {!WebInspector.ModuleManager.Extension} extension
- * @param {!Set.<!Function>=} currentContextTypes
- * @return {boolean}
- */
-WebInspector.ModuleManager.isExtensionApplicableToContextTypes = function(extension, currentContextTypes)
-{
-    if (!extension.descriptor().contextTypes)
-        return true;
-
-    return WebInspector.ModuleManager._checkExtensionApplicability(extension, currentContextTypes ? isContextTypeKnown : null);
-
-    /**
-     * @param {!Function} targetType
-     * @return {boolean}
-     */
-    function isContextTypeKnown(targetType)
-    {
-        return currentContextTypes.contains(targetType);
-    }
-}
-
 WebInspector.ModuleManager.prototype = {
     /**
      * @param {!Array.<string>} configuration
      */
     registerModules: function(configuration)
     {
         for (var i = 0; i < configuration.length; ++i)
             this.registerModule(configuration[i]);
     },
 
@@ skipping 17 matching lines @@
 
     /**
      * @param {string} moduleName
      */
     loadModule: function(moduleName)
     {
         this._modulesMap[moduleName]._load();
     },
 
     /**
+     * @param {!WebInspector.ModuleManager.Extension} extension
+     * @param {?function(function(new:Object)):boolean} predicate
+     * @return {boolean}
+     */
+    _checkExtensionApplicability: function(extension, predicate)
+    {
+        if (!predicate)
+            return false;
+        var contextTypes = /** @type {!Array.<string>|undefined} */ (extension.descriptor().contextTypes);
+        if (!contextTypes)
+            return true;
+        for (var i = 0; i < contextTypes.length; ++i) {
+            var contextType = this._resolve(contextTypes[i]);
+            var isMatching = !!contextType && predicate(contextType);
+            if (isMatching)
+                return true;
+        }
+        return false;
+    },
+
+    /**
+     * @param {!WebInspector.ModuleManager.Extension} extension
+     * @param {?Object} context
+     * @return {boolean}
+     */
+    isExtensionApplicableToContext: function(extension, context)
+    {
+        if (!context)
+            return true;
+        return this._checkExtensionApplicability(extension, isInstanceOf);
+
+        /**
+         * @param {!Function} targetType
+         * @return {boolean}
+         */
+        function isInstanceOf(targetType)
+        {
+            return context instanceof targetType;
+        }
+    },
+
+    /**
+     * @param {!WebInspector.ModuleManager.Extension} extension
+     * @param {!Set.<!Function>=} currentContextTypes
+     * @return {boolean}
+     */
+    isExtensionApplicableToContextTypes: function(extension, currentContextTypes)
+    {
+        if (!extension.descriptor().contextTypes)
+            return true;
+
+        return this._checkExtensionApplicability(extension, currentContextTypes ? isContextTypeKnown : null);
+
+        /**
+         * @param {!Function} targetType
+         * @return {boolean}
+         */
+        function isContextTypeKnown(targetType)
+        {
+            return currentContextTypes.contains(targetType);
+        }
+    },
+
+    /**
      * @param {string|!Function} type
      * @param {?Object=} context
      * @return {!Array.<!WebInspector.ModuleManager.Extension>}
      */
     extensions: function(type, context)
     {
         /**
          * @param {!WebInspector.ModuleManager.Extension} extension
          * @return {boolean}
          */
@@ skipping 73 matching lines @@
             if (name2 in orderForName)
                 return 1;
             return name1.compareTo(name2);
         }
         return result;
     },
 
     /**
      * @return {?function(new:Object)}
      */
-    resolve: function(typeName)
+    _resolve: function(typeName)
     {
         if (!this._cachedTypeClasses[typeName]) {
-            var path = typeName.substring(1).split(".");
+            var path = typeName.split(".");
             var object = window;
             for (var i = 0; object && (i < path.length); ++i)
                 object = object[path[i]];
             if (object)
                 this._cachedTypeClasses[typeName] = /** @type function(new:Object) */(object);
         }
         return this._cachedTypeClasses[typeName];
     }
-
 }
 
 /**
  * @constructor
  */
 WebInspector.ModuleManager.ModuleDescriptor = function()
 {
     /**
      * @type {string}
      */
@@ skipping 122 matching lines @@
         return this._module;
     },
 
     /**
      * @return {?function(new:Object)}
      */
     _typeClass: function()
     {
         if (!this._hasTypeClass)
             return null;
-        return this._module._manager.resolve(this._type);
+        return this._module._manager._resolve(this._type.substring(1));
     },
 
     /**
      * @param {?Object} context
      * @return {boolean}
      */
     isApplicable: function(context)
     {
-        return WebInspector.ModuleManager.isExtensionApplicableToContext(this, context);
+        return this._module._manager.isExtensionApplicableToContext(this, context);
     },
 
     /**
      * @return {?Object}
      */
     instance: function()
     {
         if (!this._className)
             return null;
 
@@ skipping 46 matching lines @@
 }
 
 WebInspector.Revealer.prototype = {
     /**
      * @param {!Object} object
      */
     reveal: function(object) {}
 }
 
 WebInspector.moduleManager = new WebInspector.ModuleManager(allDescriptors);