DevTools: rename WebInspector into modules.

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

 /*
  * Copyright (C) 2011 Google 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:
  *
  *     * Redistributions of source code must retain the above copyrightdd
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * 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.
  */
 
 /**
  * @unrestricted
  */
-WebInspector.HeapSnapshotWorkerProxy = class extends WebInspector.Object {
+Profiler.HeapSnapshotWorkerProxy = class extends Common.Object {
   /**
    * @param {function(string, *)} eventHandler
    */
   constructor(eventHandler) {
     super();
     this._eventHandler = eventHandler;
     this._nextObjectId = 1;
     this._nextCallId = 1;
     /** @type {!Map<number, function(*)>} */
     this._callbacks = new Map();
     /** @type {!Set<number>} */
     this._previousCallbacks = new Set();
-    this._worker = new WebInspector.Worker('heap_snapshot_worker');
+    this._worker = new Common.Worker('heap_snapshot_worker');
     this._worker.onmessage = this._messageReceived.bind(this);
   }
 
   /**
    * @param {number} profileUid
-   * @param {function(!WebInspector.HeapSnapshotProxy)} snapshotReceivedCallback
-   * @return {!WebInspector.HeapSnapshotLoaderProxy}
+   * @param {function(!Profiler.HeapSnapshotProxy)} snapshotReceivedCallback
+   * @return {!Profiler.HeapSnapshotLoaderProxy}
    */
   createLoader(profileUid, snapshotReceivedCallback) {
     var objectId = this._nextObjectId++;
-    var proxy = new WebInspector.HeapSnapshotLoaderProxy(this, objectId, profileUid, snapshotReceivedCallback);
+    var proxy = new Profiler.HeapSnapshotLoaderProxy(this, objectId, profileUid, snapshotReceivedCallback);
     this._postMessage({
       callId: this._nextCallId++,
       disposition: 'create',
       objectId: objectId,
-      methodName: 'WebInspector.HeapSnapshotLoader'
+      methodName: 'HeapSnapshotWorker.HeapSnapshotLoader'
     });
     return proxy;
   }
 
   dispose() {
     this._worker.terminate();
     if (this._interval)
       clearInterval(this._interval);
   }
 
@@ skipping 14 matching lines @@
    * @param {function(new:T, ...?)} proxyConstructor
    * @return {?Object}
    * @template T
    */
   callFactoryMethod(callback, objectId, methodName, proxyConstructor) {
     var callId = this._nextCallId++;
     var methodArguments = Array.prototype.slice.call(arguments, 4);
     var newObjectId = this._nextObjectId++;
 
     /**
-     * @this {WebInspector.HeapSnapshotWorkerProxy}
+     * @this {Profiler.HeapSnapshotWorkerProxy}
      */
     function wrapCallback(remoteResult) {
       callback(remoteResult ? new proxyConstructor(this, newObjectId) : null);
     }
 
     if (callback) {
       this._callbacks.set(callId, wrapCallback.bind(this));
       this._postMessage({
         callId: callId,
         disposition: 'factory',
@@ skipping 57 matching lines @@
    */
   _messageReceived(event) {
     var data = event.data;
     if (data.eventName) {
       if (this._eventHandler)
         this._eventHandler(data.eventName, data.data);
       return;
     }
     if (data.error) {
       if (data.errorMethodName)
-        WebInspector.console.error(WebInspector.UIString(
+        Common.console.error(Common.UIString(
             'An error occurred when a call to method \'%s\' was requested', data.errorMethodName));
-      WebInspector.console.error(data['errorCallStack']);
+      Common.console.error(data['errorCallStack']);
       this._callbacks.delete(data.callId);
       return;
     }
     if (!this._callbacks.has(data.callId))
       return;
     var callback = this._callbacks.get(data.callId);
     this._callbacks.delete(data.callId);
     callback(data.result);
   }
 
   _postMessage(message) {
     this._worker.postMessage(message);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.HeapSnapshotProxyObject = class {
+Profiler.HeapSnapshotProxyObject = class {
   /**
-   * @param {!WebInspector.HeapSnapshotWorkerProxy} worker
+   * @param {!Profiler.HeapSnapshotWorkerProxy} worker
    * @param {number} objectId
    */
   constructor(worker, objectId) {
     this._worker = worker;
     this._objectId = objectId;
   }
 
   /**
    * @param {string} workerMethodName
    * @param {!Array.<*>} args
@@ skipping 37 matching lines @@
   /**
    * @param {string} methodName
    * @param {...*} var_args
    * @return {!Promise.<?T>}
    * @template T
    */
   _callMethodPromise(methodName, var_args) {
     /**
      * @param {!Array.<*>} args
      * @param {function(?T)} fulfill
-     * @this {WebInspector.HeapSnapshotProxyObject}
+     * @this {Profiler.HeapSnapshotProxyObject}
      * @template T
      */
     function action(args, fulfill) {
       this._callWorker('callMethod', [fulfill].concat(args));
     }
     return new Promise(action.bind(this, Array.prototype.slice.call(arguments)));
   }
 };
 
 /**
- * @implements {WebInspector.OutputStream}
+ * @implements {Common.OutputStream}
  * @unrestricted
  */
-WebInspector.HeapSnapshotLoaderProxy = class extends WebInspector.HeapSnapshotProxyObject {
+Profiler.HeapSnapshotLoaderProxy = class extends Profiler.HeapSnapshotProxyObject {
   /**
-   * @param {!WebInspector.HeapSnapshotWorkerProxy} worker
+   * @param {!Profiler.HeapSnapshotWorkerProxy} worker
    * @param {number} objectId
    * @param {number} profileUid
-   * @param {function(!WebInspector.HeapSnapshotProxy)} snapshotReceivedCallback
+   * @param {function(!Profiler.HeapSnapshotProxy)} snapshotReceivedCallback
    */
   constructor(worker, objectId, profileUid, snapshotReceivedCallback) {
     super(worker, objectId);
     this._profileUid = profileUid;
     this._snapshotReceivedCallback = snapshotReceivedCallback;
   }
 
   /**
    * @override
    * @param {string} chunk
-   * @param {function(!WebInspector.OutputStream)=} callback
+   * @param {function(!Common.OutputStream)=} callback
    */
   write(chunk, callback) {
     this.callMethod(callback, 'write', chunk);
   }
 
   /**
    * @override
    * @param {function()=} callback
    */
   close(callback) {
     /**
-     * @this {WebInspector.HeapSnapshotLoaderProxy}
+     * @this {Profiler.HeapSnapshotLoaderProxy}
      */
     function buildSnapshot() {
       if (callback)
         callback();
-      this.callFactoryMethod(updateStaticData.bind(this), 'buildSnapshot', WebInspector.HeapSnapshotProxy);
+      this.callFactoryMethod(updateStaticData.bind(this), 'buildSnapshot', Profiler.HeapSnapshotProxy);
     }
 
     /**
-     * @param {!WebInspector.HeapSnapshotProxy} snapshotProxy
-     * @this {WebInspector.HeapSnapshotLoaderProxy}
+     * @param {!Profiler.HeapSnapshotProxy} snapshotProxy
+     * @this {Profiler.HeapSnapshotLoaderProxy}
      */
     function updateStaticData(snapshotProxy) {
       this.dispose();
       snapshotProxy.setProfileUid(this._profileUid);
       snapshotProxy.updateStaticData(this._snapshotReceivedCallback.bind(this));
     }
 
     this.callMethod(buildSnapshot.bind(this), 'close');
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.HeapSnapshotProxy = class extends WebInspector.HeapSnapshotProxyObject {
+Profiler.HeapSnapshotProxy = class extends Profiler.HeapSnapshotProxyObject {
   /**
-   * @param {!WebInspector.HeapSnapshotWorkerProxy} worker
+   * @param {!Profiler.HeapSnapshotWorkerProxy} worker
    * @param {number} objectId
    */
   constructor(worker, objectId) {
     super(worker, objectId);
-    /** @type {?WebInspector.HeapSnapshotCommon.StaticData} */
+    /** @type {?Profiler.HeapSnapshotCommon.StaticData} */
     this._staticData = null;
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotCommon.SearchConfig} searchConfig
-   * @param {!WebInspector.HeapSnapshotCommon.NodeFilter} filter
+   * @param {!Profiler.HeapSnapshotCommon.SearchConfig} searchConfig
+   * @param {!Profiler.HeapSnapshotCommon.NodeFilter} filter
    * @return {!Promise<!Array<number>>}
    */
   search(searchConfig, filter) {
     return this._callMethodPromise('search', searchConfig, filter);
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotCommon.NodeFilter} filter
-   * @param {function(!Object.<string, !WebInspector.HeapSnapshotCommon.Aggregate>)} callback
+   * @param {!Profiler.HeapSnapshotCommon.NodeFilter} filter
+   * @param {function(!Object.<string, !Profiler.HeapSnapshotCommon.Aggregate>)} callback
    */
   aggregatesWithFilter(filter, callback) {
     this.callMethod(callback, 'aggregatesWithFilter', filter);
   }
 
   aggregatesForDiff(callback) {
     this.callMethod(callback, 'aggregatesForDiff');
   }
 
   calculateSnapshotDiff(baseSnapshotId, baseSnapshotAggregates, callback) {
     this.callMethod(callback, 'calculateSnapshotDiff', baseSnapshotId, baseSnapshotAggregates);
   }
 
   /**
    * @param {number} snapshotObjectId
    * @return {!Promise<?string>}
    */
   nodeClassName(snapshotObjectId) {
     return this._callMethodPromise('nodeClassName', snapshotObjectId);
   }
 
   /**
    * @param {number} nodeIndex
-   * @return {!WebInspector.HeapSnapshotProviderProxy}
+   * @return {!Profiler.HeapSnapshotProviderProxy}
    */
   createEdgesProvider(nodeIndex) {
-    return this.callFactoryMethod(null, 'createEdgesProvider', WebInspector.HeapSnapshotProviderProxy, nodeIndex);
+    return this.callFactoryMethod(null, 'createEdgesProvider', Profiler.HeapSnapshotProviderProxy, nodeIndex);
   }
 
   /**
    * @param {number} nodeIndex
-   * @return {!WebInspector.HeapSnapshotProviderProxy}
+   * @return {!Profiler.HeapSnapshotProviderProxy}
    */
   createRetainingEdgesProvider(nodeIndex) {
     return this.callFactoryMethod(
-        null, 'createRetainingEdgesProvider', WebInspector.HeapSnapshotProviderProxy, nodeIndex);
+        null, 'createRetainingEdgesProvider', Profiler.HeapSnapshotProviderProxy, nodeIndex);
   }
 
   /**
    * @param {string} baseSnapshotId
    * @param {string} className
-   * @return {?WebInspector.HeapSnapshotProviderProxy}
+   * @return {?Profiler.HeapSnapshotProviderProxy}
    */
   createAddedNodesProvider(baseSnapshotId, className) {
     return this.callFactoryMethod(
-        null, 'createAddedNodesProvider', WebInspector.HeapSnapshotProviderProxy, baseSnapshotId, className);
+        null, 'createAddedNodesProvider', Profiler.HeapSnapshotProviderProxy, baseSnapshotId, className);
   }
 
   /**
    * @param {!Array.<number>} nodeIndexes
-   * @return {?WebInspector.HeapSnapshotProviderProxy}
+   * @return {?Profiler.HeapSnapshotProviderProxy}
    */
   createDeletedNodesProvider(nodeIndexes) {
     return this.callFactoryMethod(
-        null, 'createDeletedNodesProvider', WebInspector.HeapSnapshotProviderProxy, nodeIndexes);
+        null, 'createDeletedNodesProvider', Profiler.HeapSnapshotProviderProxy, nodeIndexes);
   }
 
   /**
    * @param {function(*):boolean} filter
-   * @return {?WebInspector.HeapSnapshotProviderProxy}
+   * @return {?Profiler.HeapSnapshotProviderProxy}
    */
   createNodesProvider(filter) {
-    return this.callFactoryMethod(null, 'createNodesProvider', WebInspector.HeapSnapshotProviderProxy, filter);
+    return this.callFactoryMethod(null, 'createNodesProvider', Profiler.HeapSnapshotProviderProxy, filter);
   }
 
   /**
    * @param {string} className
-   * @param {!WebInspector.HeapSnapshotCommon.NodeFilter} nodeFilter
-   * @return {?WebInspector.HeapSnapshotProviderProxy}
+   * @param {!Profiler.HeapSnapshotCommon.NodeFilter} nodeFilter
+   * @return {?Profiler.HeapSnapshotProviderProxy}
    */
   createNodesProviderForClass(className, nodeFilter) {
     return this.callFactoryMethod(
-        null, 'createNodesProviderForClass', WebInspector.HeapSnapshotProviderProxy, className, nodeFilter);
+        null, 'createNodesProviderForClass', Profiler.HeapSnapshotProviderProxy, className, nodeFilter);
   }
 
   allocationTracesTops(callback) {
     this.callMethod(callback, 'allocationTracesTops');
   }
 
   /**
    * @param {number} nodeId
-   * @param {function(!WebInspector.HeapSnapshotCommon.AllocationNodeCallers)} callback
+   * @param {function(!Profiler.HeapSnapshotCommon.AllocationNodeCallers)} callback
    */
   allocationNodeCallers(nodeId, callback) {
     this.callMethod(callback, 'allocationNodeCallers', nodeId);
   }
 
   /**
    * @param {number} nodeIndex
-   * @param {function(?Array.<!WebInspector.HeapSnapshotCommon.AllocationStackFrame>)} callback
+   * @param {function(?Array.<!Profiler.HeapSnapshotCommon.AllocationStackFrame>)} callback
    */
   allocationStack(nodeIndex, callback) {
     this.callMethod(callback, 'allocationStack', nodeIndex);
   }
 
   /**
    * @override
    */
   dispose() {
     throw new Error('Should never be called');
   }
 
   get nodeCount() {
     return this._staticData.nodeCount;
   }
 
   get rootNodeIndex() {
     return this._staticData.rootNodeIndex;
   }
 
   updateStaticData(callback) {
     /**
-     * @param {!WebInspector.HeapSnapshotCommon.StaticData} staticData
-     * @this {WebInspector.HeapSnapshotProxy}
+     * @param {!Profiler.HeapSnapshotCommon.StaticData} staticData
+     * @this {Profiler.HeapSnapshotProxy}
      */
     function dataReceived(staticData) {
       this._staticData = staticData;
       callback(this);
     }
     this.callMethod(dataReceived.bind(this), 'updateStaticData');
   }
 
   /**
-   * @return {!Promise.<!WebInspector.HeapSnapshotCommon.Statistics>}
+   * @return {!Promise.<!Profiler.HeapSnapshotCommon.Statistics>}
    */
   getStatistics() {
     return this._callMethodPromise('getStatistics');
   }
 
   /**
-   * @return {!Promise.<?WebInspector.HeapSnapshotCommon.Samples>}
+   * @return {!Promise.<?Profiler.HeapSnapshotCommon.Samples>}
    */
   getSamples() {
     return this._callMethodPromise('getSamples');
   }
 
   get totalSize() {
     return this._staticData.totalSize;
   }
 
   get uid() {
     return this._profileUid;
   }
 
   setProfileUid(profileUid) {
     this._profileUid = profileUid;
   }
 
   /**
    * @return {number}
    */
   maxJSObjectId() {
     return this._staticData.maxJSObjectId;
   }
 };
 
 /**
- * @implements {WebInspector.HeapSnapshotGridNode.ChildrenProvider}
+ * @implements {Profiler.HeapSnapshotGridNode.ChildrenProvider}
  * @unrestricted
  */
-WebInspector.HeapSnapshotProviderProxy = class extends WebInspector.HeapSnapshotProxyObject {
+Profiler.HeapSnapshotProviderProxy = class extends Profiler.HeapSnapshotProxyObject {
   /**
-   * @param {!WebInspector.HeapSnapshotWorkerProxy} worker
+   * @param {!Profiler.HeapSnapshotWorkerProxy} worker
    * @param {number} objectId
    */
   constructor(worker, objectId) {
     super(worker, objectId);
   }
 
   /**
    * @override
    * @param {number} snapshotObjectId
    * @return {!Promise<number>}
    */
   nodePosition(snapshotObjectId) {
     return this._callMethodPromise('nodePosition', snapshotObjectId);
   }
 
   /**
    * @override
    * @param {function(boolean)} callback
    */
   isEmpty(callback) {
     this.callMethod(callback, 'isEmpty');
   }
 
   /**
    * @override
    * @param {number} startPosition
    * @param {number} endPosition
-   * @param {function(!WebInspector.HeapSnapshotCommon.ItemsRange)} callback
+   * @param {function(!Profiler.HeapSnapshotCommon.ItemsRange)} callback
    */
   serializeItemsRange(startPosition, endPosition, callback) {
     this.callMethod(callback, 'serializeItemsRange', startPosition, endPosition);
   }
 
   /**
    * @override
-   * @param {!WebInspector.HeapSnapshotCommon.ComparatorConfig} comparator
+   * @param {!Profiler.HeapSnapshotCommon.ComparatorConfig} comparator
    * @return {!Promise<?>}
    */
   sortAndRewind(comparator) {
     return this._callMethodPromise('sortAndRewind', comparator);
   }
 };