DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/sdk/CPUProfileDataModel.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
  * @unrestricted
  */
-WebInspector.CPUProfileNode = class extends WebInspector.ProfileNode {
+SDK.CPUProfileNode = class extends SDK.ProfileNode {
   /**
    * @param {!Protocol.Profiler.ProfileNode} node
    * @param {number} sampleTime
    */
   constructor(node, sampleTime) {
     var callFrame = node.callFrame || /** @type {!Protocol.Runtime.CallFrame} */ ({
                       // Backward compatibility for old SamplingHeapProfileNode format.
                       functionName: node['functionName'],
                       scriptId: node['scriptId'],
                       url: node['url'],
                       lineNumber: node['lineNumber'] - 1,
                       columnNumber: node['columnNumber'] - 1
                     });
     super(callFrame);
     this.id = node.id;
     this.self = node.hitCount * sampleTime;
     this.positionTicks = node.positionTicks;
     // Compatibility: legacy backends could provide "no reason" for optimized functions.
     this.deoptReason = node.deoptReason && node.deoptReason !== 'no reason' ? node.deoptReason : null;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.CPUProfileDataModel = class extends WebInspector.ProfileTreeModel {
+SDK.CPUProfileDataModel = class extends SDK.ProfileTreeModel {
   /**
    * @param {!Protocol.Profiler.Profile} profile
    */
   constructor(profile) {
     super();
     var isLegacyFormat = !!profile['head'];
     if (isLegacyFormat) {
       // Legacy format contains raw timestamps and start/stop times are in seconds.
       this.profileStartTime = profile.startTime * 1000;
       this.profileEndTime = profile.endTime * 1000;
@@ skipping 50 matching lines @@
     var timestamps = new Array(profile.timeDeltas.length);
     for (var i = 0; i < timestamps.length; ++i) {
       lastTimeUsec += profile.timeDeltas[i];
       timestamps[i] = lastTimeUsec;
     }
     return timestamps;
   }
 
   /**
    * @param {!Array<!Protocol.Profiler.ProfileNode>} nodes
-   * @return {!WebInspector.CPUProfileNode}
+   * @return {!SDK.CPUProfileNode}
    */
   _translateProfileTree(nodes) {
     /**
      * @param {!Protocol.Profiler.ProfileNode} node
      * @return {boolean}
      */
     function isNativeNode(node) {
       if (node.callFrame)
         return !!node.callFrame.url && node.callFrame.url.startsWith('native ');
       return !!node['url'] && node['url'].startsWith('native ');
@@ skipping 16 matching lines @@
     }
     /** @type {!Map<number, !Protocol.Profiler.ProfileNode>} */
     var nodeByIdMap = new Map();
     for (var i = 0; i < nodes.length; ++i) {
       var node = nodes[i];
       nodeByIdMap.set(node.id, node);
     }
     buildChildrenFromParents(nodes);
     this.totalHitCount = nodes.reduce((acc, node) => acc + node.hitCount, 0);
     var sampleTime = (this.profileEndTime - this.profileStartTime) / this.totalHitCount;
-    var keepNatives = !!WebInspector.moduleSetting('showNativeFunctionsInJSProfile').get();
+    var keepNatives = !!Common.moduleSetting('showNativeFunctionsInJSProfile').get();
     var root = nodes[0];
     /** @type {!Map<number, number>} */
     var idMap = new Map([[root.id, root.id]]);
-    var resultRoot = new WebInspector.CPUProfileNode(root, sampleTime);
+    var resultRoot = new SDK.CPUProfileNode(root, sampleTime);
     var parentNodeStack = root.children.map(() => resultRoot);
     var sourceNodeStack = root.children.map(id => nodeByIdMap.get(id));
     while (sourceNodeStack.length) {
       var parentNode = parentNodeStack.pop();
       var sourceNode = sourceNodeStack.pop();
       if (!sourceNode.children)
         sourceNode.children = [];
-      var targetNode = new WebInspector.CPUProfileNode(sourceNode, sampleTime);
+      var targetNode = new SDK.CPUProfileNode(sourceNode, sampleTime);
       if (keepNatives || !isNativeNode(sourceNode)) {
         parentNode.children.push(targetNode);
         parentNode = targetNode;
       } else {
         parentNode.self += targetNode.self;
       }
       idMap.set(sourceNode.id, parentNode.id);
       parentNodeStack.push.apply(parentNodeStack, sourceNode.children.map(() => parentNode));
       sourceNodeStack.push.apply(sourceNodeStack, sourceNode.children.map(id => nodeByIdMap.get(id)));
     }
@@ skipping 47 matching lines @@
     for (var i = 0; i < timestamps.length; ++i)
       timestamps[i] /= 1000;
     var averageSample = (timestamps.peekLast() - timestamps[0]) / (timestamps.length - 1);
     // Add an extra timestamp used to calculate the last sample duration.
     this.timestamps.push(timestamps.peekLast() + averageSample);
     this.profileStartTime = timestamps[0];
     this.profileEndTime = timestamps.peekLast();
   }
 
   _buildIdToNodeMap() {
-    /** @type {!Map<number, !WebInspector.CPUProfileNode>} */
+    /** @type {!Map<number, !SDK.CPUProfileNode>} */
     this._idToNode = new Map();
     var idToNode = this._idToNode;
     var stack = [this.profileHead];
     while (stack.length) {
       var node = stack.pop();
       idToNode.set(node.id, node);
       stack.push.apply(stack, node.children);
     }
   }
 
   _extractMetaNodes() {
     var topLevelNodes = this.profileHead.children;
     for (var i = 0; i < topLevelNodes.length && !(this.gcNode && this.programNode && this.idleNode); i++) {
       var node = topLevelNodes[i];
       if (node.functionName === '(garbage collector)')
         this.gcNode = node;
       else if (node.functionName === '(program)')
         this.programNode = node;
       else if (node.functionName === '(idle)')
         this.idleNode = node;
     }
   }
 
   /**
-   * @param {function(number, !WebInspector.CPUProfileNode, number)} openFrameCallback
-   * @param {function(number, !WebInspector.CPUProfileNode, number, number, number)} closeFrameCallback
+   * @param {function(number, !SDK.CPUProfileNode, number)} openFrameCallback
+   * @param {function(number, !SDK.CPUProfileNode, number, number, number)} closeFrameCallback
    * @param {number=} startTime
    * @param {number=} stopTime
    */
   forEachFrame(openFrameCallback, closeFrameCallback, startTime, stopTime) {
     if (!this.profileHead || !this.samples)
       return;
 
     startTime = startTime || 0;
     stopTime = stopTime || Infinity;
     var samples = this.samples;
@@ skipping 50 matching lines @@
         stackNodes.push(node);
         node = node.parent;
       }
 
       // Go down to the LCA and close current intervals.
       while (prevNode !== node) {
         var start = stackStartTimes[stackTop];
         var duration = sampleTime - start;
         stackChildrenDuration[stackTop - 1] += duration;
         closeFrameCallback(
-            prevNode.depth, /** @type {!WebInspector.CPUProfileNode} */ (prevNode), start, duration,
+            prevNode.depth, /** @type {!SDK.CPUProfileNode} */ (prevNode), start, duration,
             duration - stackChildrenDuration[stackTop]);
         --stackTop;
         if (node.depth === prevNode.depth) {
           stackNodes.push(node);
           node = node.parent;
         }
         prevNode = prevNode.parent;
       }
 
       // Go up the nodes stack and open new intervals.
@@ skipping 13 matching lines @@
       stackChildrenDuration[stackTop - 1] += duration;
       closeFrameCallback(gcParentNode.depth + 1, node, start, duration, duration - stackChildrenDuration[stackTop]);
       --stackTop;
     }
 
     for (var node = idToNode.get(prevId); node.parent; node = node.parent) {
       var start = stackStartTimes[stackTop];
       var duration = sampleTime - start;
       stackChildrenDuration[stackTop - 1] += duration;
       closeFrameCallback(
-          node.depth, /** @type {!WebInspector.CPUProfileNode} */ (node), start, duration,
+          node.depth, /** @type {!SDK.CPUProfileNode} */ (node), start, duration,
           duration - stackChildrenDuration[stackTop]);
       --stackTop;
     }
   }
 
   /**
    * @param {number} index
-   * @return {?WebInspector.CPUProfileNode}
+   * @return {?SDK.CPUProfileNode}
    */
   nodeByIndex(index) {
     return this._idToNode.get(this.samples[index]) || null;
   }
 };