third_party/WebKit/Source/devtools/front_end/components/ExecutionContextModel.js

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 /**
   6  * @constructor
   7  * @implements {WebInspector.TargetManager.Observer}
   8  * @param {!Element} selectElement
   9  */
  10 WebInspector.ExecutionContextModel = function(selectElement)
  11 {
  12     this._selectElement = selectElement;
  13     /**
  14      * @type {!Map.<!WebInspector.ExecutionContext, !Element>}
  15      */
  16     this._optionByExecutionContext = new Map();
  17
  18     WebInspector.targetManager.observeTargets(this);
  19     WebInspector.targetManager.addModelListener(WebInspector.RuntimeModel, WebInspector.RuntimeModel.Events.ExecutionContextCreated, this._onExecutionContextCreated, this);
  20     WebInspector.targetManager.addModelListener(WebInspector.RuntimeModel, WebInspector.RuntimeModel.Events.ExecutionContextDestroyed, this._onExecutionContextDestroyed, this);
  21     WebInspector.targetManager.addModelListener(WebInspector.ResourceTreeModel, WebInspector.ResourceTreeModel.EventTypes.FrameNavigated, this._onFrameNavigated, this);
  22
  23     this._selectElement.addEventListener("change", this._executionContextChanged.bind(this), false);
  24     WebInspector.context.addFlavorChangeListener(WebInspector.ExecutionContext, this._executionContextChangedExternally, this);
  25 }
  26
  27 WebInspector.ExecutionContextModel.prototype = {
  28     /**
  29      * @param {!WebInspector.ExecutionContext} executionContext
  30      * @return {string}
  31      */
  32     _titleFor: function(executionContext)
  33     {
  34         var result;
  35         if (executionContext.isMainWorldContext) {
  36             if (executionContext.frameId) {
  37                 var frame = executionContext.target().resourceTreeModel.frameForId(executionContext.frameId);
  38                 result =  frame ? frame.displayName() : (executionContext.origin || executionContext.name);
  39             } else {
  40                 var parsedUrl = executionContext.origin.asParsedURL();
  41                 var name = parsedUrl? parsedUrl.lastPathComponentWithFragment() : executionContext.name;
  42                 result = executionContext.target().decorateLabel(name);
  43             }
  44         } else {
  45             result = "\u00a0\u00a0\u00a0\u00a0" + (executionContext.name || executionContext.origin);
  46         }
  47
  48         var maxLength = 50;
  49         return result.trimMiddle(maxLength);
  50     },
  51
  52     /**
  53      * @param {!WebInspector.ExecutionContext} executionContext
  54      */
  55     _executionContextCreated: function(executionContext)
  56     {
  57         // FIXME(413886): We never want to show execution context for the main thread of shadow page in service/shared worker frontend.
  58         // This check could be removed once we do not send this context to frontend.
  59         if (executionContext.target().isServiceWorker())
  60             return;
  61
  62         var newOption = createElement("option");
  63         newOption.__executionContext = executionContext;
  64         newOption.text = this._titleFor(executionContext);
  65         this._optionByExecutionContext.set(executionContext, newOption);
  66         var options = this._selectElement.options;
  67         var contexts = Array.prototype.map.call(options, mapping);
  68         var index = insertionIndexForObjectInListSortedByFunction(executionContext, contexts, WebInspector.ExecutionContext.comparator);
  69         this._selectElement.insertBefore(newOption, options[index]);
  70
  71         if (executionContext === WebInspector.context.flavor(WebInspector.ExecutionContext))
  72             this._select(newOption);
  73
  74         /**
  75          * @param {!Element} option
  76          * @return {!WebInspector.ExecutionContext}
  77          */
  78         function mapping(option)
  79         {
  80             return option.__executionContext;
  81         }
  82     },
  83
  84     /**
  85      * @param {!WebInspector.Event} event
  86      */
  87     _onExecutionContextCreated: function(event)
  88     {
  89         var executionContext = /** @type {!WebInspector.ExecutionContext} */ (event.data);
  90         this._executionContextCreated(executionContext);
  91     },
  92
  93     /**
  94      * @param {!WebInspector.ExecutionContext} executionContext
  95      */
  96     _executionContextDestroyed: function(executionContext)
  97     {
  98         var option = this._optionByExecutionContext.remove(executionContext);
  99         option.remove();
 100     },
 101
 102     /**
 103      * @param {!WebInspector.Event} event
 104      */
 105     _onExecutionContextDestroyed: function(event)
 106     {
 107         var executionContext = /** @type {!WebInspector.ExecutionContext} */ (event.data);
 108         this._executionContextDestroyed(executionContext);
 109     },
 110
 111     /**
 112      * @param {!WebInspector.Event} event
 113      */
 114     _onFrameNavigated: function(event)
 115     {
 116         var frame = /** @type {!WebInspector.ResourceTreeFrame} */ (event.data);
 117         var executionContexts = this._optionByExecutionContext.keysArray();
 118         for (var i = 0; i < executionContexts.length; ++i) {
 119             var context = executionContexts[i];
 120             if (context.frameId === frame.id)
 121                 this._optionByExecutionContext.get(context).text = this._titleFor(context);
 122         }
 123     },
 124
 125     /**
 126      * @param {!WebInspector.Event} event
 127      */
 128     _executionContextChangedExternally: function(event)
 129     {
 130         var executionContext =  /** @type {?WebInspector.ExecutionContext} */ (event.data);
 131         if (!executionContext)
 132             return;
 133
 134         var options = this._selectElement.options;
 135         for (var i = 0; i < options.length; ++i) {
 136             if (options[i].__executionContext === executionContext)
 137                 this._select(options[i]);
 138         }
 139     },
 140
 141     _executionContextChanged: function()
 142     {
 143         var option = this._selectedOption();
 144         var newContext = option ? option.__executionContext : null;
 145         WebInspector.context.setFlavor(WebInspector.ExecutionContext, newContext);
 146     },
 147
 148     /**
 149      * @override
 150      * @param {!WebInspector.Target} target
 151      */
 152     targetAdded: function(target)
 153     {
 154         target.runtimeModel.executionContexts().forEach(this._executionContextCreated, this);
 155     },
 156
 157     /**
 158      * @override
 159      * @param {!WebInspector.Target} target
 160      */
 161     targetRemoved: function(target)
 162     {
 163         var executionContexts = this._optionByExecutionContext.keysArray();
 164         for (var i = 0; i < executionContexts.length; ++i) {
 165             if (executionContexts[i].target() === target)
 166                 this._executionContextDestroyed(executionContexts[i]);
 167         }
 168     },
 169
 170     /**
 171      * @param {!Element} option
 172      */
 173     _select: function(option)
 174     {
 175         this._selectElement.selectedIndex = Array.prototype.indexOf.call(/** @type {?} */ (this._selectElement), option);
 176     },
 177
 178     /**
 179      * @return {?Element}
 180      */
 181     _selectedOption: function()
 182     {
 183         if (this._selectElement.selectedIndex >= 0)
 184             return this._selectElement[this._selectElement.selectedIndex];
 185         return null;
 186     }
 187 }