DevTools: Decouple shortcuts from actions, introduce shortcut contexts

Source/devtools/front_end/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;
+    var conjunction = !!extension.descriptor()["contextTypeConjunction"];

[pfeldman, 2014/04/17 10:40:25]

I don't see it used. Lets not add it for now.

[apavlov, 2014/04/17 12:42:22]

Done.

+    for (var i = 0; i < contextTypes.length; ++i) {
+        var contextType = /** @type {!Function} */ (window.eval(contextTypes[i]));
+        var isMatching = predicate(contextType);
+        if (conjunction && !isMatching)
+            return false;
+        if (!conjunction && isMatching)
+            return true;
+    }
+    return conjunction;
+}
+
+/**
+ * @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 258 matching lines @@
             return null;
         return this._module._manager.resolve(this._type);
     },
 
     /**
      * @param {?Object} context
      * @return {boolean}
      */
     isApplicable: function(context)
     {
-        var contextTypes = /** @type {!Array.<string>|undefined} */ (this._descriptor.contextTypes);
-        if (!contextTypes)
-            return true;
-        for (var i = 0; i < contextTypes.length; ++i) {
-            var contextType = /** @type {!Function} */ (window.eval(contextTypes[i]));
-            if (context instanceof contextType)
-                return true;
-        }
-        return false;
+        return WebInspector.ModuleManager.isExtensionApplicableToContext(this, context);
     },
 
     /**
      * @return {?Object}
      */
     instance: function()
     {
         if (!this._className)
             return null;
 
@@ skipping 45 matching lines @@
         revealer.reveal(revealable, lineNumber);
 }
 
 WebInspector.Revealer.prototype = {
     /**
      * @param {!Object} object
      */
     reveal: function(object) {}
 }
 
-/**
- * @interface
- */
-WebInspector.ActionDelegate = function()
-{
-}
-
-WebInspector.ActionDelegate.prototype = {
-    /**
-     * @param {!Event} event
-     * @return {boolean}
-     */
-    handleAction: function(event) {}
-}
-
 WebInspector.moduleManager = new WebInspector.ModuleManager(allDescriptors);