DevTools: rename WebInspector into modules.

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

Index: third_party/WebKit/Source/devtools/front_end/sdk/TargetManager.js
diff --git a/third_party/WebKit/Source/devtools/front_end/sdk/TargetManager.js b/third_party/WebKit/Source/devtools/front_end/sdk/TargetManager.js
index 133cabc0bfb444a7348be64b8117ab5b78544fe3..f7d7a9862c67ad688fcbfaf598f8a41b5e5f1b02 100644
--- a/third_party/WebKit/Source/devtools/front_end/sdk/TargetManager.js
+++ b/third_party/WebKit/Source/devtools/front_end/sdk/TargetManager.js
@@ -7,15 +7,15 @@
 /**
  * @unrestricted
  */
-WebInspector.TargetManager = class extends WebInspector.Object {
+SDK.TargetManager = class extends Common.Object {
   constructor() {
     super();
-    /** @type {!Array.<!WebInspector.Target>} */
+    /** @type {!Array.<!SDK.Target>} */
     this._targets = [];
-    /** @type {!Array.<!WebInspector.TargetManager.Observer>} */
+    /** @type {!Array.<!SDK.TargetManager.Observer>} */
     this._observers = [];
     this._observerCapabiliesMaskSymbol = Symbol('observerCapabilitiesMask');
-    /** @type {!Map<symbol, !Array<{modelClass: !Function, thisObject: (!Object|undefined), listener: function(!WebInspector.Event)}>>} */
+    /** @type {!Map<symbol, !Array<{modelClass: !Function, thisObject: (!Object|undefined), listener: function(!Common.Event)}>>} */
     this._modelListeners = new Map();
     this._isSuspended = false;
   }
@@ -24,7 +24,7 @@ WebInspector.TargetManager = class extends WebInspector.Object {
     if (this._isSuspended)
       return;
     this._isSuspended = true;
-    this.dispatchEventToListeners(WebInspector.TargetManager.Events.SuspendStateChanged);
+    this.dispatchEventToListeners(SDK.TargetManager.Events.SuspendStateChanged);
 
     for (var i = 0; i < this._targets.length; ++i) {
       for (var model of this._targets[i].models())
@@ -39,7 +39,7 @@ WebInspector.TargetManager = class extends WebInspector.Object {
     if (!this._isSuspended)
       throw new Error('Not suspended');
     this._isSuspended = false;
-    this.dispatchEventToListeners(WebInspector.TargetManager.Events.SuspendStateChanged);
+    this.dispatchEventToListeners(SDK.TargetManager.Events.SuspendStateChanged);
 
     var promises = [];
     for (var i = 0; i < this._targets.length; ++i) {
@@ -69,8 +69,8 @@ WebInspector.TargetManager = class extends WebInspector.Object {
   }
 
   /**
-   * @param {!WebInspector.TargetManager.Events} eventName
-   * @param {!WebInspector.Event} event
+   * @param {!SDK.TargetManager.Events} eventName
+   * @param {!Common.Event} event
    */
   _redispatchEvent(eventName, event) {
     this.dispatchEventToListeners(eventName, event.data);
@@ -84,7 +84,7 @@ WebInspector.TargetManager = class extends WebInspector.Object {
     if (!this._targets.length)
       return;
 
-    var resourceTreeModel = WebInspector.ResourceTreeModel.fromTarget(this._targets[0]);
+    var resourceTreeModel = SDK.ResourceTreeModel.fromTarget(this._targets[0]);
     if (!resourceTreeModel)
       return;
 
@@ -94,7 +94,7 @@ WebInspector.TargetManager = class extends WebInspector.Object {
   /**
    * @param {!Function} modelClass
    * @param {symbol} eventType
-   * @param {function(!WebInspector.Event)} listener
+   * @param {function(!Common.Event)} listener
    * @param {!Object=} thisObject
    */
   addModelListener(modelClass, eventType, listener, thisObject) {
@@ -111,7 +111,7 @@ WebInspector.TargetManager = class extends WebInspector.Object {
   /**
    * @param {!Function} modelClass
    * @param {symbol} eventType
-   * @param {function(!WebInspector.Event)} listener
+   * @param {function(!Common.Event)} listener
    * @param {!Object=} thisObject
    */
   removeModelListener(modelClass, eventType, listener, thisObject) {
@@ -135,7 +135,7 @@ WebInspector.TargetManager = class extends WebInspector.Object {
   }
 
   /**
-   * @param {!WebInspector.TargetManager.Observer} targetObserver
+   * @param {!SDK.TargetManager.Observer} targetObserver
    * @param {number=} capabilitiesMask
    */
   observeTargets(targetObserver, capabilitiesMask) {
@@ -147,7 +147,7 @@ WebInspector.TargetManager = class extends WebInspector.Object {
   }
 
   /**
-   * @param {!WebInspector.TargetManager.Observer} targetObserver
+   * @param {!SDK.TargetManager.Observer} targetObserver
    */
   unobserveTargets(targetObserver) {
     delete targetObserver[this._observerCapabiliesMaskSymbol];
@@ -158,58 +158,58 @@ WebInspector.TargetManager = class extends WebInspector.Object {
    * @param {string} name
    * @param {number} capabilitiesMask
    * @param {!InspectorBackendClass.Connection.Factory} connectionFactory
-   * @param {?WebInspector.Target} parentTarget
-   * @return {!WebInspector.Target}
+   * @param {?SDK.Target} parentTarget
+   * @return {!SDK.Target}
    */
   createTarget(name, capabilitiesMask, connectionFactory, parentTarget) {
-    var target = new WebInspector.Target(this, name, capabilitiesMask, connectionFactory, parentTarget);
+    var target = new SDK.Target(this, name, capabilitiesMask, connectionFactory, parentTarget);
 
     var logAgent = target.hasLogCapability() ? target.logAgent() : null;
 
-    /** @type {!WebInspector.ConsoleModel} */
-    target.consoleModel = new WebInspector.ConsoleModel(target, logAgent);
+    /** @type {!SDK.ConsoleModel} */
+    target.consoleModel = new SDK.ConsoleModel(target, logAgent);
 
     var networkManager = null;
     var resourceTreeModel = null;
     if (target.hasNetworkCapability())
-      networkManager = new WebInspector.NetworkManager(target);
+      networkManager = new SDK.NetworkManager(target);
     if (networkManager && target.hasDOMCapability()) {
-      resourceTreeModel = new WebInspector.ResourceTreeModel(
-          target, networkManager, WebInspector.SecurityOriginManager.fromTarget(target));
-      new WebInspector.NetworkLog(target, resourceTreeModel, networkManager);
+      resourceTreeModel = new SDK.ResourceTreeModel(
+          target, networkManager, SDK.SecurityOriginManager.fromTarget(target));
+      new SDK.NetworkLog(target, resourceTreeModel, networkManager);
     }
 
-    /** @type {!WebInspector.RuntimeModel} */
-    target.runtimeModel = new WebInspector.RuntimeModel(target);
+    /** @type {!SDK.RuntimeModel} */
+    target.runtimeModel = new SDK.RuntimeModel(target);
 
     if (target.hasJSCapability())
-      new WebInspector.DebuggerModel(target);
+      new SDK.DebuggerModel(target);
 
     if (resourceTreeModel) {
-      var domModel = new WebInspector.DOMModel(target);
+      var domModel = new SDK.DOMModel(target);
       // TODO(eostroukhov) CSSModel should not depend on RTM
-      new WebInspector.CSSModel(target, domModel);
+      new SDK.CSSModel(target, domModel);
     }
 
-    /** @type {?WebInspector.SubTargetsManager} */
-    target.subTargetsManager = target.hasTargetCapability() ? new WebInspector.SubTargetsManager(target) : null;
-    /** @type {!WebInspector.CPUProfilerModel} */
-    target.cpuProfilerModel = new WebInspector.CPUProfilerModel(target);
-    /** @type {!WebInspector.HeapProfilerModel} */
-    target.heapProfilerModel = new WebInspector.HeapProfilerModel(target);
+    /** @type {?SDK.SubTargetsManager} */
+    target.subTargetsManager = target.hasTargetCapability() ? new SDK.SubTargetsManager(target) : null;
+    /** @type {!SDK.CPUProfilerModel} */
+    target.cpuProfilerModel = new SDK.CPUProfilerModel(target);
+    /** @type {!SDK.HeapProfilerModel} */
+    target.heapProfilerModel = new SDK.HeapProfilerModel(target);
 
-    target.tracingManager = new WebInspector.TracingManager(target);
+    target.tracingManager = new SDK.TracingManager(target);
 
     if (target.subTargetsManager && target.hasBrowserCapability())
-      target.serviceWorkerManager = new WebInspector.ServiceWorkerManager(target, target.subTargetsManager);
+      target.serviceWorkerManager = new SDK.ServiceWorkerManager(target, target.subTargetsManager);
 
     this.addTarget(target);
     return target;
   }
 
   /**
-   * @param {!WebInspector.Target} target
-   * @return {!Array<!WebInspector.TargetManager.Observer>}
+   * @param {!SDK.Target} target
+   * @return {!Array<!SDK.TargetManager.Observer>}
    */
   _observersForTarget(target) {
     return this._observers.filter(
@@ -217,23 +217,23 @@ WebInspector.TargetManager = class extends WebInspector.Object {
   }
 
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   addTarget(target) {
     this._targets.push(target);
-    var resourceTreeModel = WebInspector.ResourceTreeModel.fromTarget(target);
+    var resourceTreeModel = SDK.ResourceTreeModel.fromTarget(target);
     if (this._targets.length === 1 && resourceTreeModel) {
-      resourceTreeModel[WebInspector.TargetManager._listenersSymbol] = [
+      resourceTreeModel[SDK.TargetManager._listenersSymbol] = [
         setupRedispatch.call(
-            this, WebInspector.ResourceTreeModel.Events.MainFrameNavigated,
-            WebInspector.TargetManager.Events.MainFrameNavigated),
-        setupRedispatch.call(this, WebInspector.ResourceTreeModel.Events.Load, WebInspector.TargetManager.Events.Load),
+            this, SDK.ResourceTreeModel.Events.MainFrameNavigated,
+            SDK.TargetManager.Events.MainFrameNavigated),
+        setupRedispatch.call(this, SDK.ResourceTreeModel.Events.Load, SDK.TargetManager.Events.Load),
         setupRedispatch.call(
-            this, WebInspector.ResourceTreeModel.Events.PageReloadRequested,
-            WebInspector.TargetManager.Events.PageReloadRequested),
+            this, SDK.ResourceTreeModel.Events.PageReloadRequested,
+            SDK.TargetManager.Events.PageReloadRequested),
         setupRedispatch.call(
-            this, WebInspector.ResourceTreeModel.Events.WillReloadPage,
-            WebInspector.TargetManager.Events.WillReloadPage)
+            this, SDK.ResourceTreeModel.Events.WillReloadPage,
+            SDK.TargetManager.Events.WillReloadPage)
       ];
     }
     var copy = this._observersForTarget(target);
@@ -250,10 +250,10 @@ WebInspector.TargetManager = class extends WebInspector.Object {
     }
 
     /**
-     * @param {!WebInspector.ResourceTreeModel.Events} sourceEvent
-     * @param {!WebInspector.TargetManager.Events} targetEvent
-     * @return {!WebInspector.EventTarget.EventDescriptor}
-     * @this {WebInspector.TargetManager}
+     * @param {!SDK.ResourceTreeModel.Events} sourceEvent
+     * @param {!SDK.TargetManager.Events} targetEvent
+     * @return {!Common.EventTarget.EventDescriptor}
+     * @this {SDK.TargetManager}
      */
     function setupRedispatch(sourceEvent, targetEvent) {
       return resourceTreeModel.addEventListener(sourceEvent, this._redispatchEvent.bind(this, targetEvent));
@@ -261,16 +261,16 @@ WebInspector.TargetManager = class extends WebInspector.Object {
   }
 
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   removeTarget(target) {
     if (!this._targets.includes(target))
       return;
     this._targets.remove(target);
-    var resourceTreeModel = WebInspector.ResourceTreeModel.fromTarget(target);
-    var treeModelListeners = resourceTreeModel && resourceTreeModel[WebInspector.TargetManager._listenersSymbol];
+    var resourceTreeModel = SDK.ResourceTreeModel.fromTarget(target);
+    var treeModelListeners = resourceTreeModel && resourceTreeModel[SDK.TargetManager._listenersSymbol];
     if (treeModelListeners)
-      WebInspector.EventTarget.removeEventListeners(treeModelListeners);
+      Common.EventTarget.removeEventListeners(treeModelListeners);
 
     var copy = this._observersForTarget(target);
     for (var i = 0; i < copy.length; ++i)
@@ -288,7 +288,7 @@ WebInspector.TargetManager = class extends WebInspector.Object {
 
   /**
    * @param {number=} capabilitiesMask
-   * @return {!Array.<!WebInspector.Target>}
+   * @return {!Array.<!SDK.Target>}
    */
   targets(capabilitiesMask) {
     if (!capabilitiesMask)
@@ -300,7 +300,7 @@ WebInspector.TargetManager = class extends WebInspector.Object {
   /**
    *
    * @param {number} id
-   * @return {?WebInspector.Target}
+   * @return {?SDK.Target}
    */
   targetById(id) {
     for (var i = 0; i < this._targets.length; ++i) {
@@ -311,26 +311,26 @@ WebInspector.TargetManager = class extends WebInspector.Object {
   }
 
   /**
-   * @return {?WebInspector.Target}
+   * @return {?SDK.Target}
    */
   mainTarget() {
     return this._targets[0] || null;
   }
 
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   suspendReload(target) {
-    var resourceTreeModel = WebInspector.ResourceTreeModel.fromTarget(target);
+    var resourceTreeModel = SDK.ResourceTreeModel.fromTarget(target);
     if (resourceTreeModel)
       resourceTreeModel.suspendReload();
   }
 
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   resumeReload(target) {
-    var resourceTreeModel = WebInspector.ResourceTreeModel.fromTarget(target);
+    var resourceTreeModel = SDK.ResourceTreeModel.fromTarget(target);
     if (resourceTreeModel)
       setImmediate(resourceTreeModel.resumeReload.bind(resourceTreeModel));
   }
@@ -344,18 +344,18 @@ WebInspector.TargetManager = class extends WebInspector.Object {
   }
 
   _connectAndCreateMainTarget() {
-    var capabilities = WebInspector.Target.Capability.Browser | WebInspector.Target.Capability.DOM |
-        WebInspector.Target.Capability.JS | WebInspector.Target.Capability.Log |
-        WebInspector.Target.Capability.Network | WebInspector.Target.Capability.Target;
+    var capabilities = SDK.Target.Capability.Browser | SDK.Target.Capability.DOM |
+        SDK.Target.Capability.JS | SDK.Target.Capability.Log |
+        SDK.Target.Capability.Network | SDK.Target.Capability.Target;
     if (Runtime.queryParam('isSharedWorker')) {
-      capabilities = WebInspector.Target.Capability.Browser | WebInspector.Target.Capability.Log |
-          WebInspector.Target.Capability.Network | WebInspector.Target.Capability.Target;
+      capabilities = SDK.Target.Capability.Browser | SDK.Target.Capability.Log |
+          SDK.Target.Capability.Network | SDK.Target.Capability.Target;
     } else if (Runtime.queryParam('v8only')) {
-      capabilities = WebInspector.Target.Capability.JS;
+      capabilities = SDK.Target.Capability.JS;
     }
 
     var target =
-        this.createTarget(WebInspector.UIString('Main'), capabilities, this._createMainConnection.bind(this), null);
+        this.createTarget(Common.UIString('Main'), capabilities, this._createMainConnection.bind(this), null);
     target.runtimeAgent().runIfWaitingForDebugger();
   }
 
@@ -366,11 +366,11 @@ WebInspector.TargetManager = class extends WebInspector.Object {
   _createMainConnection(params) {
     if (Runtime.queryParam('ws')) {
       var ws = 'ws://' + Runtime.queryParam('ws');
-      this._mainConnection = new WebInspector.WebSocketConnection(ws, this._webSocketConnectionLostCallback, params);
+      this._mainConnection = new SDK.WebSocketConnection(ws, this._webSocketConnectionLostCallback, params);
     } else if (InspectorFrontendHost.isHostedMode()) {
-      this._mainConnection = new WebInspector.StubConnection(params);
+      this._mainConnection = new SDK.StubConnection(params);
     } else {
-      this._mainConnection = new WebInspector.MainConnection(params);
+      this._mainConnection = new SDK.MainConnection(params);
     }
     return this._mainConnection;
   }
@@ -386,7 +386,7 @@ WebInspector.TargetManager = class extends WebInspector.Object {
 };
 
 /** @enum {symbol} */
-WebInspector.TargetManager.Events = {
+SDK.TargetManager.Events = {
   InspectedURLChanged: Symbol('InspectedURLChanged'),
   Load: Symbol('Load'),
   MainFrameNavigated: Symbol('MainFrameNavigated'),
@@ -397,26 +397,26 @@ WebInspector.TargetManager.Events = {
   SuspendStateChanged: Symbol('SuspendStateChanged')
 };
 
-WebInspector.TargetManager._listenersSymbol = Symbol('WebInspector.TargetManager.Listeners');
+SDK.TargetManager._listenersSymbol = Symbol('SDK.TargetManager.Listeners');
 
 /**
  * @interface
  */
-WebInspector.TargetManager.Observer = function() {};
+SDK.TargetManager.Observer = function() {};
 
-WebInspector.TargetManager.Observer.prototype = {
+SDK.TargetManager.Observer.prototype = {
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   targetAdded: function(target) {},
 
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   targetRemoved: function(target) {},
 };
 
 /**
- * @type {!WebInspector.TargetManager}
+ * @type {!SDK.TargetManager}
  */
-WebInspector.targetManager = new WebInspector.TargetManager();
+SDK.targetManager = new SDK.TargetManager();