DevTools: Support properly multiple targets in sources panel

Source/devtools/front_end/sources/SourcesPanel.js

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2011 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 107 matching lines @@
     this.sidebarPanes.scopechain = new WebInspector.ScopeChainSidebarPane();
     this.sidebarPanes.jsBreakpoints = new WebInspector.JavaScriptBreakpointsSidebarPane(WebInspector.debuggerModel, WebInspector.breakpointManager, this.showUISourceCode.bind(this));
     this.sidebarPanes.domBreakpoints = WebInspector.domBreakpointsSidebarPane.createProxy(this);
     this.sidebarPanes.xhrBreakpoints = new WebInspector.XHRBreakpointsSidebarPane();
     this.sidebarPanes.eventListenerBreakpoints = new WebInspector.EventListenerBreakpointsSidebarPane();
 
     if (Capabilities.isMainFrontend)
         this.sidebarPanes.workerList = new WebInspector.WorkersSidebarPane();
 
     this._extensionSidebarPanes = [];
+    /** @type {!Set.<!WebInspector.Target>} */
+    this._waitingToPauseInTarget = new Set();
 
     this._installDebuggerSidebarController();
 
     WebInspector.dockController.addEventListener(WebInspector.DockController.Events.DockSideChanged, this._dockSideChanged.bind(this));
     WebInspector.settings.splitVerticallyWhenDockedToRight.addChangeListener(this._dockSideChanged.bind(this));
     this._dockSideChanged();
 
     this._updateDebuggerButtons();
     this._pauseOnExceptionEnabledChanged();
     if (WebInspector.debuggerModel.isPaused())
         this._showDebuggerPausedDetails(WebInspector.debuggerModel.debuggerPausedDetails());
 
     WebInspector.settings.pauseOnExceptionEnabled.addChangeListener(this._pauseOnExceptionEnabledChanged, this);
     WebInspector.targetManager.observeTargets(this);
+    WebInspector.executionContextSelector.addTargetChangeListener(this._currentTargetChanged, this);
 }
 
 WebInspector.SourcesPanel.minToolbarWidth = 215;
 
 WebInspector.SourcesPanel.prototype = {
     /**
      * @param {!WebInspector.Target} target
      */
-    targetAdded: function(target) {
+    targetAdded: function(target)
+    {
         target.debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.DebuggerWasEnabled, this._debuggerWasEnabled, this);
-        target.debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.DebuggerWasDisabled, this._debuggerWasDisabled, this);
+        target.debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.DebuggerWasDisabled, this._debuggerReset, this);
         target.debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.DebuggerPaused, this._debuggerPaused, this);
         target.debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.DebuggerResumed, this._debuggerResumed, this);
         target.debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.CallFrameSelected, this._callFrameSelected, this);
         target.debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.ConsoleCommandEvaluatedInSelectedCallFrame, this._consoleCommandEvaluatedInSelectedCallFrame, this);
         target.debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.BreakpointsActiveStateChanged, this._breakpointsActiveStateChanged, this);
         target.debuggerModel.addEventListener(WebInspector.DebuggerModel.Events.GlobalObjectCleared, this._debuggerReset, this);
     },
 
     /**
      * @param {!WebInspector.Target} target
      */
-    targetRemoved: function(target) {
+    targetRemoved: function(target)
+    {
         target.debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.DebuggerWasEnabled, this._debuggerWasEnabled, this);
-        target.debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.DebuggerWasDisabled, this._debuggerWasDisabled, this);
+        target.debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.DebuggerWasDisabled, this._debuggerReset, this);
         target.debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.DebuggerPaused, this._debuggerPaused, this);
         target.debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.DebuggerResumed, this._debuggerResumed, this);
         target.debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.CallFrameSelected, this._callFrameSelected, this);
         target.debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.ConsoleCommandEvaluatedInSelectedCallFrame, this._consoleCommandEvaluatedInSelectedCallFrame, this);
         target.debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.BreakpointsActiveStateChanged, this._breakpointsActiveStateChanged, this);
         target.debuggerModel.removeEventListener(WebInspector.DebuggerModel.Events.GlobalObjectCleared, this._debuggerReset, this);
