DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/profiler/CPUProfileView.js

 /*
  * Copyright (C) 2008 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /**
- * @implements {WebInspector.Searchable}
+ * @implements {UI.Searchable}
  * @unrestricted
  */
-WebInspector.CPUProfileView = class extends WebInspector.ProfileView {
+Profiler.CPUProfileView = class extends Profiler.ProfileView {
   /**
-   * @param {!WebInspector.CPUProfileHeader} profileHeader
+   * @param {!Profiler.CPUProfileHeader} profileHeader
    */
   constructor(profileHeader) {
     super();
     this._profileHeader = profileHeader;
-    this.profile = new WebInspector.CPUProfileDataModel(profileHeader._profile || profileHeader.protocolProfile());
+    this.profile = new SDK.CPUProfileDataModel(profileHeader._profile || profileHeader.protocolProfile());
     this.adjustedTotal = this.profile.profileHead.total;
     this.adjustedTotal -= this.profile.idleNode ? this.profile.idleNode.total : 0;
-    this.initialize(new WebInspector.CPUProfileView.NodeFormatter(this));
+    this.initialize(new Profiler.CPUProfileView.NodeFormatter(this));
   }
 
   /**
    * @override
    */
   wasShown() {
     super.wasShown();
-    var lineLevelProfile = WebInspector.LineLevelProfile.instance();
+    var lineLevelProfile = Components.LineLevelProfile.instance();
     lineLevelProfile.reset();
     lineLevelProfile.appendCPUProfile(this.profile);
   }
 
   /**
    * @override
    * @param {string} columnId
    * @return {string}
    */
   columnHeader(columnId) {
     switch (columnId) {
       case 'self':
-        return WebInspector.UIString('Self Time');
+        return Common.UIString('Self Time');
       case 'total':
-        return WebInspector.UIString('Total Time');
+        return Common.UIString('Total Time');
     }
     return '';
   }
 
   /**
    * @override
-   * @return {!WebInspector.FlameChartDataProvider}
+   * @return {!UI.FlameChartDataProvider}
    */
   createFlameChartDataProvider() {
-    return new WebInspector.CPUFlameChartDataProvider(this.profile, this._profileHeader.target());
+    return new Profiler.CPUFlameChartDataProvider(this.profile, this._profileHeader.target());
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.CPUProfileType = class extends WebInspector.ProfileType {
+Profiler.CPUProfileType = class extends Profiler.ProfileType {
   constructor() {
-    super(WebInspector.CPUProfileType.TypeId, WebInspector.UIString('Record JavaScript CPU Profile'));
+    super(Profiler.CPUProfileType.TypeId, Common.UIString('Record JavaScript CPU Profile'));
     this._recording = false;
 
     this._nextAnonymousConsoleProfileNumber = 1;
     this._anonymousConsoleProfileIdToTitle = {};
 
-    WebInspector.CPUProfileType.instance = this;
-    WebInspector.targetManager.addModelListener(
-        WebInspector.CPUProfilerModel, WebInspector.CPUProfilerModel.Events.ConsoleProfileStarted,
+    Profiler.CPUProfileType.instance = this;
+    SDK.targetManager.addModelListener(
+        SDK.CPUProfilerModel, SDK.CPUProfilerModel.Events.ConsoleProfileStarted,
         this._consoleProfileStarted, this);
-    WebInspector.targetManager.addModelListener(
-        WebInspector.CPUProfilerModel, WebInspector.CPUProfilerModel.Events.ConsoleProfileFinished,
+    SDK.targetManager.addModelListener(
+        SDK.CPUProfilerModel, SDK.CPUProfilerModel.Events.ConsoleProfileFinished,
         this._consoleProfileFinished, this);
   }
 
   /**
    * @override
    * @return {string}
    */
   typeName() {
     return 'CPU';
   }
 
   /**
    * @override
    * @return {string}
    */
   fileExtension() {
     return '.cpuprofile';
   }
 
   get buttonTooltip() {
-    return this._recording ? WebInspector.UIString('Stop CPU profiling') : WebInspector.UIString('Start CPU profiling');
+    return this._recording ? Common.UIString('Stop CPU profiling') : Common.UIString('Start CPU profiling');
   }
 
   /**
    * @override
    * @return {boolean}
    */
   buttonClicked() {
     if (this._recording) {
       this.stopRecordingProfile();
       return false;
     } else {
       this.startRecordingProfile();
       return true;
     }
   }
 
   get treeItemTitle() {
-    return WebInspector.UIString('CPU PROFILES');
+    return Common.UIString('CPU PROFILES');
   }
 
   get description() {
-    return WebInspector.UIString(
+    return Common.UIString(
         'CPU profiles show where the execution time is spent in your page\'s JavaScript functions.');
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _consoleProfileStarted(event) {
-    var data = /** @type {!WebInspector.CPUProfilerModel.EventData} */ (event.data);
+    var data = /** @type {!SDK.CPUProfilerModel.EventData} */ (event.data);
     var resolvedTitle = data.title;
     if (!resolvedTitle) {
-      resolvedTitle = WebInspector.UIString('Profile %s', this._nextAnonymousConsoleProfileNumber++);
+      resolvedTitle = Common.UIString('Profile %s', this._nextAnonymousConsoleProfileNumber++);
       this._anonymousConsoleProfileIdToTitle[data.id] = resolvedTitle;
     }
     this._addMessageToConsole(
-        WebInspector.ConsoleMessage.MessageType.Profile, data.scriptLocation,
-        WebInspector.UIString('Profile \'%s\' started.', resolvedTitle));
+        SDK.ConsoleMessage.MessageType.Profile, data.scriptLocation,
+        Common.UIString('Profile \'%s\' started.', resolvedTitle));
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _consoleProfileFinished(event) {
-    var data = /** @type {!WebInspector.CPUProfilerModel.EventData} */ (event.data);
+    var data = /** @type {!SDK.CPUProfilerModel.EventData} */ (event.data);
     var cpuProfile = /** @type {!Protocol.Profiler.Profile} */ (data.cpuProfile);
     var resolvedTitle = data.title;
     if (typeof resolvedTitle === 'undefined') {
       resolvedTitle = this._anonymousConsoleProfileIdToTitle[data.id];
       delete this._anonymousConsoleProfileIdToTitle[data.id];
     }
-    var profile = new WebInspector.CPUProfileHeader(data.scriptLocation.target(), this, resolvedTitle);
+    var profile = new Profiler.CPUProfileHeader(data.scriptLocation.target(), this, resolvedTitle);
     profile.setProtocolProfile(cpuProfile);
     this.addProfile(profile);
     this._addMessageToConsole(
-        WebInspector.ConsoleMessage.MessageType.ProfileEnd, data.scriptLocation,
-        WebInspector.UIString('Profile \'%s\' finished.', resolvedTitle));
+        SDK.ConsoleMessage.MessageType.ProfileEnd, data.scriptLocation,
+        Common.UIString('Profile \'%s\' finished.', resolvedTitle));
   }
 
   /**
    * @param {string} type
-   * @param {!WebInspector.DebuggerModel.Location} scriptLocation
+   * @param {!SDK.DebuggerModel.Location} scriptLocation
    * @param {string} messageText
    */
   _addMessageToConsole(type, scriptLocation, messageText) {
     var script = scriptLocation.script();
     var target = scriptLocation.target();
-    var message = new WebInspector.ConsoleMessage(
-        target, WebInspector.ConsoleMessage.MessageSource.ConsoleAPI, WebInspector.ConsoleMessage.MessageLevel.Debug,
+    var message = new SDK.ConsoleMessage(
+        target, SDK.ConsoleMessage.MessageSource.ConsoleAPI, SDK.ConsoleMessage.MessageLevel.Debug,
         messageText, type, undefined, undefined, undefined, undefined, [{
           functionName: '',
           scriptId: scriptLocation.scriptId,
           url: script ? script.contentURL() : '',
           lineNumber: scriptLocation.lineNumber,
           columnNumber: scriptLocation.columnNumber || 0
         }]);
 
     target.consoleModel.addMessage(message);
   }
 
   startRecordingProfile() {
-    var target = WebInspector.context.flavor(WebInspector.Target);
+    var target = UI.context.flavor(SDK.Target);
     if (this._profileBeingRecorded || !target)
       return;
-    var profile = new WebInspector.CPUProfileHeader(target, this);
+    var profile = new Profiler.CPUProfileHeader(target, this);
     this.setProfileBeingRecorded(profile);
-    WebInspector.targetManager.suspendAllTargets();
+    SDK.targetManager.suspendAllTargets();
     this.addProfile(profile);
-    profile.updateStatus(WebInspector.UIString('Recording\u2026'));
+    profile.updateStatus(Common.UIString('Recording\u2026'));
     this._recording = true;
     target.cpuProfilerModel.startRecording();
   }
 
   stopRecordingProfile() {
     this._recording = false;
     if (!this._profileBeingRecorded || !this._profileBeingRecorded.target())
       return;
 
     var recordedProfile;
 
     /**
      * @param {?Protocol.Profiler.Profile} profile
-     * @this {WebInspector.CPUProfileType}
+     * @this {Profiler.CPUProfileType}
      */
     function didStopProfiling(profile) {
       if (!this._profileBeingRecorded)
         return;
       console.assert(profile);
       this._profileBeingRecorded.setProtocolProfile(profile);
       this._profileBeingRecorded.updateStatus('');
       recordedProfile = this._profileBeingRecorded;
       this.setProfileBeingRecorded(null);
     }
 
     /**
-     * @this {WebInspector.CPUProfileType}
+     * @this {Profiler.CPUProfileType}
      */
     function fireEvent() {
-      this.dispatchEventToListeners(WebInspector.ProfileType.Events.ProfileComplete, recordedProfile);
+      this.dispatchEventToListeners(Profiler.ProfileType.Events.ProfileComplete, recordedProfile);
     }
 
     this._profileBeingRecorded.target()
         .cpuProfilerModel.stopRecording()
         .then(didStopProfiling.bind(this))
-        .then(WebInspector.targetManager.resumeAllTargets.bind(WebInspector.targetManager))
+        .then(SDK.targetManager.resumeAllTargets.bind(SDK.targetManager))
         .then(fireEvent.bind(this));
   }
 
   /**
    * @override
    * @param {string} title
-   * @return {!WebInspector.ProfileHeader}
+   * @return {!Profiler.ProfileHeader}
    */
   createProfileLoadedFromFile(title) {
-    return new WebInspector.CPUProfileHeader(null, this, title);
+    return new Profiler.CPUProfileHeader(null, this, title);
   }
 
   /**
    * @override
    */
   profileBeingRecordedRemoved() {
     this.stopRecordingProfile();
   }
 };
 
-WebInspector.CPUProfileType.TypeId = 'CPU';
+Profiler.CPUProfileType.TypeId = 'CPU';
 
 /**
  * @unrestricted
  */
-WebInspector.CPUProfileHeader = class extends WebInspector.WritableProfileHeader {
+Profiler.CPUProfileHeader = class extends Profiler.WritableProfileHeader {
   /**
-   * @param {?WebInspector.Target} target
-   * @param {!WebInspector.CPUProfileType} type
+   * @param {?SDK.Target} target
+   * @param {!Profiler.CPUProfileType} type
    * @param {string=} title
    */
   constructor(target, type, title) {
     super(target, type, title);
   }
 
   /**
    * @override
-   * @return {!WebInspector.ProfileView}
+   * @return {!Profiler.ProfileView}
    */
   createView() {
-    return new WebInspector.CPUProfileView(this);
+    return new Profiler.CPUProfileView(this);
   }
 
   /**
    * @return {!Protocol.Profiler.Profile}
    */
   protocolProfile() {
     return this._protocolProfile;
   }
 };
 
 /**
- * @implements {WebInspector.ProfileDataGridNode.Formatter}
+ * @implements {Profiler.ProfileDataGridNode.Formatter}
  * @unrestricted
  */
-WebInspector.CPUProfileView.NodeFormatter = class {
+Profiler.CPUProfileView.NodeFormatter = class {
   constructor(profileView) {
     this._profileView = profileView;
   }
 
   /**
    * @override
    * @param {number} value
    * @return {string}
    */
   formatValue(value) {
-    return WebInspector.UIString('%.1f\u2009ms', value);
+    return Common.UIString('%.1f\u2009ms', value);
   }
 
   /**
    * @override
    * @param {number} value
-   * @param {!WebInspector.ProfileDataGridNode} node
+   * @param {!Profiler.ProfileDataGridNode} node
    * @return {string}
    */
   formatPercent(value, node) {
-    return node.profileNode === this._profileView.profile.idleNode ? '' : WebInspector.UIString('%.2f\u2009%%', value);
+    return node.profileNode === this._profileView.profile.idleNode ? '' : Common.UIString('%.2f\u2009%%', value);
   }
 
   /**
    * @override
-   * @param  {!WebInspector.ProfileDataGridNode} node
+   * @param  {!Profiler.ProfileDataGridNode} node
    * @return {?Element}
    */
   linkifyNode(node) {
     return this._profileView.linkifier().maybeLinkifyConsoleCallFrame(
         this._profileView.target(), node.profileNode.callFrame, 'profile-node-file');
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.CPUFlameChartDataProvider = class extends WebInspector.ProfileFlameChartDataProvider {
+Profiler.CPUFlameChartDataProvider = class extends Profiler.ProfileFlameChartDataProvider {
   /**
-   * @param {!WebInspector.CPUProfileDataModel} cpuProfile
-   * @param {?WebInspector.Target} target
+   * @param {!SDK.CPUProfileDataModel} cpuProfile
+   * @param {?SDK.Target} target
    */
   constructor(cpuProfile, target) {
     super(target);
     this._cpuProfile = cpuProfile;
   }
 
   /**
    * @override
-   * @return {!WebInspector.FlameChart.TimelineData}
+   * @return {!UI.FlameChart.TimelineData}
    */
   _calculateTimelineData() {
-    /** @type {!Array.<?WebInspector.CPUFlameChartDataProvider.ChartEntry>} */
+    /** @type {!Array.<?Profiler.CPUFlameChartDataProvider.ChartEntry>} */
     var entries = [];
     /** @type {!Array.<number>} */
     var stack = [];
     var maxDepth = 5;
 
     function onOpenFrame() {
       stack.push(entries.length);
       // Reserve space for the entry, as they have to be ordered by startTime.
       // The entry itself will be put there in onCloseFrame.
       entries.push(null);
     }
     /**
      * @param {number} depth
-     * @param {!WebInspector.CPUProfileNode} node
+     * @param {!SDK.CPUProfileNode} node
      * @param {number} startTime
      * @param {number} totalTime
      * @param {number} selfTime
      */
     function onCloseFrame(depth, node, startTime, totalTime, selfTime) {
       var index = stack.pop();
       entries[index] =
-          new WebInspector.CPUFlameChartDataProvider.ChartEntry(depth, totalTime, startTime, selfTime, node);
+          new Profiler.CPUFlameChartDataProvider.ChartEntry(depth, totalTime, startTime, selfTime, node);
       maxDepth = Math.max(maxDepth, depth);
     }
     this._cpuProfile.forEachFrame(onOpenFrame, onCloseFrame);
 
-    /** @type {!Array<!WebInspector.CPUProfileNode>} */
+    /** @type {!Array<!SDK.CPUProfileNode>} */
     var entryNodes = new Array(entries.length);
     var entryLevels = new Uint16Array(entries.length);
     var entryTotalTimes = new Float32Array(entries.length);
     var entrySelfTimes = new Float32Array(entries.length);
     var entryStartTimes = new Float64Array(entries.length);
     var minimumBoundary = this.minimumBoundary();
 
     for (var i = 0; i < entries.length; ++i) {
       var entry = entries[i];
       entryNodes[i] = entry.node;
       entryLevels[i] = entry.depth;
       entryTotalTimes[i] = entry.duration;
       entryStartTimes[i] = entry.startTime;
       entrySelfTimes[i] = entry.selfTime;
     }
 
     this._maxStackDepth = maxDepth;
 
-    this._timelineData = new WebInspector.FlameChart.TimelineData(entryLevels, entryTotalTimes, entryStartTimes, null);
+    this._timelineData = new UI.FlameChart.TimelineData(entryLevels, entryTotalTimes, entryStartTimes, null);
 
-    /** @type {!Array<!WebInspector.CPUProfileNode>} */
+    /** @type {!Array<!SDK.CPUProfileNode>} */
     this._entryNodes = entryNodes;
     this._entrySelfTimes = entrySelfTimes;
 
     return this._timelineData;
   }
 
   /**
    * @override
    * @param {number} entryIndex
    * @return {?Element}
@@ skipping 13 matching lines @@
       entryInfo.push({title: title, value: value});
     }
     /**
      * @param {number} ms
      * @return {string}
      */
     function millisecondsToString(ms) {
       if (ms === 0)
         return '0';
       if (ms < 1000)
-        return WebInspector.UIString('%.1f\u2009ms', ms);
+        return Common.UIString('%.1f\u2009ms', ms);
       return Number.secondsToString(ms / 1000, true);
     }
-    var name = WebInspector.beautifyFunctionName(node.functionName);
-    pushEntryInfoRow(WebInspector.UIString('Name'), name);
+    var name = UI.beautifyFunctionName(node.functionName);
+    pushEntryInfoRow(Common.UIString('Name'), name);
     var selfTime = millisecondsToString(this._entrySelfTimes[entryIndex]);
     var totalTime = millisecondsToString(timelineData.entryTotalTimes[entryIndex]);
-    pushEntryInfoRow(WebInspector.UIString('Self time'), selfTime);
-    pushEntryInfoRow(WebInspector.UIString('Total time'), totalTime);
-    var linkifier = new WebInspector.Linkifier();
+    pushEntryInfoRow(Common.UIString('Self time'), selfTime);
+    pushEntryInfoRow(Common.UIString('Total time'), totalTime);
+    var linkifier = new Components.Linkifier();
     var link = linkifier.maybeLinkifyConsoleCallFrame(this._target, node.callFrame);
     if (link)
-      pushEntryInfoRow(WebInspector.UIString('URL'), link.textContent);
+      pushEntryInfoRow(Common.UIString('URL'), link.textContent);
     linkifier.dispose();
-    pushEntryInfoRow(WebInspector.UIString('Aggregated self time'), Number.secondsToString(node.self / 1000, true));
-    pushEntryInfoRow(WebInspector.UIString('Aggregated total time'), Number.secondsToString(node.total / 1000, true));
+    pushEntryInfoRow(Common.UIString('Aggregated self time'), Number.secondsToString(node.self / 1000, true));
+    pushEntryInfoRow(Common.UIString('Aggregated total time'), Number.secondsToString(node.total / 1000, true));
     if (node.deoptReason)
-      pushEntryInfoRow(WebInspector.UIString('Not optimized'), node.deoptReason);
+      pushEntryInfoRow(Common.UIString('Not optimized'), node.deoptReason);
 
-    return WebInspector.ProfileView.buildPopoverTable(entryInfo);
+    return Profiler.ProfileView.buildPopoverTable(entryInfo);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.CPUFlameChartDataProvider.ChartEntry = class {
+Profiler.CPUFlameChartDataProvider.ChartEntry = class {
   /**
    * @param {number} depth
    * @param {number} duration
    * @param {number} startTime
    * @param {number} selfTime
-   * @param {!WebInspector.CPUProfileNode} node
+   * @param {!SDK.CPUProfileNode} node
    */
   constructor(depth, duration, startTime, selfTime, node) {
     this.depth = depth;
     this.duration = duration;
     this.startTime = startTime;
     this.selfTime = selfTime;
     this.node = node;
   }
 };