[DevTools] Replace the target type with capabilities

third_party/WebKit/Source/devtools/front_end/sdk/TargetManager.js

 /*
  * Copyright 2014 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /**
  * @constructor
  * @extends {WebInspector.Object}
  */
 WebInspector.TargetManager = function()
 {
     WebInspector.Object.call(this);
     /** @type {!Array.<!WebInspector.Target>} */
     this._targets = [];
     /** @type {!Array.<!WebInspector.TargetManager.Observer>} */
     this._observers = [];
-    this._observerTypeSymbol = Symbol("observerType");
+    this._observerCapabiliesMaskSymbol = Symbol("observerCapabilitiesMask");
     /** @type {!Object.<string, !Array.<{modelClass: !Function, thisObject: (!Object|undefined), listener: function(!WebInspector.Event)}>>} */
     this._modelListeners = {};
     this._isSuspended = false;
 }
 
 WebInspector.TargetManager.Events = {
     InspectedURLChanged: "InspectedURLChanged",
     MainFrameNavigated: "MainFrameNavigated",
     Load: "Load",
     PageReloadRequested: "PageReloadRequested",
@@ skipping 127 matching lines @@
         for (var i = 0; i < listeners.length; ++i) {
             if (listeners[i].modelClass === modelClass && listeners[i].listener === listener && listeners[i].thisObject === thisObject)
                 listeners.splice(i--, 1);
         }
         if (!listeners.length)
             delete this._modelListeners[eventType];
     },
 
     /**
      * @param {!WebInspector.TargetManager.Observer} targetObserver
-     * @param {number=} type
+     * @param {number=} capabilitiesMask
      */
-    observeTargets: function(targetObserver, type)
+    observeTargets: function(targetObserver, capabilitiesMask)
     {
-        if (this._observerTypeSymbol in targetObserver)
+        if (this._observerCapabiliesMaskSymbol in targetObserver)
             throw new Error("Observer can only be registered once");
-        targetObserver[this._observerTypeSymbol] = type || 0x7fff;
-        this.targets(type).forEach(targetObserver.targetAdded.bind(targetObserver));
+        targetObserver[this._observerCapabiliesMaskSymbol] = capabilitiesMask || 0;
+        this.targets(capabilitiesMask).forEach(targetObserver.targetAdded.bind(targetObserver));
         this._observers.push(targetObserver);
     },
 
     /**
      * @param {!WebInspector.TargetManager.Observer} targetObserver
      */
     unobserveTargets: function(targetObserver)
     {
-        delete targetObserver[this._observerTypeSymbol];
+        delete targetObserver[this._observerCapabiliesMaskSymbol];
         this._observers.remove(targetObserver);
     },
 
     /**
      * @param {string} name
-     * @param {number} type
+     * @param {number} capabilitiesMask
      * @param {!InspectorBackendClass.Connection} connection
      * @param {?WebInspector.Target} parentTarget
      * @return {!WebInspector.Target}
      */
-    createTarget: function(name, type, connection, parentTarget)
+    createTarget: function(name, capabilitiesMask, connection, parentTarget)
     {
-        var target = new WebInspector.Target(this, name, type, connection, parentTarget);
+        var target = new WebInspector.Target(this, name, capabilitiesMask, connection, parentTarget);
 
         /** @type {!WebInspector.ConsoleModel} */
         target.consoleModel = new WebInspector.ConsoleModel(target);
 
         var networkManager = null;
-        if (!target.isJSInspector())
+        if (target.hasNetworkDomains())
             networkManager = new WebInspector.NetworkManager(target);
 
         /** @type {!WebInspector.ResourceTreeModel} */
         target.resourceTreeModel = new WebInspector.ResourceTreeModel(target, networkManager);
 
         if (networkManager)
             new WebInspector.NetworkLog(target, networkManager);
 
         /** @type {!WebInspector.RuntimeModel} */
         target.runtimeModel = new WebInspector.RuntimeModel(target);
-        if (target.hasJSContext())
+        if (target.hasJSDomains())
             new WebInspector.DebuggerModel(target);
 
-        if (target.type() === WebInspector.Target.Type.Page) {
+        if (target.hasBrowserDomains()) {
             new WebInspector.DOMModel(target);
             new WebInspector.CSSModel(target);
         }
 
         /** @type {?WebInspector.WorkerManager} */
-        target.workerManager = target.supportsWorkers() ? new WebInspector.WorkerManager(target) : null;
+        target.workerManager = target.hasWorkerDomains() ? new WebInspector.WorkerManager(target) : null;
         /** @type {!WebInspector.CPUProfilerModel} */
         target.cpuProfilerModel = new WebInspector.CPUProfilerModel(target);
         /** @type {!WebInspector.HeapProfilerModel} */
         target.heapProfilerModel = new WebInspector.HeapProfilerModel(target);
 
         target.tracingManager = new WebInspector.TracingManager(target);
 
-        if (target.isPage())
+        if (target.hasBrowserDomains())
             target.serviceWorkerManager = new WebInspector.ServiceWorkerManager(target);
 
         this.addTarget(target);
         return target;
     },
 
     /**
-     * @param {number} type
+     * Returns observers matching the capabilities mask.

[dgozman, 2016/07/12 00:34:11]

We don't usually put comments like this and rely on the good method name.

[eostroukhov-old, 2016/07/12 21:46:16]

Done.

+     * @param {number} capabilitiesMask
      * @return {!Array<!WebInspector.TargetManager.Observer>}
      */
-    _observersByType: function(type)
+    _observersForMask: function(capabilitiesMask)
     {
         var result = [];
         for (var observer of this._observers) {
-            if (observer[this._observerTypeSymbol] & type)
+            var observerMask = observer[this._observerCapabiliesMaskSymbol];
+            // All bits should match
+            if ((observerMask & capabilitiesMask) === observerMask)
                 result.push(observer);
         }
         return result;
     },
 
     /**
      * @param {!WebInspector.Target} target
      */
     addTarget: function(target)
     {
         this._targets.push(target);
         if (this._targets.length === 1) {
             target.resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.InspectedURLChanged, this._redispatchEvent, this);
             target.resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.MainFrameNavigated, this._redispatchEvent, this);
             target.resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.Load, this._redispatchEvent, this);
             target.resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.PageReloadRequested, this._redispatchEvent, this);
             target.resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.WillReloadPage, this._redispatchEvent, this);
         }
