DevTools: Extract HeapSnapshotCommon.js into HeapSnapshotModel module

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 316 matching lines @@
 /**
  * @unrestricted
  */
 Profiler.HeapSnapshotProxy = class extends Profiler.HeapSnapshotProxyObject {
   /**
    * @param {!Profiler.HeapSnapshotWorkerProxy} worker
    * @param {number} objectId
    */
   constructor(worker, objectId) {
     super(worker, objectId);
-    /** @type {?Profiler.HeapSnapshotCommon.StaticData} */
+    /** @type {?HeapSnapshotModel.StaticData} */
     this._staticData = null;
   }
 
   /**
-   * @param {!Profiler.HeapSnapshotCommon.SearchConfig} searchConfig
-   * @param {!Profiler.HeapSnapshotCommon.NodeFilter} filter
+   * @param {!HeapSnapshotModel.SearchConfig} searchConfig
+   * @param {!HeapSnapshotModel.NodeFilter} filter
    * @return {!Promise<!Array<number>>}
    */
   search(searchConfig, filter) {
     return this._callMethodPromise('search', searchConfig, filter);
   }
 
   /**
-   * @param {!Profiler.HeapSnapshotCommon.NodeFilter} filter
-   * @param {function(!Object.<string, !Profiler.HeapSnapshotCommon.Aggregate>)} callback
+   * @param {!HeapSnapshotModel.NodeFilter} filter
+   * @param {function(!Object.<string, !HeapSnapshotModel.Aggregate>)} callback
    */
   aggregatesWithFilter(filter, callback) {
     this.callMethod(callback, 'aggregatesWithFilter', filter);
   }
 
   aggregatesForDiff(callback) {
     this.callMethod(callback, 'aggregatesForDiff');
   }
 
   calculateSnapshotDiff(baseSnapshotId, baseSnapshotAggregates, callback) {
@@ skipping 45 matching lines @@
   /**
    * @param {function(*):boolean} filter
    * @return {?Profiler.HeapSnapshotProviderProxy}
    */
   createNodesProvider(filter) {
     return this.callFactoryMethod(null, 'createNodesProvider', Profiler.HeapSnapshotProviderProxy, filter);
   }
 
   /**
    * @param {string} className
-   * @param {!Profiler.HeapSnapshotCommon.NodeFilter} nodeFilter
+   * @param {!HeapSnapshotModel.NodeFilter} nodeFilter
    * @return {?Profiler.HeapSnapshotProviderProxy}
    */
   createNodesProviderForClass(className, nodeFilter) {
     return this.callFactoryMethod(
         null, 'createNodesProviderForClass', Profiler.HeapSnapshotProviderProxy, className, nodeFilter);
   }
 
   allocationTracesTops(callback) {
     this.callMethod(callback, 'allocationTracesTops');
   }
 
   /**
    * @param {number} nodeId
-   * @param {function(!Profiler.HeapSnapshotCommon.AllocationNodeCallers)} callback
+   * @param {function(!HeapSnapshotModel.AllocationNodeCallers)} callback
    */
   allocationNodeCallers(nodeId, callback) {
     this.callMethod(callback, 'allocationNodeCallers', nodeId);
   }
 
   /**
    * @param {number} nodeIndex
-   * @param {function(?Array.<!Profiler.HeapSnapshotCommon.AllocationStackFrame>)} callback
+   * @param {function(?Array.<!HeapSnapshotModel.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 {!Profiler.HeapSnapshotCommon.StaticData} staticData
+     * @param {!HeapSnapshotModel.StaticData} staticData
      * @this {Profiler.HeapSnapshotProxy}
      */
     function dataReceived(staticData) {
       this._staticData = staticData;
       callback(this);
     }
     this.callMethod(dataReceived.bind(this), 'updateStaticData');
   }
 
   /**
-   * @return {!Promise.<!Profiler.HeapSnapshotCommon.Statistics>}
+   * @return {!Promise.<!HeapSnapshotModel.Statistics>}
    */
   getStatistics() {
     return this._callMethodPromise('getStatistics');
   }
 
   /**
-   * @return {!Promise.<?Profiler.HeapSnapshotCommon.Samples>}
+   * @return {!Promise.<?HeapSnapshotModel.Samples>}
    */
   getSamples() {
     return this._callMethodPromise('getSamples');
   }
 
   get totalSize() {
     return this._staticData.totalSize;
   }
 
   get uid() {
@@ skipping 39 matching lines @@
    * @param {function(boolean)} callback
    */
   isEmpty(callback) {
     this.callMethod(callback, 'isEmpty');
   }
 
   /**
    * @override
    * @param {number} startPosition
    * @param {number} endPosition
-   * @param {function(!Profiler.HeapSnapshotCommon.ItemsRange)} callback
+   * @param {function(!HeapSnapshotModel.ItemsRange)} callback
    */
   serializeItemsRange(startPosition, endPosition, callback) {
     this.callMethod(callback, 'serializeItemsRange', startPosition, endPosition);
   }
 
   /**
    * @override
-   * @param {!Profiler.HeapSnapshotCommon.ComparatorConfig} comparator
+   * @param {!HeapSnapshotModel.ComparatorConfig} comparator
    * @return {!Promise<?>}
    */
   sortAndRewind(comparator) {
     return this._callMethodPromise('sortAndRewind', comparator);
   }
 };