DevTools: allow reattaching main target live.

third_party/WebKit/Source/devtools/front_end/main/Main.js

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc.  All rights reserved.
  * Copyright (C) 2007 Matt Lilek (pewtermoose@gmail.com).
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
@@ skipping 12 matching lines @@
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @constructor
- * @implements {InspectorAgent.Dispatcher}
  * @suppressGlobalPropertiesCheck
  */
 WebInspector.Main = function()
 {
     WebInspector.Main._instanceForTest = this;
     runOnWindowLoad(this._loaded.bind(this));
 }
 
 WebInspector.Main.prototype = {
     _loaded: function()
@@ skipping 84 matching lines @@
             "securityPanel",
             "resolveVariableNames"
         ]);
     },
 
     /**
      * @suppressGlobalPropertiesCheck
      */
     _createAppUI: function()
     {
-        console.timeStamp("Main._createApp");
+        console.time("Main._createAppUI");
 
         WebInspector.viewManager = new WebInspector.ViewManager();
 
         // Request filesystems early, we won't create connections until callback is fired. Things will happen in parallel.
         WebInspector.isolatedFileSystemManager = new WebInspector.IsolatedFileSystemManager();
         WebInspector.isolatedFileSystemManager.waitForFileSystems()
             .then(this._didInitializeFileSystemManager.bind(this));
 
         var themeSetting = WebInspector.settings.createSetting("uiTheme", "default");
         WebInspector.initializeUIUtils(document, themeSetting);
@@ skipping 54 matching lines @@
         new WebInspector.BackendSettingsSync();
         WebInspector.domBreakpointsSidebarPane = new WebInspector.DOMBreakpointsSidebarPane();
 
         WebInspector.actionRegistry = new WebInspector.ActionRegistry();
         WebInspector.shortcutRegistry = new WebInspector.ShortcutRegistry(WebInspector.actionRegistry, document);
         WebInspector.ShortcutsScreen.registerShortcuts();
         this._registerForwardedShortcuts();
         this._registerMessageSinkListener();
 
         self.runtime.extension(WebInspector.AppProvider).instance().then(this._showAppUI.bind(this));
+        console.timeEnd("Main._createAppUI");
     },
 
     /**
      * @param {!Object} appProvider
      * @suppressGlobalPropertiesCheck
      */
     _showAppUI: function(appProvider)
     {
+        console.time("Main._showAppUI");
         var app = /** @type {!WebInspector.AppProvider} */ (appProvider).createApp();
         // It is important to kick controller lifetime after apps are instantiated.
         WebInspector.dockController.initialize();
-        console.timeStamp("Main._presentUI");
         app.presentUI(document);
 
         var toggleSearchNodeAction = WebInspector.actionRegistry.action("elements.toggle-element-search");
         // TODO: we should not access actions from other modules.
         if (toggleSearchNodeAction)
             InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.EnterInspectElementMode, toggleSearchNodeAction.execute.bind(toggleSearchNodeAction), this);
         WebInspector.inspectorView.createToolbars();
         InspectorFrontendHost.loadCompleted();
 
-        InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.EvaluateForTestInFrontend, this._evaluateForTestInFrontend, this);
         InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.ReloadInspectedPage, this._reloadInspectedPage, this);
 
         var extensions = self.runtime.extensions(WebInspector.QueryParamHandler);
         for (var extension of extensions) {
             var value = Runtime.queryParam(extension.descriptor()["name"]);
             if (value !== null)
                 extension.instance().then(handleQueryParam.bind(null, value));
         }
 
         /**
          * @param {string} value
          * @param {!WebInspector.QueryParamHandler} handler
          */
         function handleQueryParam(value, handler)
         {
             handler.handleQueryParam(value);
         }
 
         this._appUIShown = true;
         if (this._fileSystemManagerInitialized) {
             // Allow UI cycles to repaint prior to creating connection.
-            setTimeout(this._createConnection.bind(this), 0);
+            setTimeout(this._connectAndCreateTarget.bind(this), 0);
         }
+        console.timeEnd("Main._showAppUI");
     },
 
     _didInitializeFileSystemManager: function()
     {
         this._fileSystemManagerInitialized = true;
         if (this._appUIShown)
-            this._createConnection();
+            this._connectAndCreateTarget();
     },
 