-        var copy = this._observersByType(target.type());
+        var copy = this._observersForMask(target.capabilitiesMask());
         for (var i = 0; i < copy.length; ++i)
             copy[i].targetAdded(target);
 
         for (var eventType in this._modelListeners) {
             var listeners = this._modelListeners[eventType];
             for (var i = 0; i < listeners.length; ++i) {
                 var model = target.model(listeners[i].modelClass);
                 if (model)
                     model.addEventListener(eventType, listeners[i].listener, listeners[i].thisObject);
             }
         }
     },
 
     /**
      * @param {!WebInspector.Target} target
      */
     removeTarget: function(target)
     {
         this._targets.remove(target);
         if (this._targets.length === 0) {
             target.resourceTreeModel.removeEventListener(WebInspector.ResourceTreeModel.EventTypes.InspectedURLChanged, this._redispatchEvent, this);
             target.resourceTreeModel.removeEventListener(WebInspector.ResourceTreeModel.EventTypes.MainFrameNavigated, this._redispatchEvent, this);
             target.resourceTreeModel.removeEventListener(WebInspector.ResourceTreeModel.EventTypes.Load, this._redispatchEvent, this);
             target.resourceTreeModel.removeEventListener(WebInspector.ResourceTreeModel.EventTypes.WillReloadPage, this._redispatchEvent, this);
         }
-        var copy = this._observersByType(target.type());
+        var copy = this._observersForMask(target.capabilitiesMask());
         for (var i = 0; i < copy.length; ++i)
             copy[i].targetRemoved(target);
 
         for (var eventType in this._modelListeners) {
             var listeners = this._modelListeners[eventType];
             for (var i = 0; i < listeners.length; ++i) {
                 var model = target.model(listeners[i].modelClass);
                 if (model)
                     model.removeEventListener(eventType, listeners[i].listener, listeners[i].thisObject);
             }
         }
     },
 
     /**
-     * @param {number=} type
+     * @param {number=} capabilitiesMask
      * @return {boolean}
      */
-    hasTargets: function(type)
+    hasTargets: function(capabilitiesMask)
     {
-        return !!this.targets(type).length;
+        return !!this.targets(capabilitiesMask).length;
     },
 
     /**
-     * @param {number=} type
+     * @param {number=} capabilitiesMask
      * @return {!Array.<!WebInspector.Target>}
      */
-    targets: function(type)
+    targets: function(capabilitiesMask)
     {
-        if (!type)
+        if (!capabilitiesMask)
             return this._targets.slice();
 
         var result = [];
         for (var target of this._targets) {
-            if (target.type() & type)
+            if (target.capabilitiesMask() & capabilitiesMask)
                 result.push(target);
         }
         return result;
     },
 
     /**
      * @return {!Array.<!WebInspector.Target>}
      */
     targetsWithJSContext: function()

[dgozman, 2016/07/12 00:34:11]

targetsWithJSDomains

[eostroukhov-old, 2016/07/12 21:46:16]

Deleted. Not needed any more.

     {
         var result = [];
         for (var target of this._targets) {
-            if (target.hasJSContext())
+            if (target.hasJSDomains())
                 result.push(target);
         }
         return result;
     },
 
     /**
      *
      * @param {number} id
      * @return {?WebInspector.Target}
      */
@@ skipping 33 matching lines @@
     /**
      * @param {!WebInspector.Target} target
      */
     targetRemoved: function(target) { },
 }
 
 /**
  * @type {!WebInspector.TargetManager}
  */
 WebInspector.targetManager = new WebInspector.TargetManager();