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 = [];
-
     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);
+    this._resetForTarget(WebInspector.context.flavor(WebInspector.Target));
+    WebInspector.context.addFlavorChangeListener(WebInspector.Target, this._onCurrentTargetChanged, 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
+     */
+    _resetForTarget: function(target)

[vsevik, 2014/06/19 15:30:40]

_setTarget

[sergeyv, 2014/06/19 17:02:45]

Done.

+    {
+        if (!target)
+            return;
+
+        if (target.debuggerModel.isPaused()) {
+            this._showDebuggerPausedDetails(/** @type {!WebInspector.DebuggerPausedDetails} */ (target.debuggerModel.debuggerPausedDetails()));
+            var callFrame = target.debuggerModel.selectedCallFrame();
+            if (callFrame)
+                this._selectCallFrame(callFrame);
+        } else {
+            this._paused = false;
+            this._clearInterface();
+            this._toggleDebuggerSidebarButton.setEnabled(true);
+        }
+    },
+
+    /**
+     * @param {!WebInspector.Event} event
+     */
+    _onCurrentTargetChanged: function(event)
+    {
+        var target = /** @type {?WebInspector.Target} */ (event.data);
+        this._resetForTarget(target);
+    },
+
+    /**
      * @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);
+        if (!this._paused)

[vsevik, 2014/06/19 15:30:40]

I don't think this is needed

[sergeyv, 2014/06/19 17:02:45]

If we are already paused in the current target and we are on a different panel,
we don't want switch neither the current target, neither a panel

+            WebInspector.inspectorView.setCurrentPanel(this);
+
+        if (WebInspector.context.flavor(WebInspector.Target) === details.target())
+            this._showDebuggerPausedDetails(details);
+        else if (!this._paused)
+            WebInspector.context.setFlavor(WebInspector.Target, details.target());
     },
 
     /**
-     * @param {?WebInspector.DebuggerPausedDetails} details
+     * @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 39 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.target.target());
+        if (WebInspector.context.flavor(WebInspector.Target) !== target)
+            return

[vsevik, 2014/06/19 15:30:40]

;

[sergeyv, 2014/06/19 17:02:45]

Done.

         this._paused = false;
-        this._waitingToPause = false;
-
         this._clearInterface();
         this._toggleDebuggerSidebarButton.setEnabled(true);
     },
 
-    _debuggerWasEnabled: function()
+    /**
+     * @param {!WebInspector.Event} event
+     */
+    _debuggerWasEnabled: function(event)
     {
+        var target = /** @type {!WebInspector.Target} */  (event.target.target());
+        if (WebInspector.context.flavor(WebInspector.Target) !== target)
+            return;
+
         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.context.flavor(WebInspector.Target))
             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.context.flavor(WebInspector.Target);
+        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(!currentTarget.debuggerModel.isWaitingToPause());
             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.context.flavor(WebInspector.Target);
+        if (!target)
+            return true;
+
         if (this._paused) {
             delete this._skipExecutionLineRevealing;
             this._paused = false;
-            this._waitingToPause = false;
-            WebInspector.debuggerModel.resume();
+            target.debuggerModel.resume();
         } else {
-            this._waitingToPause = true;
             // Make sure pauses didn't stick skipped.
-            WebInspector.debuggerModel.skipAllPauses(false);
-            DebuggerAgent.pause();
+            target.debuggerModel.pause();
         }
 
         this._clearInterface();
         return true;
     },
 
     /**
+     * @return {?WebInspector.DebuggerModel}
+     */
+    _prepareToResume: function()
+    {
+        if (!this._paused)
+            return null;
+
+        delete this._skipExecutionLineRevealing;
+        this._paused = false;
+
+        this._clearInterface();
+        var target = WebInspector.context.flavor(WebInspector.Target);
+        return target ? target.debuggerModel : null;
+    },
+
+    /**
      * @return {boolean}
      */
     _longResume: function()
     {
-        if (!this._paused)
+        var debuggerModel = this._prepareToResume();
+        if (!debuggerModel)
             return true;
 
-        this._paused = false;
-        this._waitingToPause = false;
-        WebInspector.debuggerModel.skipAllPausesUntilReloadOrTimeout(500);
-        WebInspector.debuggerModel.resume();
-
-        this._clearInterface();
+        debuggerModel.skipAllPausesUntilReloadOrTimeout(500);
+        debuggerModel.resume();
         return true;
     },
 
     /**
      * @return {boolean}
      */
     _stepOverClicked: function()
     {
-        if (!this._paused)
+        var debuggerModel = this._prepareToResume();
+        if (!debuggerModel)
             return true;
 
-        delete this._skipExecutionLineRevealing;
-        this._paused = false;
-
-        this._clearInterface();
-
-        WebInspector.debuggerModel.stepOver();
+        debuggerModel.stepOver();
         return true;
     },
 
     /**
      * @return {boolean}
      */
     _stepIntoClicked: function()
     {
-        if (!this._paused)
+        var debuggerModel = this._prepareToResume();
+        if (!debuggerModel)
             return true;
 
-        delete this._skipExecutionLineRevealing;
-        this._paused = false;
-
-        this._clearInterface();
-
-        WebInspector.debuggerModel.stepInto();
+        debuggerModel.stepInto();
         return true;
     },
 
     /**
      * @return {boolean}
      */
     _stepOutClicked: function()
     {
-        if (!this._paused)
+        var debuggerModel = this._prepareToResume();
+        if (!debuggerModel)
             return true;
 
-        delete this._skipExecutionLineRevealing;
-        this._paused = false;
-
-        this._clearInterface();
-
-        WebInspector.debuggerModel.stepOut();
+        debuggerModel.stepOut();
         return true;
     },
 
     /**
      * @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
      */
     continueToLocation: function(rawLocation)
     {
-        if (!this._paused)
+        if (!this._prepareToResume())
             return;
 
-        delete this._skipExecutionLineRevealing;
-        this._paused = false;
-        this._clearInterface();
         rawLocation.continueToLocation();
     },
 
     _toggleBreakpointsClicked: function(event)
     {
         WebInspector.debuggerModel.setBreakpointsActive(!WebInspector.debuggerModel.breakpointsActive());
     },
 
     _breakpointsActiveStateChanged: function(event)
     {
@@ skipping 340 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;
     }
 }