-    _createConnection: function()
+    _connectAndCreateTarget: function()
     {
-        console.timeStamp("Main._createConnection");
+        console.time("Main._connectAndCreateTarget");
+        this._createConnection().then(connection => {
+            this._createMainTarget(connection);
+            InspectorFrontendHost.readyForTest();
+            WebInspector.targetManager.setMainTargetFactory(this._recreateMainTarget.bind(this));
+            // Asynchronously run the extensions.
+            console.timeEnd("Main._connectAndCreateTarget");
+            setTimeout(this._lateInitialization.bind(this), 100);
+        });
+    },
 
-        if (Runtime.queryParam("ws")) {
-            var ws = "ws://" + Runtime.queryParam("ws");
-            WebInspector.WebSocketConnection.Create(ws, this._connectionEstablished.bind(this));
-            return;
-        }
-
-        if (!InspectorFrontendHost.isHostedMode()) {
-            this._connectionEstablished(new WebInspector.MainConnection());
-            return;
-        }
-
-        this._connectionEstablished(new WebInspector.StubConnection());
+    _recreateMainTarget: function()
+    {
+        this._createConnection().then(this._createMainTarget.bind(this));
     },
 
     /**
-     * @param {!InspectorBackendClass.Connection} connection
+     * @return {!Promise<!InspectorBackendClass.Connection>}
      */
-    _connectionEstablished: function(connection)
+    _createConnection: function()
     {
-        console.timeStamp("Main._connectionEstablished");
-        this._mainConnection = connection;
-        connection.addEventListener(InspectorBackendClass.Connection.Events.Disconnected, onDisconnected);
+        if (Runtime.queryParam("ws")) {
+            var ws = "ws://" + Runtime.queryParam("ws");
+            return WebInspector.WebSocketConnection.Create(ws).then(connection => {
+                connection.addEventListener(InspectorBackendClass.Connection.Events.Disconnected, onDisconnected);
+                return connection;
+            });
+        }
+
+        return /** @type {!Promise<!InspectorBackendClass.Connection>} */ (Promise.resolve(InspectorFrontendHost.isHostedMode() ?
+            new WebInspector.StubConnection() : new WebInspector.MainConnection()));
 
         /**
          * @param {!WebInspector.Event} event
          */
         function onDisconnected(event)
         {
             if (WebInspector._disconnectedScreenWithReasonWasShown)
                 return;
             WebInspector.RemoteDebuggingTerminatedScreen.show(event.data.reason);
         }
-
-        this._createMainTarget();
-        InspectorFrontendHost.readyForTest();
-        // Asynchronously run the extensions.
-        setTimeout(this._lateInitialization.bind(this), 100);
     },
 
-    _createMainTarget: function()
+    /**
+     * @param {!InspectorBackendClass.Connection} connection
+     */
+    _createMainTarget: function(connection)
     {
+        console.time("Main._createMainTarget");
         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.Worker;
-        if (Runtime.queryParam("isSharedWorker"))
+        if (Runtime.queryParam("isSharedWorker")) {
             capabilities =
                 WebInspector.Target.Capability.Browser | WebInspector.Target.Capability.Log |
                 WebInspector.Target.Capability.Network | WebInspector.Target.Capability.Worker;
-        else if (Runtime.queryParam("v8only"))
+        } else if (Runtime.queryParam("v8only")) {
             capabilities = WebInspector.Target.Capability.JS;
+        }
 
-        this._mainTarget = WebInspector.targetManager.createTarget(WebInspector.UIString("Main"), capabilities, this._mainConnection, null);
-        this._mainTarget.registerInspectorDispatcher(this);
-        this._mainTarget.runtimeAgent().runIfWaitingForDebugger();
-        if (this._mainTarget.hasBrowserCapability())
-            this._mainTarget.inspectorAgent().enable();
-        console.timeStamp("Main._mainTargetCreated");
+        var target = WebInspector.targetManager.createTarget(WebInspector.UIString("Main"), capabilities, connection, null);
+        target.registerInspectorDispatcher(new WebInspector.Main.InspectorDomainDispatcher(target));
+        target.runtimeAgent().runIfWaitingForDebugger();
+        if (target.hasBrowserCapability())
+            target.inspectorAgent().enable();
+        if (Runtime.experiments.isEnabled("nodeDebugging"))
+            new WebInspector.RemoteLocationManager(target);
+        console.timeEnd("Main._createMainTarget");
     },
 
     _lateInitialization: function()
     {
         console.timeStamp("Main._lateInitialization");
         this._registerShortcuts();
         WebInspector.extensionServer.initializeExtensions();
-        if (Runtime.experiments.isEnabled("nodeDebugging"))
-            new WebInspector.RemoteLocationManager(this._mainTarget);
     },
 
     _registerForwardedShortcuts: function()
     {
         /** @const */ var forwardedActions = ["main.toggle-dock", "debugger.toggle-breakpoints-active", "debugger.toggle-pause", "commandMenu.show"];
         var actionKeys = WebInspector.shortcutRegistry.keysForActions(forwardedActions).map(WebInspector.KeyboardShortcut.keyCodeAndModifiersFromKey);
         InspectorFrontendHost.setWhitelistedShortcuts(JSON.stringify(actionKeys));
     },
 
     _registerMessageSinkListener: function()
