Changeset 237652 in webkit


Ignore:
Timestamp:
Oct 31, 2018, 2:19:11 PM (7 years ago)
Author:
Joseph Pecoraro
Message:

Web Inspector: Separate target initialization from frontend initialization
​https://bugs.webkit.org/show_bug.cgi?id=191052
<rdar://problem/45658384>

Reviewed by Brian Burg.

  • UserInterface/Base/Main.js:

(WI.loaded):
(WI.performOneTimeFrontendInitializationsUsingTarget):
Create the targets after the rest of frontend initialization. This is a step
toward a frontend opening and being told about multiple targets instead of
knowing in advance a single target it is connected to. All backend
messages during frontend initialization now happen with an explicit target.

  • UserInterface/Controllers/ApplicationCacheManager.js:

(WI.ApplicationCacheManager):
(WI.ApplicationCacheManager.prototype.initializeTarget):
(WI.ApplicationCacheManager.prototype.initialize):

  • UserInterface/Controllers/CSSManager.js:

(WI.CSSManager):
(WI.CSSManager.prototype.initializeTarget):

  • UserInterface/Controllers/CanvasManager.js:

(WI.CanvasManager):
(WI.CanvasManager.prototype.initializeTarget):

  • UserInterface/Controllers/ConsoleManager.js:

(WI.ConsoleManager):
(WI.ConsoleManager.prototype.initializeLogChannels):

  • UserInterface/Controllers/DOMManager.js:

(WI.DOMManager):
(WI.DOMManager.prototype.initializeTarget):

  • UserInterface/Controllers/DOMStorageManager.js:

(WI.DOMStorageManager):
(WI.DOMStorageManager.prototype.initializeTarget):

  • UserInterface/Controllers/DatabaseManager.js:

(WI.DatabaseManager):
(WI.DatabaseManager.prototype.initializeTarget):

  • UserInterface/Controllers/DebuggerManager.js:

(WI.DebuggerManager):
(WI.DebuggerManager.prototype.initializeTarget):
(WI.DebuggerManager.restoreBreakpointsSoon): Deleted.

  • UserInterface/Controllers/HeapManager.js:

(WI.HeapManager.prototype.initializeTarget):

  • UserInterface/Controllers/IndexedDBManager.js:

(WI.IndexedDBManager):
(WI.IndexedDBManager.prototype.initializeTarget):

  • UserInterface/Controllers/LayerTreeManager.js:

(WI.LayerTreeManager.prototype.initializeTarget):

  • UserInterface/Controllers/MemoryManager.js:

(WI.MemoryManager.prototype.initializeTarget):

  • UserInterface/Controllers/NetworkManager.js:

(WI.NetworkManager):
(WI.NetworkManager.prototype.initializeTarget):

  • UserInterface/Controllers/RuntimeManager.js:

(WI.RuntimeManager):
(WI.RuntimeManager.prototype.initializeTarget):

  • UserInterface/Controllers/TargetManager.js:

(WI.TargetManager):
(WI.TargetManager.prototype.initializeTargetsWithMainTarget):

  • UserInterface/Controllers/TimelineManager.js:

(WI.TimelineManager):
(WI.TimelineManager.prototype.initializeTarget):
(WI.TimelineManager.prototype.set enabledTimelineTypes):
(WI.TimelineManager.prototype._updateAutoCaptureInstruments):

  • UserInterface/Controllers/WorkerManager.js:

(WI.WorkerManager):
(WI.WorkerManager.prototype.initializeTarget):
Move Target initialization out of the constructor into a top level
initializeTarget function. This will be expected to be called
by any target that the frontend connects to.

(WI.DebuggerManager.prototype._pauseForInternalScriptsDidChange):
Drive-by fix. Update all targets if the setting changes.

(WI.WorkerManager.prototype.workerCreated):
Call initialize on the new target.

  • UserInterface/Models/CSSCompletions.js:

(WI.CSSCompletions.initializeCSSCompletions):
(WI.CSSCompletions.requestCSSCompletions): Deleted.
Rename requestCSSCompletions to initializeCSSCompletions to try
and standardize on "initialize" being used for most frontend one
time initialization tasks. This being one such operation that
only needs to be performed once on a target that supports it.

  • UserInterface/Protocol/Target.js:

(WI.Target):
(WI.Target.prototype.initialize):
Perform explicit target initialization, such as initializing
the state of all backend domains / agents. This is done by asking
each of the managers to do initialization work for this target.

(WI.Target.prototype.get ApplicationCacheAgent):
(WI.Target.prototype.get CSSAgent):
(WI.Target.prototype.get CanvasAgent):
(WI.Target.prototype.get ConsoleAgent):
(WI.Target.prototype.get DOMAgent):
(WI.Target.prototype.get DOMDebuggerAgent):
(WI.Target.prototype.get DOMStorageAgent):
(WI.Target.prototype.get DatabaseAgent):
(WI.Target.prototype.get DebuggerAgent):
(WI.Target.prototype.get HeapAgent):
(WI.Target.prototype.get IndexedDBAgent):
(WI.Target.prototype.get InspectorAgent):
(WI.Target.prototype.get LayerTreeAgent):
(WI.Target.prototype.get MemoryAgent):
(WI.Target.prototype.get NetworkAgent):
(WI.Target.prototype.get PageAgent):
(WI.Target.prototype.get RecordingAgent):
(WI.Target.prototype.get RuntimeAgent):
(WI.Target.prototype.get ScriptProfilerAgent):
(WI.Target.prototype.get ServiceWorkerAgent):
(WI.Target.prototype.get TargetAgent):
(WI.Target.prototype.get TimelineAgent):
(WI.Target.prototype.get WorkerAgent):
Accessors for all of the agents on a Target.

  • UserInterface/Protocol/WorkerTarget.js:

(WI.WorkerTarget):
This is now automatically done in the base class.

  • UserInterface/Test/Test.js:

(WI.loaded):
(WI.performOneTimeFrontendInitializationsUsingTarget):
New necessary top level hooks, and initialize more like Main.js.

