DevTools: Use TargetsToolbar instead of ThreadToolbar

Source/devtools/front_end/components/ExecutionContextSelector.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
  * @implements {WebInspector.TargetManager.Observer}
  */
 WebInspector.ExecutionContextSelector = function() {
     WebInspector.targetManager.observeTargets(this);
 }
 
 WebInspector.ExecutionContextSelector.prototype = {
 
     /**
      * @param {!WebInspector.Target} target
      */
     targetAdded: function(target)
     {
+        if (!WebInspector.context.flavor(WebInspector.Target))
+            WebInspector.context.setFlavor(WebInspector.Target, target);
+
         target.runtimeModel.addEventListener(WebInspector.RuntimeModel.Events.ExecutionContextCreated, this._onExecutionContextCreated, this);
         target.runtimeModel.addEventListener(WebInspector.RuntimeModel.Events.ExecutionContextDestroyed, this._onExecutionContextDestroyed, this);
     },
 
     /**
      * @param {!WebInspector.Target} target
      */
     targetRemoved: function(target)
     {
         target.runtimeModel.removeEventListener(WebInspector.RuntimeModel.Events.ExecutionContextCreated, this._onExecutionContextCreated, this);
         target.runtimeModel.removeEventListener(WebInspector.RuntimeModel.Events.ExecutionContextDestroyed, this._onExecutionContextDestroyed, this);
-        if (WebInspector.context.flavor(WebInspector.ExecutionContext).target() === target)
+        var currentExecutionContext = this.currentExecutionContext();
+        if (currentExecutionContext && currentExecutionContext.target() === target || this.currentTarget() === target)
             this._currentExecutionContextGone();
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _onExecutionContextCreated: function(event)
     {
         var executionContext = /** @type {!WebInspector.ExecutionContext}*/ (event.data);
         if (!WebInspector.context.flavor(WebInspector.ExecutionContext))
-            WebInspector.context.setFlavor(WebInspector.ExecutionContext, executionContext);
+            this.setCurrentExecutionContext(executionContext);
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _onExecutionContextDestroyed: function(event)
     {
         var executionContext = /** @type {!WebInspector.ExecutionContext}*/ (event.data);
         if (WebInspector.context.flavor(WebInspector.ExecutionContext) === executionContext)
             this._currentExecutionContextGone();
     },
 
     _currentExecutionContextGone: function()
     {
         var targets = WebInspector.targetManager.targets();
         var newContext = null;
         for (var i = 0; i < targets.length; ++i) {
             var executionContexts = targets[i].runtimeModel.executionContexts();
             if (executionContexts.length) {
-                newContext = executionContexts[0];
-                break;
+                this.setCurrentExecutionContext(executionContexts[0]);
+                return;
             }
         }
+        WebInspector.context.setFlavor(WebInspector.ExecutionContext, null);
+        WebInspector.context.setFlavor(WebInspector.Target, targets.length ? targets[0] : null);
+    },
+
+    /**
+     * @param {?WebInspector.ExecutionContext} executionContext
+     */
+    setCurrentExecutionContext: function(executionContext)
+    {
+        if (executionContext)
+            WebInspector.context.setFlavor(WebInspector.Target, executionContext.target());
+        WebInspector.context.setFlavor(WebInspector.ExecutionContext, executionContext);
+    },
+
+    /**
+     * @param {?WebInspector.Target} target
+     */
+    setCurrentTarget: function(target)
+    {
+        WebInspector.context.setFlavor(WebInspector.Target, target);
+        var executionContexts = target ? target.runtimeModel.executionContexts() : [];
+        if (!executionContexts.length)
+            return;
+
+        var newContext = executionContexts[0];
+        for (var i = 1; i < executionContexts.length; ++i) {
+            if (executionContexts[i].isMainWorldContext)
+                newContext = executionContexts[i];
+        }
         WebInspector.context.setFlavor(WebInspector.ExecutionContext, newContext);
+    },
+
+    /**
+     * @return {?WebInspector.ExecutionContext}
+     */
+    currentExecutionContext: function()
+    {
+        return WebInspector.context.flavor(WebInspector.ExecutionContext);
+    },
+
+    /**
+     * @return {?WebInspector.Target}
+     */
+    currentTarget: function()
+    {
+        return WebInspector.context.flavor(WebInspector.Target);
+    },
+
+    /**
+     * @param {function(new:T, ...)} flavorType
+     * @param {function(?T)} listener
+     * @param {!Object=} thisObject
+     * @template T
+     */
+    _addChangeListener: function(flavorType, listener, thisObject)
+    {
+        WebInspector.context.addFlavorChangeListener(flavorType, callback);
+
+        /**
+         * @param {!WebInspector.Event} event
+         */
+        function callback(event)
+        {
+            listener.call(thisObject, event.data);
+        }
+
+    },
+
+    /**
+     * @param {function(?WebInspector.ExecutionContext)} listener
+     * @param {!Object=} thisObject
+     */
+    addExecutionContextChangeListener: function(listener, thisObject)
+    {
+       this._addChangeListener(WebInspector.ExecutionContext, listener, thisObject);
+    },
+
+    /**
+     * @param {function(?WebInspector.Target)} listener
+     * @param {!Object=} thisObject
+     */
+    addTargetChangeListener: function(listener, thisObject)
+    {
+        this._addChangeListener(WebInspector.Target, listener, thisObject);
     }
-
 }
 
 /**
  * @param {!Element} proxyElement
  * @param {!Range} wordRange
  * @param {boolean} force
  * @param {function(!Array.<string>, number=)} completionsReadyCallback
  */
 WebInspector.ExecutionContextSelector.completionsForTextPromptInCurrentContext = function(proxyElement, wordRange, force, completionsReadyCallback)
 {
     var executionContext = WebInspector.context.flavor(WebInspector.ExecutionContext);
     if (!executionContext) {
         completionsReadyCallback([]);
         return;
     }
 
     // Pass less stop characters to rangeOfWord so the range will be a more complete expression.
     var expressionRange = wordRange.startContainer.rangeOfWord(wordRange.startOffset, " =:[({;,!+-*/&|^<>", proxyElement, "backward");
     var expressionString = expressionRange.toString();
     var prefix = wordRange.toString();
     executionContext.completionsForExpression(expressionString, prefix, force, completionsReadyCallback);
-}
+}
+
+/**
+ * @type {!WebInspector.ExecutionContextSelector}
+ */
+WebInspector.executionContextSelector;