DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/timeline/TimelineController.js

 // Copyright 2016 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.
 
 /** @typedef {!{range: !Protocol.CSS.SourceRange, styleSheetId: !Protocol.CSS.StyleSheetId, wasUsed: boolean}} */
-WebInspector.CSSModel.RuleUsage;
+SDK.CSSModel.RuleUsage;
 
 /**
- * @implements {WebInspector.TargetManager.Observer}
- * @implements {WebInspector.TracingManagerClient}
+ * @implements {SDK.TargetManager.Observer}
+ * @implements {SDK.TracingManagerClient}
  * @unrestricted
  */
-WebInspector.TimelineController = class {
+Timeline.TimelineController = class {
   /**
-   * @param {!WebInspector.Target} target
-   * @param {!WebInspector.TimelineLifecycleDelegate} delegate
-   * @param {!WebInspector.TracingModel} tracingModel
+   * @param {!SDK.Target} target
+   * @param {!Timeline.TimelineLifecycleDelegate} delegate
+   * @param {!SDK.TracingModel} tracingModel
    */
   constructor(target, delegate, tracingModel) {
     this._delegate = delegate;
     this._target = target;
     this._tracingModel = tracingModel;
     this._targets = [];
-    WebInspector.targetManager.observeTargets(this);
+    SDK.targetManager.observeTargets(this);
 
     if (Runtime.experiments.isEnabled('timelineRuleUsageRecording'))
-      this._markUnusedCSS = WebInspector.settings.createSetting('timelineMarkUnusedCSS', false);
+      this._markUnusedCSS = Common.settings.createSetting('timelineMarkUnusedCSS', false);
   }
 
   /**
    * @param {boolean} captureCauses
    * @param {boolean} enableJSSampling
    * @param {boolean} captureMemory
    * @param {boolean} capturePictures
    * @param {boolean} captureFilmStrip
    */
   startRecording(captureCauses, enableJSSampling, captureMemory, capturePictures, captureFilmStrip) {
-    this._extensionTraceProviders = WebInspector.extensionServer.traceProviders().slice();
+    this._extensionTraceProviders = Extensions.extensionServer.traceProviders().slice();
 
     function disabledByDefault(category) {
       return 'disabled-by-default-' + category;
     }
     var categoriesArray = [
       '-*', 'devtools.timeline', 'v8.execute', disabledByDefault('devtools.timeline'),
-      disabledByDefault('devtools.timeline.frame'), WebInspector.TracingModel.TopLevelEventCategory,
-      WebInspector.TimelineModel.Category.Console, WebInspector.TimelineModel.Category.UserTiming
+      disabledByDefault('devtools.timeline.frame'), SDK.TracingModel.TopLevelEventCategory,
+      TimelineModel.TimelineModel.Category.Console, TimelineModel.TimelineModel.Category.UserTiming
     ];
-    categoriesArray.push(WebInspector.TimelineModel.Category.LatencyInfo);
+    categoriesArray.push(TimelineModel.TimelineModel.Category.LatencyInfo);
 
     if (Runtime.experiments.isEnabled('timelineFlowEvents')) {
       categoriesArray.push(disabledByDefault('toplevel.flow'), disabledByDefault('ipc.flow'));
     }
     if (Runtime.experiments.isEnabled('timelineV8RuntimeCallStats') && enableJSSampling)
       categoriesArray.push(disabledByDefault('v8.runtime_stats_sampling'));
     if (Runtime.experiments.isEnabled('timelineTracingJSProfile') && enableJSSampling) {
       categoriesArray.push(disabledByDefault('v8.cpu_profiler'));
-      if (WebInspector.moduleSetting('highResolutionCpuProfiling').get())
+      if (Common.moduleSetting('highResolutionCpuProfiling').get())
         categoriesArray.push(disabledByDefault('v8.cpu_profiler.hires'));
     }
     if (captureCauses || enableJSSampling)
       categoriesArray.push(disabledByDefault('devtools.timeline.stack'));
     if (captureCauses && Runtime.experiments.isEnabled('timelineInvalidationTracking'))
       categoriesArray.push(disabledByDefault('devtools.timeline.invalidationTracking'));
     if (capturePictures) {
       categoriesArray.push(
           disabledByDefault('devtools.timeline.layers'), disabledByDefault('devtools.timeline.picture'),
           disabledByDefault('blink.graphics_context_annotations'));
     }
     if (captureFilmStrip)
       categoriesArray.push(disabledByDefault('devtools.screenshot'));
 
     for (var traceProvider of this._extensionTraceProviders)
       traceProvider.start();
 
     var categories = categoriesArray.join(',');
     this._startRecordingWithCategories(categories, enableJSSampling);
   }
 
   stopRecording() {
     var tracingStoppedPromises = [];
     tracingStoppedPromises.push(new Promise(resolve => this._tracingCompleteCallback = resolve));
     tracingStoppedPromises.push(this._stopProfilingOnAllTargets());
     this._target.tracingManager.stop();
 
     if (!Runtime.experiments.isEnabled('timelineRuleUsageRecording') || !this._markUnusedCSS.get())
-      tracingStoppedPromises.push(WebInspector.targetManager.resumeAllTargets());
+      tracingStoppedPromises.push(SDK.targetManager.resumeAllTargets());
     else
       this._addUnusedRulesToCoverage();
 
     Promise.all(tracingStoppedPromises).then(() => this._allSourcesFinished());
 
     this._delegate.loadingStarted();
 
     for (var traceProvider of this._extensionTraceProviders)
       traceProvider.stop();
   }
 
   /**
    * @override
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   targetAdded(target) {
     this._targets.push(target);
     if (this._profiling)
       this._startProfilingOnTarget(target);
   }
 
   /**
    * @override
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    */
   targetRemoved(target) {
     this._targets.remove(target, true);
     // FIXME: We'd like to stop profiling on the target and retrieve a profile
     // but it's too late. Backend connection is closed.
   }
 
   _addUnusedRulesToCoverage() {
-    var mainTarget = WebInspector.targetManager.mainTarget();
+    var mainTarget = SDK.targetManager.mainTarget();
     if (!mainTarget)
       return;
-    var cssModel = WebInspector.CSSModel.fromTarget(mainTarget);
+    var cssModel = SDK.CSSModel.fromTarget(mainTarget);
 
     /**
-     * @param {!Array<!WebInspector.CSSModel.RuleUsage>} ruleUsageList
+     * @param {!Array<!SDK.CSSModel.RuleUsage>} ruleUsageList
      */
     function ruleListReceived(ruleUsageList) {
 
       for (var rule of ruleUsageList) {
         if (rule.wasUsed)
           continue;
 
         var styleSheetHeader = cssModel.styleSheetHeaderForId(rule.styleSheetId);
         var url = styleSheetHeader.sourceURL;
 
-        WebInspector.CoverageProfile.instance().appendUnusedRule(url, rule.range);
+        Components.CoverageProfile.instance().appendUnusedRule(url, rule.range);
       }
     }
 
     cssModel.ruleListPromise().then(ruleListReceived);
   }
 
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    * @return {!Promise}
    */
   _startProfilingOnTarget(target) {
     return target.hasJSCapability() ? target.profilerAgent().start() : Promise.resolve();
   }
 
   /**
    * @return {!Promise}
    */
   _startProfilingOnAllTargets() {
-    var intervalUs = WebInspector.moduleSetting('highResolutionCpuProfiling').get() ? 100 : 1000;
+    var intervalUs = Common.moduleSetting('highResolutionCpuProfiling').get() ? 100 : 1000;
     this._target.profilerAgent().setSamplingInterval(intervalUs);
     this._profiling = true;
     return Promise.all(this._targets.map(this._startProfilingOnTarget));
   }
 
   /**
-   * @param {!WebInspector.Target} target
+   * @param {!SDK.Target} target
    * @return {!Promise}
    */
   _stopProfilingOnTarget(target) {
     return target.hasJSCapability() ? target.profilerAgent().stop(this._addCpuProfile.bind(this, target.id())) :
                                       Promise.resolve();
   }
 
   /**
    * @param {number} targetId
    * @param {?Protocol.Error} error
    * @param {?Protocol.Profiler.Profile} cpuProfile
    */
   _addCpuProfile(targetId, error, cpuProfile) {
     if (!cpuProfile) {
-      WebInspector.console.warn(WebInspector.UIString('CPU profile for a target is not available. %s', error || ''));
+      Common.console.warn(Common.UIString('CPU profile for a target is not available. %s', error || ''));
       return;
     }
     if (!this._cpuProfiles)
       this._cpuProfiles = new Map();
     this._cpuProfiles.set(targetId, cpuProfile);
   }
 
   /**
    * @return {!Promise}
    */
   _stopProfilingOnAllTargets() {
     var targets = this._profiling ? this._targets : [];
     this._profiling = false;
     return Promise.all(targets.map(this._stopProfilingOnTarget, this));
   }
 
   /**
    * @param {string} categories
    * @param {boolean=} enableJSSampling
    * @param {function(?string)=} callback
    */
   _startRecordingWithCategories(categories, enableJSSampling, callback) {
 
     if (!Runtime.experiments.isEnabled('timelineRuleUsageRecording') || !this._markUnusedCSS.get())
-      WebInspector.targetManager.suspendAllTargets();
+      SDK.targetManager.suspendAllTargets();
 
     var profilingStartedPromise = enableJSSampling && !Runtime.experiments.isEnabled('timelineTracingJSProfile') ?
         this._startProfilingOnAllTargets() :
         Promise.resolve();
-    var samplingFrequencyHz = WebInspector.moduleSetting('highResolutionCpuProfiling').get() ? 10000 : 1000;
+    var samplingFrequencyHz = Common.moduleSetting('highResolutionCpuProfiling').get() ? 10000 : 1000;
     var options = 'sampling-frequency=' + samplingFrequencyHz;
     var target = this._target;
     var tracingManager = target.tracingManager;
-    WebInspector.targetManager.suspendReload(target);
+    SDK.targetManager.suspendReload(target);
     profilingStartedPromise.then(tracingManager.start.bind(tracingManager, this, categories, options, onTraceStarted));
     /**
      * @param {?string} error
      */
     function onTraceStarted(error) {
-      WebInspector.targetManager.resumeReload(target);
+      SDK.targetManager.resumeReload(target);
       if (callback)
         callback(error);
     }
   }
 
   /**
    * @override
    */
   tracingStarted() {
     this._tracingModel.reset();
     this._delegate.recordingStarted();
   }
 
   /**
-   * @param {!Array.<!WebInspector.TracingManager.EventPayload>} events
+   * @param {!Array.<!SDK.TracingManager.EventPayload>} events
    * @override
    */
   traceEventsCollected(events) {
     this._tracingModel.addEvents(events);
   }
 
   /**
    * @override
    */
   tracingComplete() {
     this._tracingCompleteCallback();
     this._tracingCompleteCallback = null;
   }
 
   _allSourcesFinished() {
     this._injectCpuProfileEvents();
     this._tracingModel.tracingComplete();
     this._delegate.loadingComplete(true);
   }
 
   /**
    * @param {number} pid
    * @param {number} tid
    * @param {?Protocol.Profiler.Profile} cpuProfile
    */
   _injectCpuProfileEvent(pid, tid, cpuProfile) {
     if (!cpuProfile)
       return;
-    var cpuProfileEvent = /** @type {!WebInspector.TracingManager.EventPayload} */ ({
-      cat: WebInspector.TracingModel.DevToolsMetadataEventCategory,
-      ph: WebInspector.TracingModel.Phase.Instant,
+    var cpuProfileEvent = /** @type {!SDK.TracingManager.EventPayload} */ ({
+      cat: SDK.TracingModel.DevToolsMetadataEventCategory,
+      ph: SDK.TracingModel.Phase.Instant,
       ts: this._tracingModel.maximumRecordTime() * 1000,
       pid: pid,
       tid: tid,
-      name: WebInspector.TimelineModel.RecordType.CpuProfile,
+      name: TimelineModel.TimelineModel.RecordType.CpuProfile,
       args: {data: {cpuProfile: cpuProfile}}
     });
     this._tracingModel.addEvents([cpuProfileEvent]);
   }
 
   _injectCpuProfileEvents() {
     if (!this._cpuProfiles)
       return;
 
-    var metadataEventTypes = WebInspector.TimelineModel.DevToolsMetadataEvent;
+    var metadataEventTypes = TimelineModel.TimelineModel.DevToolsMetadataEvent;
     var metadataEvents = this._tracingModel.devToolsMetadataEvents();
     var mainMetaEvent =
         metadataEvents.filter(event => event.name === metadataEventTypes.TracingStartedInPage).peekLast();
     if (!mainMetaEvent)
       return;
 
     var pid = mainMetaEvent.thread.process().id();
     var mainCpuProfile = this._cpuProfiles.get(this._target.id());
     this._injectCpuProfileEvent(pid, mainMetaEvent.thread.id(), mainCpuProfile);
 
@@ skipping 18 matching lines @@
   }
 
   /**
    * @param {number} progress
    * @override
    */
   eventsRetrievalProgress(progress) {
     this._delegate.loadingProgress(progress);
   }
 };