-
     },
 
     /**
+     * @param {?WebInspector.Target} target
+     */
+    _currentTargetChanged: function(target)
+    {
+        if (!target)
+            return;
+
+        if (target.debuggerModel.isPaused()) {
+            this._showDebuggerPausedDetails(target.debuggerModel.debuggerPausedDetails());
+            var callFrame = target.debuggerModel.selectedCallFrame();
+            if (callFrame)
+                this._selectCallFrame(callFrame);
+        } else {
+            this._paused = false;
+            this._clearInterface();
+            this._toggleDebuggerSidebarButton.setEnabled(true);
+        }
+    },
+
+    /**
      * @return {!Element}
      */
     defaultFocusedElement: function()
     {
         return this._sourcesView.defaultFocusedElement() || this._navigator.view.defaultFocusedElement();
     },
 
-    get paused()
+    /**
+     * @return {boolean}
+     */
+    paused: function()
     {
         return this._paused;
     },
 
     /**
      * @return {!WebInspector.SourcesPanel.DrawerEditor}
      */
     _drawerEditor: function()
     {
         var drawerEditorInstance = WebInspector.moduleManager.instance(WebInspector.DrawerEditor);
@@ skipping 33 matching lines @@
     {
         this.sidebarPanes.scopechain.update(WebInspector.debuggerModel.selectedCallFrame());
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _debuggerPaused: function(event)
     {
         var details = /** @type {!WebInspector.DebuggerPausedDetails} */ (event.data);
-        WebInspector.inspectorView.setCurrentPanel(this);
-        this._showDebuggerPausedDetails(details);
+        this._waitingToPauseInTarget.remove(details.target());
+
+        if (!this._paused)
+            WebInspector.inspectorView.setCurrentPanel(this);
+
+        if (WebInspector.executionContextSelector.currentTarget() === details.target())
+            this._showDebuggerPausedDetails(details);
+        else if (!this._paused)
+            WebInspector.executionContextSelector.setCurrentTarget(details.target());
     },
 
     /**
      * @param {?WebInspector.DebuggerPausedDetails} details
      */
     _showDebuggerPausedDetails: function(details)
     {
         this._paused = true;
-        this._waitingToPause = false;
-
         this._updateDebuggerButtons();
 
         this.sidebarPanes.callstack.update(details);
 
         /**
          * @param {!Element} element
          * @this {WebInspector.SourcesPanel}
          */
         function didCreateBreakpointHitStatusMessage(element)
         {
@@ skipping 38 matching lines @@
             else
                 console.warn("ScriptsPanel paused, but callFrames.length is zero."); // TODO remove this once we understand this case better
         }
 
         this._splitView.showBoth(true);
         this._toggleDebuggerSidebarButton.setEnabled(false);
         window.focus();
         InspectorFrontendHost.bringToFront();
     },
 
-    _debuggerResumed: function()
+    /**
+     * @param {!WebInspector.Event} event
+     */
+    _debuggerResumed: function(event)
     {
+        var target = /** @type {!WebInspector.Target} */ (event.data);
+        this._waitingToPauseInTarget.remove(target);

[vsevik, 2014/06/18 13:51:47]

Let's move it on DebuggerModel

[sergeyv, 2014/06/19 12:42:04]

Done.

+        if (WebInspector.executionContextSelector.currentTarget() !== target)
+            return
         this._paused = false;
-        this._waitingToPause = false;
-
         this._clearInterface();
         this._toggleDebuggerSidebarButton.setEnabled(true);
     },
 
     _debuggerWasEnabled: function()
     {
         this._updateDebuggerButtons();
     },
 
-    _debuggerWasDisabled: function()
+    /**
+     * @param {!WebInspector.Event} event
+     */
+    _debuggerReset: function(event)
     {
-        this._debuggerReset();
-    },
-
-    _debuggerReset: function()
-    {
-        this._debuggerResumed();
-        this.sidebarPanes.watchExpressions.reset();
+        this._debuggerResumed(event);
         delete this._skipExecutionLineRevealing;
     },
 
     /**
      * @return {!WebInspector.View}
      */
     get visibleView()
     {
         return this._sourcesView.visibleView();
     },
@@ skipping 49 matching lines @@
     _executionLineChanged: function(uiLocation)
     {
         this._sourcesView.clearCurrentExecutionLine();
         this._sourcesView.setExecutionLine(uiLocation);
         if (this._skipExecutionLineRevealing)
             return;
         this._skipExecutionLineRevealing = true;
         this._sourcesView.showSourceLocation(uiLocation.uiSourceCode, uiLocation.lineNumber, 0, undefined, true);
     },
 
+    /**
+     * @param {!WebInspector.Event} event
+     */
     _callFrameSelected: function(event)
     {
-        var callFrame = event.data;
+        var callFrame = /** @type {?WebInspector.DebuggerModel.CallFrame} */ (event.data);
 
-        if (!callFrame)
+        if (!callFrame || callFrame.target() !== WebInspector.executionContextSelector.currentTarget())
             return;
 
+        this._selectCallFrame(callFrame);
+    },
+
+    /**
+     * @param {!WebInspector.DebuggerModel.CallFrame}  callFrame
+     */
+    _selectCallFrame: function(callFrame)
+    {
         this.sidebarPanes.scopechain.update(callFrame);
         this.sidebarPanes.watchExpressions.refreshExpressions();
         this.sidebarPanes.callstack.setSelectedCallFrame(callFrame);
         callFrame.createLiveLocation(this._executionLineChanged.bind(this));
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _sourceSelected: function(event)
@@ skipping 14 matching lines @@
     _pauseOnExceptionEnabledChanged: function()
     {
         var enabled = WebInspector.settings.pauseOnExceptionEnabled.get();
         this._pauseOnExceptionButton.toggled = enabled;
         this._pauseOnExceptionButton.title = WebInspector.UIString(enabled ? "Don't pause on exceptions." : "Pause on exceptions.");
         this._debugToolbarDrawer.classList.toggle("expanded", enabled);
     },
 
     _updateDebuggerButtons: function()
     {
+        var currentTarget = WebInspector.executionContextSelector.currentTarget();
+        if (!currentTarget)
+            return;
+
         if (this._paused) {
             this._updateButtonTitle(this._pauseButton, WebInspector.UIString("Resume script execution (%s)."))
             this._pauseButton.state = true;
             this._pauseButton.setLongClickOptionsEnabled((function() { return [ this._longResumeButton ] }).bind(this));
 
             this._pauseButton.setEnabled(true);
             this._stepOverButton.setEnabled(true);
             this._stepIntoButton.setEnabled(true);
             this._stepOutButton.setEnabled(true);
         } else {
             this._updateButtonTitle(this._pauseButton, WebInspector.UIString("Pause script execution (%s)."))
             this._pauseButton.state = false;
             this._pauseButton.setLongClickOptionsEnabled(null);
 
-            this._pauseButton.setEnabled(!this._waitingToPause);
+            this._pauseButton.setEnabled(!this._waitingToPauseInTarget.contains(currentTarget));
             this._stepOverButton.setEnabled(false);
             this._stepIntoButton.setEnabled(false);
             this._stepOutButton.setEnabled(false);
         }
     },
 
     _clearInterface: function()
     {
         this.sidebarPanes.callstack.update(null);
         this.sidebarPanes.scopechain.update(null);
@@ skipping 54 matching lines @@
     {
         var isSnippet = uiSourceCode && uiSourceCode.project().type() === WebInspector.projectTypes.Snippets;
         this._runSnippetButton.element.classList.toggle("hidden", !isSnippet);
     },
 
     /**
      * @return {boolean}
      */
     togglePause: function()
     {
+        var target = WebInspector.executionContextSelector.currentTarget();
+        if (!target)
+            return true;
+
         if (this._paused) {
             delete this._skipExecutionLineRevealing;
             this._paused = false;
-            this._waitingToPause = false;
-            WebInspector.debuggerModel.resume();
+            this._waitingToPauseInTarget.remove(target);
+            target.debuggerModel.resume();
         } else {
-            this._waitingToPause = true;
+            this._waitingToPauseInTarget.add(target);
             // Make sure pauses didn't stick skipped.
-            WebInspector.debuggerModel.skipAllPauses(false);
-            DebuggerAgent.pause();
+            target.debuggerModel.skipAllPauses(false);
+            target.debuggerAgent().pause();
         }
 
         this._clearInterface();
         return true;
     },
 
     /**
+     * @param {!function(!WebInspector.DebuggerModel)} continuation
      * @return {boolean}
      */
-    _longResume: function()
-    {
-        if (!this._paused)
-            return true;
-
-        this._paused = false;
-        this._waitingToPause = false;
-        WebInspector.debuggerModel.skipAllPausesUntilReloadOrTimeout(500);
-        WebInspector.debuggerModel.resume();
-
-        this._clearInterface();
-        return true;
-    },
-
-    /**
-     * @return {boolean}
-     */
-    _stepOverClicked: function()
+    _stepButtonHandler: function(continuation)

[vsevik, 2014/06/18 13:51:47]

prepareToResume

[sergeyv, 2014/06/19 12:42:03]

Done.

     {
         if (!this._paused)
             return true;
 
         delete this._skipExecutionLineRevealing;
         this._paused = false;
 
         this._clearInterface();
+        var target = WebInspector.executionContextSelector.currentTarget();
+        if (target)
+            continuation.call(this, target.debuggerModel);
 
-        WebInspector.debuggerModel.stepOver();
         return true;
     },
 
     /**
-     * @return {boolean}
+     * @param {!WebInspector.DebuggerModel} debuggerModel
      */
-    _stepIntoClicked: function()
+    _longResume: function(debuggerModel)
     {
-        if (!this._paused)
-            return true;
-
-        delete this._skipExecutionLineRevealing;
-        this._paused = false;
-
-        this._clearInterface();
-
-        WebInspector.debuggerModel.stepInto();
-        return true;
+        this._waitingToPauseInTarget.remove(debuggerModel.target());
+        debuggerModel.skipAllPausesUntilReloadOrTimeout(500);
+        debuggerModel.resume();
     },
 
     /**
-     * @return {boolean}
+     * @param {!WebInspector.DebuggerModel} debuggerModel
      */
-    _stepOutClicked: function()
+    _stepOver: function(debuggerModel)
     {
-        if (!this._paused)
-            return true;
-
-        delete this._skipExecutionLineRevealing;
-        this._paused = false;
-
-        this._clearInterface();
-
-        WebInspector.debuggerModel.stepOut();
-        return true;
+        debuggerModel.stepOver();
     },
 
     /**
+     * @param {!WebInspector.DebuggerModel} debuggerModel
+     */
+    _stepInto: function(debuggerModel)
+    {
+        debuggerModel.stepInto();
+    },
+
+    /**
+     * @param {!WebInspector.DebuggerModel} debuggerModel
+     */
+    _stepOut: function(debuggerModel)
+    {
+        debuggerModel.stepOut();
+    },
+
+    /**
      * @param {!WebInspector.Event} event
      */
     _callFrameSelectedInSidebar: function(event)
     {
         var callFrame = /** @type {!WebInspector.DebuggerModel.CallFrame} */ (event.data);
         delete this._skipExecutionLineRevealing;
-        WebInspector.debuggerModel.setSelectedCallFrame(callFrame);
+        callFrame.target().debuggerModel.setSelectedCallFrame(callFrame);
     },
 
     _callFrameRestartedInSidebar: function()
     {
         delete this._skipExecutionLineRevealing;
     },
 
     /**
      * @param {!WebInspector.DebuggerModel.Location} rawLocation
      */
@@ skipping 41 matching lines @@
         this._runSnippetButton.element.classList.add("hidden");
 
         // Continue.
         handler = function() { return WebInspector.actionRegistry.execute("debugger.toggle-pause"); };
         this._pauseButton = this._createButtonAndRegisterShortcuts("scripts-pause", "", handler, []);
         debugToolbar.appendChild(this._pauseButton.element);
 
         // Long resume.
         title = WebInspector.UIString("Resume with all pauses blocked for 500 ms");
         this._longResumeButton = new WebInspector.StatusBarButton(title, "scripts-long-resume");
-        this._longResumeButton.addEventListener("click", this._longResume.bind(this), this);
+        this._longResumeButton.addEventListener("click", this._stepButtonHandler.bind(this, this._longResume), this);
 
         // Step over.
         title = WebInspector.UIString("Step over next function call (%s).");
-        handler = this._stepOverClicked.bind(this);
+        handler = this._stepButtonHandler.bind(this, this._stepOver);
         this._stepOverButton = this._createButtonAndRegisterShortcuts("scripts-step-over", title, handler, WebInspector.ShortcutsScreen.SourcesPanelShortcuts.StepOver);
         debugToolbar.appendChild(this._stepOverButton.element);
 
         // Step into.
         title = WebInspector.UIString("Step into next function call (%s).");
-        handler = this._stepIntoClicked.bind(this);
+        handler = this._stepButtonHandler.bind(this, this._stepInto);
         this._stepIntoButton = this._createButtonAndRegisterShortcuts("scripts-step-into", title, handler, WebInspector.ShortcutsScreen.SourcesPanelShortcuts.StepInto);
         debugToolbar.appendChild(this._stepIntoButton.element);
 
         // Step out.
         title = WebInspector.UIString("Step out of current function (%s).");
-        handler = this._stepOutClicked.bind(this);
+        handler = this._stepButtonHandler.bind(this, this._stepOut);
         this._stepOutButton = this._createButtonAndRegisterShortcuts("scripts-step-out", title, handler, WebInspector.ShortcutsScreen.SourcesPanelShortcuts.StepOut);
         debugToolbar.appendChild(this._stepOutButton.element);
 
         // Toggle Breakpoints
         this._toggleBreakpointsButton = new WebInspector.StatusBarButton(WebInspector.UIString("Deactivate breakpoints."), "scripts-toggle-breakpoints");
         this._toggleBreakpointsButton.toggled = false;
         this._toggleBreakpointsButton.addEventListener("click", this._toggleBreakpointsClicked, this);
         debugToolbar.appendChild(this._toggleBreakpointsButton.element);
 
         // Pause on Exception
@@ skipping 280 matching lines @@
             }
             target.consoleModel.showErrorMessage(message);
         }
     },
 
     /**
      * @param {!WebInspector.RemoteObject} remoteObject
      */
     _showFunctionDefinition: function(remoteObject)
     {
+        var target = remoteObject.target();
+
         /**
          * @param {?Protocol.Error} error
          * @param {!DebuggerAgent.FunctionDetails} response
          * @this {WebInspector.SourcesPanel}
          */
         function didGetFunctionDetails(error, response)
         {
             if (error) {
                 console.error(error);
                 return;
             }
 
-            var uiLocation = WebInspector.debuggerModel.rawLocationToUILocation(response.location);
+            var uiLocation = target.debuggerModel.rawLocationToUILocation(response.location);
             if (!uiLocation)
                 return;
 
             this.showUILocation(uiLocation, true);
         }
-        DebuggerAgent.getFunctionDetails(remoteObject.objectId, didGetFunctionDetails.bind(this));
+        target.debuggerAgent().getFunctionDetails(remoteObject.objectId, didGetFunctionDetails.bind(this));
     },
 
     showGoToSourceDialog: function()
     {
         this._sourcesView.showOpenResourceDialog();
     },
 
     _dockSideChanged: function()
     {
         var vertically = WebInspector.dockController.isVertical() && WebInspector.settings.splitVerticallyWhenDockedToRight.get();
@@ skipping 382 matching lines @@
 WebInspector.SourcesPanel.TogglePauseActionDelegate.prototype = {
     /**
      * @return {boolean}
      */
     handleAction: function()
     {
         /** @type {!WebInspector.SourcesPanel} */ (WebInspector.inspectorView.showPanel("sources")).togglePause();
         return true;
     }
 }