@@ skipping 181 matching lines @@
 
     /**
      * @param {!WebInspector.Event} event
      */
     _reloadInspectedPage: function(event)
     {
         var hard = /** @type {boolean} */ (event.data);
         WebInspector.Main._reloadPage(hard);
     },
 
+    _onSuspendStateChanged: function()
+    {
+        var suspended = WebInspector.targetManager.allTargetsSuspended();
+        WebInspector.inspectorView.onSuspendStateChanged(suspended);
+    }
+}
+
+/**
+ * @constructor
+ * @implements {InspectorAgent.Dispatcher}
+ * @param {!WebInspector.Target} target
+ */
+WebInspector.Main.InspectorDomainDispatcher = function(target)
+{
+    this._target = target;
+}
+
+WebInspector.Main.InspectorDomainDispatcher.prototype = {
     /**
      * @override
      * @param {string} reason
      */
     detached: function(reason)
     {
         WebInspector._disconnectedScreenWithReasonWasShown = true;
         WebInspector.RemoteDebuggingTerminatedScreen.show(reason);
     },
 
     /**
      * @override
      */
     targetCrashed: function()
     {
-        var debuggerModel = WebInspector.DebuggerModel.fromTarget(this._mainTarget);
+        var debuggerModel = WebInspector.DebuggerModel.fromTarget(this._target);
         if (debuggerModel)
             WebInspector.TargetCrashedScreen.show(debuggerModel);
-    },
-
-    _onSuspendStateChanged: function()
-    {
-        var suspended = WebInspector.targetManager.allTargetsSuspended();
-        WebInspector.inspectorView.onSuspendStateChanged(suspended);
-    },
-
-    /**
-     * @param {!WebInspector.Event} event
-     */
-    _evaluateForTestInFrontend: function(event)
-    {
-        if (!InspectorFrontendHost.isUnderTest())
-            return;
-
-        var callId = /** @type {number} */ (event.data["callId"]);
-        var script = /** @type {number} */ (event.data["script"]);
-
-        /**
-         * @suppressGlobalPropertiesCheck
-         */
-        function invokeMethod()
-        {
-            try {
-                script = script + "//# sourceURL=evaluateInWebInspector" + callId + ".js";
-                window.eval(script);
-            } catch (e) {
-                console.error(e.stack);
-            }
-        }
-
-        this._mainConnection.deprecatedRunAfterPendingDispatches(invokeMethod);
     }
 }
 
+
 /**
  * @constructor
  * @implements {WebInspector.ActionDelegate}
  */
 WebInspector.Main.ReloadActionDelegate = function()
 {
 }
 
 WebInspector.Main.ReloadActionDelegate.prototype = {
     /**
@@ skipping 514 matching lines @@
      * @override
      * @return {?Element}
      */
     settingElement: function()
     {
         return WebInspector.SettingsUI.createSettingCheckbox(WebInspector.UIString("Show rulers"), WebInspector.moduleSetting("showMetricsRulers"));
     }
 }
 
 new WebInspector.Main();