Location:
trunk/Source/WebInspectorUI
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebInspectorUI/ChangeLog

    r237644 r237652  
     12018-10-31  Joseph Pecoraro  <pecoraro@apple.com>
     2
     3        Web Inspector: Separate target initialization from frontend initialization
     4        https://bugs.webkit.org/show_bug.cgi?id=191052
     5        <rdar://problem/45658384>
     6
     7        Reviewed by Brian Burg.
     8
     9        * UserInterface/Base/Main.js:
     10        (WI.loaded):
     11        (WI.performOneTimeFrontendInitializationsUsingTarget):
     12        Create the targets after the rest of frontend initialization. This is a step
     13        toward a frontend opening and being told about multiple targets instead of
     14        knowing in advance a single target it is connected to. All backend
     15        messages during frontend initialization now happen with an explicit target.
     16
     17        * UserInterface/Controllers/ApplicationCacheManager.js:
     18        (WI.ApplicationCacheManager):
     19        (WI.ApplicationCacheManager.prototype.initializeTarget):
     20        (WI.ApplicationCacheManager.prototype.initialize):
     21        * UserInterface/Controllers/CSSManager.js:
     22        (WI.CSSManager):
     23        (WI.CSSManager.prototype.initializeTarget):
     24        * UserInterface/Controllers/CanvasManager.js:
     25        (WI.CanvasManager):
     26        (WI.CanvasManager.prototype.initializeTarget):
     27        * UserInterface/Controllers/ConsoleManager.js:
     28        (WI.ConsoleManager):
     29        (WI.ConsoleManager.prototype.initializeLogChannels):
     30        * UserInterface/Controllers/DOMManager.js:
     31        (WI.DOMManager):
     32        (WI.DOMManager.prototype.initializeTarget):
     33        * UserInterface/Controllers/DOMStorageManager.js:
     34        (WI.DOMStorageManager):
     35        (WI.DOMStorageManager.prototype.initializeTarget):
     36        * UserInterface/Controllers/DatabaseManager.js:
     37        (WI.DatabaseManager):
     38        (WI.DatabaseManager.prototype.initializeTarget):
     39        * UserInterface/Controllers/DebuggerManager.js:
     40        (WI.DebuggerManager):
     41        (WI.DebuggerManager.prototype.initializeTarget):
     42        (WI.DebuggerManager.restoreBreakpointsSoon): Deleted.
     43        * UserInterface/Controllers/HeapManager.js:
     44        (WI.HeapManager.prototype.initializeTarget):
     45        * UserInterface/Controllers/IndexedDBManager.js:
     46        (WI.IndexedDBManager):
     47        (WI.IndexedDBManager.prototype.initializeTarget):
     48        * UserInterface/Controllers/LayerTreeManager.js:
     49        (WI.LayerTreeManager.prototype.initializeTarget):
     50        * UserInterface/Controllers/MemoryManager.js:
     51        (WI.MemoryManager.prototype.initializeTarget):
     52        * UserInterface/Controllers/NetworkManager.js:
     53        (WI.NetworkManager):
     54        (WI.NetworkManager.prototype.initializeTarget):
     55        * UserInterface/Controllers/RuntimeManager.js:
     56        (WI.RuntimeManager):
     57        (WI.RuntimeManager.prototype.initializeTarget):
     58        * UserInterface/Controllers/TargetManager.js:
     59        (WI.TargetManager):
     60        (WI.TargetManager.prototype.initializeTargetsWithMainTarget):
     61        * UserInterface/Controllers/TimelineManager.js:
     62        (WI.TimelineManager):
     63        (WI.TimelineManager.prototype.initializeTarget):
     64        (WI.TimelineManager.prototype.set enabledTimelineTypes):
     65        (WI.TimelineManager.prototype._updateAutoCaptureInstruments):
     66        * UserInterface/Controllers/WorkerManager.js:
     67        (WI.WorkerManager):
     68        (WI.WorkerManager.prototype.initializeTarget):
     69        Move Target initialization out of the constructor into a top level
     70        `initializeTarget` function. This will be expected to be called
     71        by any target that the frontend connects to.
     72
     73        (WI.DebuggerManager.prototype._pauseForInternalScriptsDidChange):
     74        Drive-by fix. Update all targets if the setting changes.
     75
     76        (WI.WorkerManager.prototype.workerCreated):
     77        Call initialize on the new target.
     78
     79        * UserInterface/Models/CSSCompletions.js:
     80        (WI.CSSCompletions.initializeCSSCompletions):
     81        (WI.CSSCompletions.requestCSSCompletions): Deleted.
     82        Rename requestCSSCompletions to initializeCSSCompletions to try
     83        and standardize on "initialize" being used for most frontend one
     84        time initialization tasks. This being one such operation that
     85        only needs to be performed once on a target that supports it.
     86
     87        * UserInterface/Protocol/Target.js:
     88        (WI.Target):
     89        (WI.Target.prototype.initialize):
     90        Perform explicit target initialization, such as initializing
     91        the state of all backend domains / agents. This is done by asking
     92        each of the managers to do initialization work for this target.
     93
     94        (WI.Target.prototype.get ApplicationCacheAgent):
     95        (WI.Target.prototype.get CSSAgent):
     96        (WI.Target.prototype.get CanvasAgent):
     97        (WI.Target.prototype.get ConsoleAgent):
     98        (WI.Target.prototype.get DOMAgent):
     99        (WI.Target.prototype.get DOMDebuggerAgent):
     100        (WI.Target.prototype.get DOMStorageAgent):
     101        (WI.Target.prototype.get DatabaseAgent):
     102        (WI.Target.prototype.get DebuggerAgent):
     103        (WI.Target.prototype.get HeapAgent):
     104        (WI.Target.prototype.get IndexedDBAgent):
     105        (WI.Target.prototype.get InspectorAgent):
     106        (WI.Target.prototype.get LayerTreeAgent):
     107        (WI.Target.prototype.get MemoryAgent):
     108        (WI.Target.prototype.get NetworkAgent):
     109        (WI.Target.prototype.get PageAgent):
     110        (WI.Target.prototype.get RecordingAgent):
     111        (WI.Target.prototype.get RuntimeAgent):
     112        (WI.Target.prototype.get ScriptProfilerAgent):
     113        (WI.Target.prototype.get ServiceWorkerAgent):
     114        (WI.Target.prototype.get TargetAgent):
     115        (WI.Target.prototype.get TimelineAgent):
     116        (WI.Target.prototype.get WorkerAgent):
     117        Accessors for all of the agents on a Target.
     118
     119        * UserInterface/Protocol/WorkerTarget.js:
     120        (WI.WorkerTarget):
     121        This is now automatically done in the base class.
     122
     123        * UserInterface/Test/Test.js:
     124        (WI.loaded):
     125        (WI.performOneTimeFrontendInitializationsUsingTarget):
     126        New necessary top level hooks, and initialize more like Main.js.
     127
    11282018-10-31  Devin Rousso  <drousso@apple.com>
    2129

  • trunk/Source/WebInspectorUI/UserInterface/Base/Main.js

    r237613 r237652  
    8989        InspectorBackend.registerCanvasDispatcher(new WI.CanvasObserver);
    9090
    91     // Main backend target.
    92     WI.mainTarget = new WI.MainTarget;
    93     WI.pageTarget = WI.sharedApp.debuggableType === WI.DebuggableType.Web ? WI.mainTarget : null;
    94 
    95     // Enable agents.
    96     if (window.InspectorAgent)
    97         InspectorAgent.enable();
    98 
    99     // Perform one-time tasks.
    100     WI.CSSCompletions.requestCSSCompletions();
    101 
    10291    // Listen for the ProvisionalLoadStarted event before registering for events so our code gets called before any managers or sidebars.
    10392    // This lets us save a state cookie before any managers or sidebars do any resets that would affect state (namely TimelineManager).
    … …  
    10998    // Create the singleton managers next, before the user interface elements, so the user interface can register
    11099    // as event listeners on these managers.
    111     this.targetManager = new WI.TargetManager;
    112     this.branchManager = new WI.BranchManager;
    113     this.networkManager = new WI.NetworkManager;
    114     this.domStorageManager = new WI.DOMStorageManager;
    115     this.databaseManager = new WI.DatabaseManager;
    116     this.indexedDBManager = new WI.IndexedDBManager;
    117     this.domManager = new WI.DOMManager;
    118     this.cssManager = new WI.CSSManager;
    119     this.consoleManager = new WI.ConsoleManager;
    120     this.runtimeManager = new WI.RuntimeManager;
    121     this.heapManager = new WI.HeapManager;
    122     this.memoryManager = new WI.MemoryManager;
    123     this.applicationCacheManager = new WI.ApplicationCacheManager;
    124     this.timelineManager = new WI.TimelineManager;
    125     this.debuggerManager = new WI.DebuggerManager;
    126     this.layerTreeManager = new WI.LayerTreeManager;
    127     this.workerManager = new WI.WorkerManager;
    128     this.domDebuggerManager = new WI.DOMDebuggerManager;
    129     this.canvasManager = new WI.CanvasManager;
    130     this.auditManager = new WI.AuditManager;
    131 
    132     // Enable the Console Agent after creating the singleton managers.
    133     ConsoleAgent.enable();
    134 
    135     // Tell the backend we are initialized after all our initialization messages have been sent.
    136     setTimeout(function() {
    137         // COMPATIBILITY (iOS 8): Inspector.initialized did not exist yet.
    138         if (window.InspectorAgent && InspectorAgent.initialized)
    139             InspectorAgent.initialized();
    140     }, 0);
     100    WI.managers = [
     101        WI.targetManager = new WI.TargetManager,
     102        WI.branchManager = new WI.BranchManager,
     103        WI.networkManager = new WI.NetworkManager,
     104        WI.domStorageManager = new WI.DOMStorageManager,
     105        WI.databaseManager = new WI.DatabaseManager,
     106        WI.indexedDBManager = new WI.IndexedDBManager,
     107        WI.domManager = new WI.DOMManager,
     108        WI.cssManager = new WI.CSSManager,
     109        WI.consoleManager = new WI.ConsoleManager,
     110        WI.runtimeManager = new WI.RuntimeManager,
     111        WI.heapManager = new WI.HeapManager,
     112        WI.memoryManager = new WI.MemoryManager,
     113        WI.applicationCacheManager = new WI.ApplicationCacheManager,
     114        WI.timelineManager = new WI.TimelineManager,
     115        WI.debuggerManager = new WI.DebuggerManager,
     116        WI.layerTreeManager = new WI.LayerTreeManager,
     117        WI.workerManager = new WI.WorkerManager,
     118        WI.domDebuggerManager = new WI.DOMDebuggerManager,
     119        WI.canvasManager = new WI.CanvasManager,
     120        WI.auditManager = new WI.AuditManager,
     121    ];
    141122
    142123    // Register for events.
    143     this.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, this._debuggerDidPause, this);
    144     this.debuggerManager.addEventListener(WI.DebuggerManager.Event.Resumed, this._debuggerDidResume, this);
    145     this.domManager.addEventListener(WI.DOMManager.Event.InspectModeStateChanged, this._inspectModeStateChanged, this);
    146     this.domManager.addEventListener(WI.DOMManager.Event.DOMNodeWasInspected, this._domNodeWasInspected, this);
    147     this.domStorageManager.addEventListener(WI.DOMStorageManager.Event.DOMStorageObjectWasInspected, this._domStorageWasInspected, this);
    148     this.databaseManager.addEventListener(WI.DatabaseManager.Event.DatabaseWasInspected, this._databaseWasInspected, this);
    149     this.networkManager.addEventListener(WI.NetworkManager.Event.MainFrameDidChange, this._mainFrameDidChange, this);
    150     this.networkManager.addEventListener(WI.NetworkManager.Event.FrameWasAdded, this._frameWasAdded, this);
     124    WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, this._debuggerDidPause, this);
     125    WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Resumed, this._debuggerDidResume, this);
     126    WI.domManager.addEventListener(WI.DOMManager.Event.InspectModeStateChanged, this._inspectModeStateChanged, this);
     127    WI.domManager.addEventListener(WI.DOMManager.Event.DOMNodeWasInspected, this._domNodeWasInspected, this);
     128    WI.domStorageManager.addEventListener(WI.DOMStorageManager.Event.DOMStorageObjectWasInspected, this._domStorageWasInspected, this);
     129    WI.databaseManager.addEventListener(WI.DatabaseManager.Event.DatabaseWasInspected, this._databaseWasInspected, this);
     130    WI.networkManager.addEventListener(WI.NetworkManager.Event.MainFrameDidChange, this._mainFrameDidChange, this);
     131    WI.networkManager.addEventListener(WI.NetworkManager.Event.FrameWasAdded, this._frameWasAdded, this);
    151132
    152133    WI.Frame.addEventListener(WI.Frame.Event.MainResourceDidChange, this._mainResourceDidChange, this);
    … …  
    156137    // Create settings.
    157138    this._showingSplitConsoleSetting = new WI.Setting("showing-split-console", false);
    158 
    159139    this._openTabsSetting = new WI.Setting("open-tab-types", ["elements", "network", "debugger", "resources", "timeline", "storage", "canvas", "console"]);
    160140    this._selectedTabIndexSetting = new WI.Setting("selected-tab-index", 0);
    161 
    162141    this.showShadowDOMSetting = new WI.Setting("show-shadow-dom", false);
    163 
    164     // COMPATIBILITY (iOS 8): Page.enableTypeProfiler did not exist.
    165142    this.showJavaScriptTypeInformationSetting = new WI.Setting("show-javascript-type-information", false);
    166143    this.showJavaScriptTypeInformationSetting.addEventListener(WI.Setting.Event.Changed, this._showJavaScriptTypeInformationSettingChanged, this);
    167     if (this.showJavaScriptTypeInformationSetting.value && window.RuntimeAgent && RuntimeAgent.enableTypeProfiler)
    168         RuntimeAgent.enableTypeProfiler();
    169 
    170144    this.enableControlFlowProfilerSetting = new WI.Setting("enable-control-flow-profiler", false);
    171145    this.enableControlFlowProfilerSetting.addEventListener(WI.Setting.Event.Changed, this._enableControlFlowProfilerSettingChanged, this);
    172     if (this.enableControlFlowProfilerSetting.value && window.RuntimeAgent && RuntimeAgent.enableControlFlowProfiler)
    173         RuntimeAgent.enableControlFlowProfiler();
    174 
    175     // COMPATIBILITY (iOS 8): Page.setShowPaintRects did not exist.
    176146    this.showPaintRectsSetting = new WI.Setting("show-paint-rects", false);
    177     if (this.showPaintRectsSetting.value && window.PageAgent && PageAgent.setShowPaintRects)
    178         PageAgent.setShowPaintRects(true);
    179 
     147    this.resourceCachingDisabledSetting = new WI.Setting("disable-resource-caching", false);
     148    this.resourceCachingDisabledSetting.addEventListener(WI.Setting.Event.Changed, this._resourceCachingDisabledSettingChanged, this);
     149
     150    // State.
    180151    this.printStylesEnabled = false;
    181 
    182     // COMPATIBILITY (iOS 10.3): Network.setDisableResourceCaching did not exist.
    183     this.resourceCachingDisabledSetting = new WI.Setting("disable-resource-caching", false);
    184     if (window.NetworkAgent && NetworkAgent.setResourceCachingDisabled) {
    185         if (this.resourceCachingDisabledSetting.value)
    186             NetworkAgent.setResourceCachingDisabled(true);
    187         this.resourceCachingDisabledSetting.addEventListener(WI.Setting.Event.Changed, this._resourceCachingDisabledSettingChanged, this);
    188     }
    189 
    190152    this.setZoomFactor(WI.settings.zoomFactor.value);
    191 
    192     this.mouseCoords = {
    193         x: 0,
    194         y: 0
    195     };
    196 
     153    this.mouseCoords = {x: 0, y: 0};
    197154    this.visible = false;
    198 
    199155    this._windowKeydownListeners = [];
     156
     157    // Targets.
     158    WI.mainTarget = new WI.MainTarget;
     159    WI.mainTarget.initialize();
     160    WI.pageTarget = WI.sharedApp.debuggableType === WI.DebuggableType.Web ? WI.mainTarget : null;
     161
     162    // Post-target initialization.
     163    WI.targetManager.initializeMainTarget();
     164    WI.runtimeManager.activeExecutionContext = WI.mainTarget.executionContext;
    200165};
    201166
    … …  
    520485};
    521486
     487WI.performOneTimeFrontendInitializationsUsingTarget = function(target)
     488{
     489    if (!WI.__didPerformConsoleInitialization && target.ConsoleAgent) {
     490        WI.__didPerformConsoleInitialization = true;
     491        WI.consoleManager.initializeLogChannels(target);
     492    }
     493
     494    if (!WI.__didPerformCSSInitialization && target.CSSAgent) {
     495        WI.__didPerformCSSInitialization = true;
     496        WI.CSSCompletions.initializeCSSCompletions(target);
     497    }
     498};
     499
    522500WI.isTabTypeAllowed = function(tabType)
    523501{
    … …  
    683661    this.notifications.dispatchEventToListeners(WI.Notification.ExtraDomainsActivated, {domains});
    684662
    685     WI.CSSCompletions.requestCSSCompletions();
     663    if (WI.mainTarget && WI.mainTarget.CSSAgent)
     664        WI.CSSCompletions.initializeCSSCompletions(WI.assumingMainTarget());
    686665
    687666    this._updateReloadToolbarButton();
    … …  
    27042683Object.defineProperty(WI, "targets",
    27052684{
    2706     get() { return this.targetManager.targets; }
     2685    get() { return WI.targetManager.targets; }
    27072686});
    27082687

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/ApplicationCacheManager.js

    r236766 r237652  
    2424 */
    2525
     26// FIXME: ApplicationCacheManager lacks advanced multi-target support. (ApplciationCache objects per-target)
     27
    2628WI.ApplicationCacheManager = class ApplicationCacheManager extends WI.Object
    2729{
    … …  
    3032        super();
    3133
    32         if (window.ApplicationCacheAgent)
    33             ApplicationCacheAgent.enable();
    34 
    3534        WI.Frame.addEventListener(WI.Frame.Event.MainResourceDidChange, this._mainResourceDidChange, this);
    3635        WI.Frame.addEventListener(WI.Frame.Event.ChildFrameWasRemoved, this._childFrameWasRemoved, this);
    … …  
    4140    }
    4241
     42    // Target
     43
     44    initializeTarget(target)
     45    {
     46        if (target.ApplicationCacheAgent) {
     47            target.ApplicationCacheAgent.enable();
     48            target.ApplicationCacheAgent.getFramesWithManifests(this._framesWithManifestsLoaded.bind(this));
     49        }
     50    }
     51
    4352    // Public
    4453
    … …  
    4655    {
    4756        this._applicationCacheObjects = {};
    48 
    49         if (window.ApplicationCacheAgent)
    50             ApplicationCacheAgent.getFramesWithManifests(this._framesWithManifestsLoaded.bind(this));
    5157    }
    5258

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/CSSManager.js

    r236766 r237652  
    2424 */
    2525
     26// FIXME: CSSManager lacks advanced multi-target support. (Stylesheets per-target)
     27
    2628WI.CSSManager = class CSSManager extends WI.Object
    2729{
    … …  
    2931    {
    3032        super();
    31 
    32         if (window.CSSAgent)
    33             CSSAgent.enable();
    3433
    3534        WI.Frame.addEventListener(WI.Frame.Event.MainResourceDidChange, this._mainResourceDidChange, this);
    … …  
    5150        // added/removed events and must be fetched manually.
    5251        this._fetchedInitialStyleSheets = window.CSSAgent && window.CSSAgent.hasEvent("styleSheetAdded");
     52    }
     53
     54    // Target
     55
     56    initializeTarget(target)
     57    {
     58        if (target.CSSAgent)
     59            target.CSSAgent.enable();
    5360    }
    5461

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/CanvasManager.js

    r237198 r237652  
    2424 */
    2525
     26// FIXME: CanvasManager lacks advanced multi-target support. (Canvases per-target)
     27
    2628WI.CanvasManager = class CanvasManager extends WI.Object
    2729{
    … …  
    3537        this._shaderProgramIdentifierMap = new Map;
    3638        this._importedRecordings = new Set;
    37 
    38         if (window.CanvasAgent)
    39             CanvasAgent.enable();
     39    }
     40
     41    // Target
     42
     43    initializeTarget(target)
     44    {
     45        if (target.CanvasAgent)
     46            target.CanvasAgent.enable();
    4047    }
    4148

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/ConsoleManager.js

    r236776 r237652  
    4040        this._customLoggingChannels = [];
    4141        this._loggingChannelSources = [];
    42 
    43         if (WI.ConsoleManager.supportsLogChannels()) {
    44             this._loggingChannelSources = [WI.ConsoleMessage.MessageSource.Media, WI.ConsoleMessage.MessageSource.WebRTC];
    45             ConsoleAgent.getLoggingChannels((error, channels) => {
    46                 if (error)
    47                     return;
    48 
    49                 for (let channel of channels) {
    50                     console.assert(this._loggingChannelSources.includes(channel.source));
    51                 }
    52 
    53                 this._customLoggingChannels = channels.map(WI.LoggingChannel.fromPayload);
    54             });
    55         }
    5642    }
    5743
    … …  
    165151    }
    166152
     153    initializeLogChannels(target)
     154    {
     155        console.assert(target.ConsoleAgent);
     156
     157        if (!WI.ConsoleManager.supportsLogChannels())
     158            return;
     159
     160        if (this._loggingChannelSources.length)
     161            return;
     162
     163        this._loggingChannelSources = [WI.ConsoleMessage.MessageSource.Media, WI.ConsoleMessage.MessageSource.WebRTC];
     164
     165        target.ConsoleAgent.getLoggingChannels((error, channels) => {
     166            if (error)
     167                return;
     168
     169            console.assert(channels.every((channel) => this._loggingChannelSources.includes(channel.source)));
     170
     171            this._customLoggingChannels = channels.map(WI.LoggingChannel.fromPayload);
     172        });
     173    }
     174
    167175    // Private
    168176

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/DOMManager.js

    r237435 r237652  
    3131 */
    3232
     33// FIXME: DOMManager lacks advanced multi-target support. (DOMNodes per-target)
     34
    3335WI.DOMManager = class DOMManager extends WI.Object
    3436{
    … …  
    4749
    4850        WI.Frame.addEventListener(WI.Frame.Event.MainResourceDidChange, this._mainResourceDidChange, this);
    49 
    50         this.ensureDocument();
     51    }
     52
     53    // Target
     54
     55    initializeTarget(target)
     56    {
     57        // FIXME: This should be improved when adding better DOM multi-target support since it is really per-target.
     58        // This currently uses a setTimeout since it doesn't need to happen immediately, and DOMManager uses the
     59        // global DOMAgent to request the document, so we want to make sure we've transitioned the global agents
     60        // to this target if necessary.
     61        if (target.DOMAgent) {
     62            setTimeout(() => {
     63                this.ensureDocument();
     64            });
     65        }
    5166    }
    5267
    … …  
    7287        this._pendingDocumentRequestCallbacks = [callback];
    7388
    74         function onDocumentAvailable(error, root)
    75         {
    76             if (!error)
    77                 this._setDocument(root);
    78 
    79             for (let callback of this._pendingDocumentRequestCallbacks)
    80                 callback(this._document);
    81 
    82             this._pendingDocumentRequestCallbacks = null;
    83         }
    84 
    85         if (window.DOMAgent)
    86             DOMAgent.getDocument(onDocumentAvailable.bind(this));
     89        if (window.DOMAgent) {
     90            DOMAgent.getDocument((error, root) => {
     91                if (!error)
     92                    this._setDocument(root);
     93
     94                for (let callback of this._pendingDocumentRequestCallbacks)
     95                    callback(this._document);
     96
     97                this._pendingDocumentRequestCallbacks = null;
     98            });
     99        }
    87100    }
    88101

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/DOMStorageManager.js

    r236766 r237652  
    2525 */
    2626
     27// FIXME: DOMStorageManager lacks advanced multi-target support. (DOMStorage per-target)
     28
    2729WI.DOMStorageManager = class DOMStorageManager extends WI.Object
    2830{
    … …  
    3133        super();
    3234
    33         if (window.DOMStorageAgent)
    34             DOMStorageAgent.enable();
    35 
    3635        WI.Frame.addEventListener(WI.Frame.Event.MainResourceDidChange, this._mainResourceDidChange, this);
    3736        WI.Frame.addEventListener(WI.Frame.Event.SecurityOriginDidChange, this._securityOriginDidChange, this);
    3837
    3938        this.initialize();
     39    }
     40
     41    // Target
     42
     43    initializeTarget(target)
     44    {
     45        if (target.DOMStorageAgent)
     46            target.DOMStorageAgent.enable();
    4047    }
    4148

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/DatabaseManager.js

    r236766 r237652  
    2525 */
    2626
     27// FIXME: DatabaseManager lacks advanced multi-target support. (DataBase per-target)
     28
    2729WI.DatabaseManager = class DatabaseManager extends WI.Object
    2830{
    … …  
    3133        super();
    3234
    33         if (window.DatabaseAgent)
    34             DatabaseAgent.enable();
    35 
    3635        WI.Frame.addEventListener(WI.Frame.Event.MainResourceDidChange, this._mainResourceDidChange, this);
    3736
    3837        this.initialize();
     38    }
     39
     40    // Target
     41
     42    initializeTarget(target)
     43    {
     44        if (target.DatabaseAgent)
     45            target.DatabaseAgent.enable();
    3946    }
    4047

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/DebuggerManager.js

    r236845 r237652  
    3030        super();
    3131
    32         DebuggerAgent.enable();
    33 
    3432        WI.notifications.addEventListener(WI.Notification.DebugUIEnabledDidChange, this._debugUIEnabledDidChange, this);
    3533
    … …  
    4644        WI.targetManager.addEventListener(WI.TargetManager.Event.TargetRemoved, this._targetRemoved, this);
    4745
     46        WI.settings.pauseForInternalScripts.addEventListener(WI.Setting.Event.Changed, this._pauseForInternalScriptsDidChange);
     47
    4848        WI.Frame.addEventListener(WI.Frame.Event.MainResourceDidChange, this._mainResourceDidChange, this);
    4949
    … …  
    7979        this._internalWebKitScripts = [];
    8080        this._targetDebuggerDataMap = new Map;
    81         this._targetDebuggerDataMap.set(WI.mainTarget, new WI.DebuggerData(WI.mainTarget));
    8281
    8382        // Used to detect deleted probe actions.
    … …  
    9695        }
    9796
    98         DebuggerAgent.setBreakpointsActive(this._breakpointsEnabledSetting.value);
    99         DebuggerAgent.setPauseOnExceptions(this._breakOnExceptionsState);
    100 
    101         // COMPATIBILITY (iOS 10): DebuggerAgent.setPauseOnAssertions did not exist yet.
    102         if (DebuggerAgent.setPauseOnAssertions)
    103             DebuggerAgent.setPauseOnAssertions(this._assertionFailuresBreakpointEnabledSetting.value);
    104 
    105         // COMPATIBILITY (iOS 10): Debugger.setAsyncStackTraceDepth did not exist yet.
    106         if (DebuggerAgent.setAsyncStackTraceDepth)
    107             DebuggerAgent.setAsyncStackTraceDepth(this._asyncStackTraceDepthSetting.value);
    108 
    109         // COMPATIBILITY (iOS 12): DebuggerAgent.setPauseForInternalScripts did not exist yet.
    110         if (DebuggerAgent.setPauseForInternalScripts) {
    111             let updateBackendSetting = () => { DebuggerAgent.setPauseForInternalScripts(WI.settings.pauseForInternalScripts.value); };
    112             WI.settings.pauseForInternalScripts.addEventListener(WI.Setting.Event.Changed, updateBackendSetting);
    113 
    114             updateBackendSetting();
    115         }
    116 
    11797        this._ignoreBreakpointDisplayLocationDidChangeEvent = false;
    11898
    119         function restoreBreakpointsSoon() {
     99        // Ensure that all managers learn about restored breakpoints,
     100        // regardless of their initialization order.
     101        setTimeout(() => {
    120102            this._restoringBreakpoints = true;
    121103            for (let cookie of this._breakpointsSetting.value)
    122104                this.addBreakpoint(new WI.Breakpoint(cookie));
    123105            this._restoringBreakpoints = false;
    124         }
    125 
    126         // Ensure that all managers learn about restored breakpoints,
    127         // regardless of their initialization order.
    128         setTimeout(restoreBreakpointsSoon.bind(this), 0);
     106        });
     107    }
     108
     109    // Target
     110
     111    initializeTarget(target)
     112    {
     113        let targetData = this.dataForTarget(target);
     114
     115        // Initialize global state.
     116        target.DebuggerAgent.enable();
     117        target.DebuggerAgent.setBreakpointsActive(this._breakpointsEnabledSetting.value);
     118        target.DebuggerAgent.setPauseOnExceptions(this._breakOnExceptionsState);
     119
     120        // COMPATIBILITY (iOS 10): DebuggerAgent.setPauseOnAssertions did not exist yet.
     121        if (DebuggerAgent.setPauseOnAssertions)
     122            target.DebuggerAgent.setPauseOnAssertions(this._assertionFailuresBreakpointEnabledSetting.value);
     123
     124        // COMPATIBILITY (iOS 10): Debugger.setAsyncStackTraceDepth did not exist yet.
     125        if (DebuggerAgent.setAsyncStackTraceDepth)
     126            target.DebuggerAgent.setAsyncStackTraceDepth(this._asyncStackTraceDepthSetting.value);
     127
     128        // COMPATIBILITY (iOS 12): DebuggerAgent.setPauseForInternalScripts did not exist yet.
     129        if (DebuggerAgent.setPauseForInternalScripts)
     130            target.DebuggerAgent.setPauseForInternalScripts(WI.settings.pauseForInternalScripts.value);
     131
     132        if (this.paused)
     133            targetData.pauseIfNeeded();
     134
     135        // Initialize breakpoints.
     136        this._restoringBreakpoints = true;
     137        for (let breakpoint of this._breakpoints) {
     138            if (breakpoint.disabled)
     139                continue;
     140            if (!breakpoint.contentIdentifier)
     141                continue;
     142            this._setBreakpoint(breakpoint, target);
     143        }
     144        this._restoringBreakpoints = false;
    129145    }
    130146
    … …  
    538554    {
    539555        return this._nextBreakpointActionIdentifier++;
    540     }
    541 
    542     initializeTarget(target)
    543     {
    544         let DebuggerAgent = target.DebuggerAgent;
    545         let targetData = this.dataForTarget(target);
    546 
    547         // Initialize global state.
    548         DebuggerAgent.enable();
    549         DebuggerAgent.setBreakpointsActive(this._breakpointsEnabledSetting.value);
    550         DebuggerAgent.setPauseOnAssertions(this._assertionFailuresBreakpointEnabledSetting.value);
    551         DebuggerAgent.setPauseOnExceptions(this._breakOnExceptionsState);
    552         DebuggerAgent.setAsyncStackTraceDepth(this._asyncStackTraceDepthSetting.value);
    553 
    554         if (this.paused)
    555             targetData.pauseIfNeeded();
    556 
    557         // Initialize breakpoints.
    558         this._restoringBreakpoints = true;
    559         for (let breakpoint of this._breakpoints) {
    560             if (breakpoint.disabled)
    561                 continue;
    562             if (!breakpoint.contentIdentifier)
    563                 continue;
    564             this._setBreakpoint(breakpoint, target);
    565         }
    566         this._restoringBreakpoints = false;
    567556    }
    568557
    … …  
    11661155    }
    11671156
     1157    _pauseForInternalScriptsDidChange(event)
     1158    {
     1159        // COMPATIBILITY (iOS 12): DebuggerAgent.setPauseForInternalScripts did not exist yet.
     1160        console.assert(DebuggerAgent.setPauseForInternalScripts);
     1161
     1162        for (let target of WI.targets)
     1163            target.DebuggerAgent.setPauseForInternalScripts(WI.settings.pauseForInternalScripts.value);
     1164    }
     1165
    11681166    _mainResourceDidChange(event)
    11691167    {

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/HeapManager.js

    r220119 r237652  
    2626WI.HeapManager = class HeapManager extends WI.Object
    2727{
    28     constructor()
     28    // Target
     29
     30    initializeTarget(target)
    2931    {
    30         super();
    31 
    32         if (window.HeapAgent)
    33             HeapAgent.enable();
     32        if (target.HeapAgent)
     33            target.HeapAgent.enable();
    3434    }
    3535

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/IndexedDBManager.js

    r236766 r237652  
    2525 */
    2626
     27// FIXME: IndexedDBManager lacks advanced multi-target support. (IndexedDatabase per-target)
     28
    2729WI.IndexedDBManager = class IndexedDBManager extends WI.Object
    2830{
    … …  
    3133        super();
    3234
    33         if (window.IndexedDBAgent)
    34             IndexedDBAgent.enable();
    35 
    3635        WI.Frame.addEventListener(WI.Frame.Event.MainResourceDidChange, this._mainResourceDidChange, this);
    3736        WI.Frame.addEventListener(WI.Frame.Event.SecurityOriginDidChange, this._securityOriginDidChange, this);
    3837
    3938        this.initialize();
     39    }
     40
     41    // Target
     42
     43    initializeTarget(target)
     44    {
     45        if (target.IndexedDBAgent)
     46            target.IndexedDBAgent.enable();
    4047    }
    4148

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/LayerTreeManager.js

    r236777 r237652  
    2424 */
    2525
     26// FIXME: LayerTreeManager lacks advanced multi-target support. (Layers per-target)
     27
    2628WI.LayerTreeManager = class LayerTreeManager extends WI.Object
    2729{
    28     constructor()
     30    // Target
     31
     32    initializeTarget(target)
    2933    {
    30         super();
    31 
    32         if (window.LayerTreeAgent)
    33             LayerTreeAgent.enable();
     34        if (target.LayerTreeAgent)
     35            target.LayerTreeAgent.enable();
    3436    }
    3537

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/MemoryManager.js

    r220119 r237652  
    2626WI.MemoryManager = class MemoryManager extends WI.Object
    2727{
    28     constructor()
     28    // Target
     29
     30    initializeTarget(target)
    2931    {
    30         super();
    31 
    32         if (window.MemoryAgent)
    33             MemoryAgent.enable();
     32        if (target.MemoryAgent)
     33            target.MemoryAgent.enable();
    3434    }
    3535

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/NetworkManager.js

    r236995 r237652  
    2424 */
    2525
     26// FIXME: NetworkManager lacks advanced multi-target support. (Network.loadResource invocations per-target)
     27
    2628WI.NetworkManager = class NetworkManager extends WI.Object
    2729{
    … …  
    4143        this._downloadingSourceMaps = new Set;
    4244
    43         if (window.PageAgent) {
    44             PageAgent.enable();
    45             PageAgent.getResourceTree(this._processMainFrameResourceTreePayload.bind(this));
    46         }
    47 
    48         if (window.ServiceWorkerAgent)
    49             ServiceWorkerAgent.getInitializationInfo(this._processServiceWorkerConfiguration.bind(this));
    50 
    51         if (window.NetworkAgent)
    52             NetworkAgent.enable();
    53 
    5445        WI.notifications.addEventListener(WI.Notification.ExtraDomainsActivated, this._extraDomainsActivated, this);
    5546        WI.Frame.addEventListener(WI.Frame.Event.MainResourceDidChange, this._handleFrameMainResourceDidChange, this);
     47    }
     48
     49    // Target
     50
     51    initializeTarget(target)
     52    {
     53        if (target.PageAgent) {
     54            target.PageAgent.enable();
     55            target.PageAgent.getResourceTree(this._processMainFrameResourceTreePayload.bind(this));
     56        }
     57
     58        // FIXME: ServiceWorkerAgent should only be exposed in the "serviceworker" target type.
     59        // Currently it is exposed to "web" targets. Work around this by only using the
     60        // ServiceWorker domain if there is no Page domain.
     61        if (target.ServiceWorkerAgent && !target.PageAgent)
     62            target.ServiceWorkerAgent.getInitializationInfo(this._processServiceWorkerConfiguration.bind(this));
     63
     64        if (target.NetworkAgent) {
     65            target.NetworkAgent.enable();
     66
     67            // COMPATIBILITY (iOS 10.3): Network.setDisableResourceCaching did not exist.
     68            if (NetworkAgent.setResourceCachingDisabled) {
     69                if (WI.resourceCachingDisabledSetting && WI.resourceCachingDisabledSetting.value)
     70                    target.NetworkAgent.setResourceCachingDisabled(true);
     71            }
     72        }
     73
     74        if (target.type === WI.Target.Type.Worker)
     75            this.adoptOrphanedResourcesForTarget(target);
    5676    }
    5777

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/RuntimeManager.js

    r223308 r237652  
    3030        super();
    3131
    32         // Enable the RuntimeAgent to receive notification of execution contexts.
    33         RuntimeAgent.enable();
    34 
    35         this._activeExecutionContext = WI.mainTarget.executionContext;
     32        this._activeExecutionContext = null;
    3633
    3734        WI.Frame.addEventListener(WI.Frame.Event.ExecutionContextsCleared, this._frameExecutionContextsCleared, this);
     35    }
     36
     37    // Target
     38
     39    initializeTarget(target)
     40    {
     41        target.RuntimeAgent.enable();
     42
     43        // COMPATIBILITY (iOS 8): Runtime.enableTypeProfiler did not exist.
     44        if (WI.showJavaScriptTypeInformationSetting && WI.showJavaScriptTypeInformationSetting.value && RuntimeAgent.enableTypeProfiler)
     45            target.RuntimeAgent.enableTypeProfiler();
     46
     47        // COMPATIBILITY (iOS 10): Runtime.enableControlFlowProfiler did not exist
     48        if (WI.enableControlFlowProfilerSetting && WI.enableControlFlowProfilerSetting.value && RuntimeAgent.enableControlFlowProfiler)
     49            target.RuntimeAgent.enableControlFlowProfiler();
    3850    }
    3951

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/TargetManager.js

    r225244 r237652  
    3030        super();
    3131
    32         console.assert(WI.mainTarget);
    33 
    34         this._targets = new Set([WI.mainTarget]);
     32        this._targets = new Set;
    3533    }
    3634
    … …  
    7169        this.dispatchEventToListeners(WI.TargetManager.Event.TargetRemoved, {target});
    7270    }
     71
     72    initializeMainTarget()
     73    {
     74        console.assert(WI.mainTarget);
     75        this._targets.add(WI.mainTarget);
     76    }
    7377};
    7478

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/TimelineManager.js

    r236845 r237652  
    2424 */
    2525
     26// FIXME: TimelineManager lacks advanced multi-target support. (Instruments/Profilers per-target)
     27
    2628WI.TimelineManager = class TimelineManager extends WI.Object
    2729{
    … …  
    3941
    4042        this._enabledTimelineTypesSetting = new WI.Setting("enabled-instrument-types", WI.TimelineManager.defaultTimelineTypes());
    41         this._updateAutoCaptureInstruments();
    4243
    4344        this._persistentNetworkTimeline = new WI.NetworkTimeline;
    … …  
    6364    }
    6465
     66    // Target
     67
     68    initializeTarget(target)
     69    {
     70        this._updateAutoCaptureInstruments([target]);
     71    }
     72
    6573    // Static
    6674
    … …  
    168176        this._enabledTimelineTypesSetting.value = x || [];
    169177
    170         this._updateAutoCaptureInstruments();
     178        this._updateAutoCaptureInstruments(WI.targets);
    171179    }
    172180
    … …  
    10531061    }
    10541062
    1055     _updateAutoCaptureInstruments()
    1056     {
    1057         if (!window.TimelineAgent)
    1058             return;
    1059 
     1063    _updateAutoCaptureInstruments(targets)
     1064    {
    10601065        if (!TimelineAgent.setInstruments)
    10611066            return;
    … …  
    10831088        }
    10841089
    1085         TimelineAgent.setInstruments([...instrumentSet]);
     1090        for (let target of targets) {
     1091            if (target.TimelineAgent)
     1092                target.TimelineAgent.setInstruments([...instrumentSet]);
     1093        }
    10861094    }
    10871095};

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/WorkerManager.js

    r220119 r237652  
    3131
    3232        this._connections = new Map;
     33    }
    3334
    34         if (window.WorkerAgent)
    35             WorkerAgent.enable();
     35    // Target
     36
     37    initializeTarget(target)
     38    {
     39        if (target.WorkerAgent)
     40            target.WorkerAgent.enable();
    3641    }
    3742
    … …  
    4247        let connection = new InspectorBackend.WorkerConnection(workerId);
    4348        let workerTarget = new WI.WorkerTarget(workerId, url, connection);
     49        workerTarget.initialize();
     50
    4451        WI.targetManager.addTarget(workerTarget);
    4552

  • trunk/Source/WebInspectorUI/UserInterface/Models/CSSCompletions.js

    r236336 r237652  
    7979    // Static
    8080
    81     static requestCSSCompletions()
    82     {
     81    static initializeCSSCompletions(target)
     82    {
     83        console.assert(target.CSSAgent);
     84
    8385        if (WI.CSSCompletions.cssNameCompletions)
    8486            return;
    … …  
    163165        }
    164166
    165         if (window.CSSAgent) {
    166             CSSAgent.getSupportedCSSProperties(propertyNamesCallback);
    167 
    168             // COMPATIBILITY (iOS 9): CSS.getSupportedSystemFontFamilyNames did not exist.
    169             if (CSSAgent.getSupportedSystemFontFamilyNames)
    170                 CSSAgent.getSupportedSystemFontFamilyNames(fontFamilyNamesCallback);
    171         }
     167        target.CSSAgent.getSupportedCSSProperties(propertyNamesCallback);
     168
     169        // COMPATIBILITY (iOS 9): CSS.getSupportedSystemFontFamilyNames did not exist.
     170        if (CSSAgent.getSupportedSystemFontFamilyNames)
     171            target.CSSAgent.getSupportedSystemFontFamilyNames(fontFamilyNamesCallback);
    172172    }
    173173

  • trunk/Source/WebInspectorUI/UserInterface/Protocol/InspectorBackend.js

    r224634 r237652  
    7171    get dumpInspectorProtocolMessages()
    7272    {
     73        return true;
    7374        return WI.settings.autoLogProtocolMessages.value;
    7475    }

  • trunk/Source/WebInspectorUI/UserInterface/Protocol/Target.js

    r234945 r237652  
    3434        this._type = type;
    3535        this._connection = connection;
     36        this._agents = connection._agents;
    3637        this._executionContext = null;
    3738        this._mainResource = null;
    … …  
    4041
    4142        this._connection.target = this;
     43
     44        // Agents we always expect in every target.
     45        console.assert(this.RuntimeAgent);
     46        console.assert(this.DebuggerAgent);
     47        console.assert(this.ConsoleAgent);
     48    }
     49
     50    // Target
     51
     52    initialize()
     53    {
     54        // Intentionally initialize InspectorAgent first if it is available.
     55        // This may not be strictly necessary anymore, but is historical.
     56        if (this.InspectorAgent)
     57            this.InspectorAgent.enable();
     58
     59        // Initialize agents.
     60        for (let manager of WI.managers) {
     61            if (manager.initializeTarget)
     62                manager.initializeTarget(this);
     63        }
     64
     65        // Non-manager specific initialization.
     66        // COMPATIBILITY (iOS 8): Page.setShowPaintRects did not exist.
     67        if (this.PageAgent) {
     68            if (PageAgent.setShowPaintRects && WI.showPaintRectsSetting && WI.showPaintRectsSetting.value)
     69                this.PageAgent.setShowPaintRects(true);
     70        }
     71
     72        // Intentionally defer ConsoleAgent initialization to the end. We do this so that any
     73        // previous initialization messages will have their responses arrive before a stream
     74        // of console message added events come in after enabling Console.
     75        this.ConsoleAgent.enable();
     76
     77        setTimeout(() => {
     78            // Use this opportunity to run any one time frontend initialization
     79            // now that we have a target with potentially new capabilities.
     80            WI.performOneTimeFrontendInitializationsUsingTarget(this);
     81        });
     82
     83        setTimeout(() => {
     84            // Tell the backend we are initialized after all our initialization messages have been sent.
     85            // This allows an automatically paused backend to resume execution, but we want to ensure
     86            // our breakpoints were already sent to that backend.
     87            // COMPATIBILITY (iOS 8): Inspector.initialized did not exist yet.
     88            if (this.InspectorAgent && InspectorAgent.initialized)
     89                this.InspectorAgent.initialized();
     90        });
    4291    }
    4392
    4493    // Agents
    4594
    46     get RuntimeAgent() { return this._connection._agents.Runtime; }
    47     get ConsoleAgent() { return this._connection._agents.Console; }
    48     get DebuggerAgent() { return this._connection._agents.Debugger; }
    49     get HeapAgent() { return this._connection._agents.Heap; }
     95    get ApplicationCacheAgent() { return this._agents.ApplicationCache; }
     96    get CSSAgent() { return this._agents.CSS; }
     97    get CanvasAgent() { return this._agents.Canvas; }
     98    get ConsoleAgent() { return this._agents.Console; }
     99    get DOMAgent() { return this._agents.DOM; }
     100    get DOMDebuggerAgent() { return this._agents.DOMDebugger; }
     101    get DOMStorageAgent() { return this._agents.DOMStorage; }
     102    get DatabaseAgent() { return this._agents.Database; }
     103    get DebuggerAgent() { return this._agents.Debugger; }
     104    get HeapAgent() { return this._agents.Heap; }
     105    get IndexedDBAgent() { return this._agents.IndexedDB; }
     106    get InspectorAgent() { return this._agents.Inspector; }
     107    get LayerTreeAgent() { return this._agents.LayerTree; }
     108    get MemoryAgent() { return this._agents.Memory; }
     109    get NetworkAgent() { return this._agents.Network; }
     110    get PageAgent() { return this._agents.Page; }
     111    get RecordingAgent() { return this._agents.Recording; }
     112    get RuntimeAgent() { return this._agents.Runtime; }
     113    get ScriptProfilerAgent() { return this._agents.ScriptProfiler; }
     114    get ServiceWorkerAgent() { return this._agents.ServiceWorker; }
     115    get TargetAgent() { return this._agents.Target; }
     116    get TimelineAgent() { return this._agents.Timeline; }
     117    get WorkerAgent() { return this._agents.Worker; }
    50118
    51119    // Public

  • trunk/Source/WebInspectorUI/UserInterface/Protocol/WorkerTarget.js

    r236766 r237652  
    3030        super(workerId, name, WI.Target.Type.Worker, connection);
    3131
    32         WI.networkManager.adoptOrphanedResourcesForTarget(this);
    33 
    34         if (this.RuntimeAgent) {
    35             this._executionContext = new WI.ExecutionContext(this, WI.RuntimeManager.TopLevelExecutionContextIdentifier, this.displayName, false, null);
    36             this.RuntimeAgent.enable();
    37             if (WI.showJavaScriptTypeInformationSetting && WI.showJavaScriptTypeInformationSetting.value)
    38                 this.RuntimeAgent.enableTypeProfiler();
    39             if (WI.enableControlFlowProfilerSetting && WI.enableControlFlowProfilerSetting.value)
    40                 this.RuntimeAgent.enableControlFlowProfiler();
    41         }
    42 
    43         if (this.DebuggerAgent)
    44             WI.debuggerManager.initializeTarget(this);
    45 
    46         if (this.ConsoleAgent)
    47             this.ConsoleAgent.enable();
    48 
    49         if (this.HeapAgent)
    50             this.HeapAgent.enable();
     32        this._executionContext = new WI.ExecutionContext(this, WI.RuntimeManager.TopLevelContextExecutionIdentifier, this.displayName, false, null);
    5133    }
    5234

  • trunk/Source/WebInspectorUI/UserInterface/Test/Test.js

    r237613 r237652  
    4545    InspectorBackend.registerCanvasDispatcher(new WI.CanvasObserver);
    4646
    47     WI.mainTarget = new WI.MainTarget;
    48     WI.pageTarget = WI.sharedApp.debuggableType === WI.DebuggableType.Web ? WI.mainTarget : null;
     47    // Instantiate controllers used by tests.
     48    WI.managers = [
     49        WI.targetManager = new WI.TargetManager,
     50        WI.networkManager = new WI.NetworkManager,
     51        WI.domStorageManager = new WI.DOMStorageManager,
     52        WI.domManager = new WI.DOMManager,
     53        WI.cssManager = new WI.CSSManager,
     54        WI.consoleManager = new WI.ConsoleManager,
     55        WI.runtimeManager = new WI.RuntimeManager,
     56        WI.heapManager = new WI.HeapManager,
     57        WI.memoryManager = new WI.MemoryManager,
     58        WI.timelineManager = new WI.TimelineManager,
     59        WI.debuggerManager = new WI.DebuggerManager,
     60        WI.layerTreeManager = new WI.LayerTreeManager,
     61        WI.workerManager = new WI.WorkerManager,
     62        WI.domDebuggerManager = new WI.DOMDebuggerManager,
     63        WI.canvasManager = new WI.CanvasManager,
     64        WI.auditManager = new WI.AuditManager,
     65    ];
    4966
    50     // Instantiate controllers used by tests.
    51     this.targetManager = new WI.TargetManager;
    52     this.networkManager = new WI.NetworkManager;
    53     this.domStorageManager = new WI.DOMStorageManager;
    54     this.domManager = new WI.DOMManager;
    55     this.cssManager = new WI.CSSManager;
    56     this.consoleManager = new WI.ConsoleManager;
    57     this.runtimeManager = new WI.RuntimeManager;
    58     this.heapManager = new WI.HeapManager;
    59     this.memoryManager = new WI.MemoryManager;
    60     this.timelineManager = new WI.TimelineManager;
    61     this.debuggerManager = new WI.DebuggerManager;
    62     this.layerTreeManager = new WI.LayerTreeManager;
    63     this.workerManager = new WI.WorkerManager;
    64     this.domDebuggerManager = new WI.DOMDebuggerManager;
    65     this.canvasManager = new WI.CanvasManager;
    66     this.auditManager = new WI.AuditManager;
    67 
     67    // Register for events.
    6868    document.addEventListener("DOMContentLoaded", this.contentLoaded);
    69 
    70     // Enable agents.
    71     InspectorAgent.enable();
    72     ConsoleAgent.enable();
    73 
    74     // Perform one-time tasks.
    75     WI.CSSCompletions.requestCSSCompletions();
    7669
    7770    // Global settings.
    7871    this.showShadowDOMSetting = new WI.Setting("show-shadow-dom", true);
     72
     73    // Targets.
     74    WI.mainTarget = new WI.MainTarget;
     75    WI.mainTarget.initialize();
     76    WI.pageTarget = WI.sharedApp.debuggableType === WI.DebuggableType.Web ? WI.mainTarget : null;
     77
     78    // Post-target initialization.
     79    WI.targetManager.initializeMainTarget();
     80    WI.runtimeManager.activeExecutionContext = WI.mainTarget.executionContext;
    7981};
    8082
    … …  
    8991};
    9092
     93WI.performOneTimeFrontendInitializationsUsingTarget = function(target)
     94{
     95    if (!WI.__didPerformConsoleInitialization && target.ConsoleAgent) {
     96        WI.__didPerformConsoleInitialization = true;
     97        WI.consoleManager.initializeLogChannels(target);
     98    }
     99
     100    if (!WI.__didPerformCSSInitialization && target.CSSAgent) {
     101        WI.__didPerformCSSInitialization = true;
     102        WI.CSSCompletions.initializeCSSCompletions(target);
     103    }
     104};
     105
    91106Object.defineProperty(WI, "targets",
    92107{
    93     get() { return this.targetManager.targets; }
     108    get() { return WI.targetManager.targets; }
    94109});
    95110
Note: See TracChangeset for help on using the changeset viewer.