DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/timeline_model/TracingLayerTree.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 {!{
         bounds: {height: number, width: number},
-        children: Array.<!WebInspector.TracingLayerPayload>,
+        children: Array.<!TimelineModel.TracingLayerPayload>,
         layer_id: number,
         position: Array.<number>,
         scroll_offset: Array.<number>,
         layer_quad: Array.<number>,
         draws_content: number,
         gpu_memory_usage: number,
         transform: Array.<number>,
         owner_node: number,
         compositing_reasons: Array.<string>
     }}
 */
-WebInspector.TracingLayerPayload;
+TimelineModel.TracingLayerPayload;
 
 /** @typedef {!{
         id: string,
         layer_id: string,
         gpu_memory_usage: number,
         content_rect: !Array.<number>
     }}
 */
-WebInspector.TracingLayerTile;
-
-/** @typedef {!{
-        rect: !Protocol.DOM.Rect,
-        snapshot: !WebInspector.PaintProfilerSnapshot
-    }}
-*/
-WebInspector.SnapshotWithRect;
+TimelineModel.TracingLayerTile;
 
 /**
  * @unrestricted
  */
-WebInspector.TracingLayerTree = class extends WebInspector.LayerTreeBase {
+TimelineModel.TracingLayerTree = class extends SDK.LayerTreeBase {
   /**
-   * @param {?WebInspector.Target} target
+   * @param {?SDK.Target} target
    */
   constructor(target) {
     super(target);
-    /** @type {!Map.<string, !WebInspector.TracingLayerTile>} */
+    /** @type {!Map.<string, !TimelineModel.TracingLayerTile>} */
     this._tileById = new Map();
   }
 
   /**
-   * @param {?WebInspector.TracingLayerPayload} root
-   * @param {?Array<!WebInspector.TracingLayerPayload>} layers
-   * @param {!Array<!WebInspector.LayerPaintEvent>} paints
+   * @param {?TimelineModel.TracingLayerPayload} root
+   * @param {?Array<!TimelineModel.TracingLayerPayload>} layers
+   * @param {!Array<!TimelineModel.LayerPaintEvent>} paints
    * @param {function()} callback
    */
   setLayers(root, layers, paints, callback) {
     var idsToResolve = new Set();
     if (root) {
       // This is a legacy code path for compatibility, as cc is removing
       // layer tree hierarchy, this code will eventually be removed.
       this._extractNodeIdsToResolve(idsToResolve, {}, root);
     } else {
       for (var i = 0; i < layers.length; ++i)
         this._extractNodeIdsToResolve(idsToResolve, {}, layers[i]);
     }
     this._resolveBackendNodeIds(idsToResolve, onBackendNodeIdsResolved.bind(this));
 
     /**
-     * @this {WebInspector.TracingLayerTree}
+     * @this {TimelineModel.TracingLayerTree}
      */
     function onBackendNodeIdsResolved() {
       var oldLayersById = this._layersById;
       this._layersById = {};
       this.setContentRoot(null);
       if (root) {
         var convertedLayers = this._innerSetLayers(oldLayersById, root);
         this.setRoot(convertedLayers);
       } else {
         var processedLayers = layers.map(this._innerSetLayers.bind(this, oldLayersById));
         var contentRoot = this.contentRoot();
         this.setRoot(contentRoot);
         for (var i = 0; i < processedLayers.length; ++i) {
           if (processedLayers[i].id() !== contentRoot.id())
             contentRoot.addChild(processedLayers[i]);
         }
       }
       this._setPaints(paints);
       callback();
     }
   }
 
   /**
-   * @param {!Array.<!WebInspector.TracingLayerTile>} tiles
+   * @param {!Array.<!TimelineModel.TracingLayerTile>} tiles
    */
   setTiles(tiles) {
     this._tileById = new Map();
     for (var tile of tiles)
       this._tileById.set(tile.id, tile);
   }
 
   /**
    * @param {string} tileId
-   * @return {!Promise<?WebInspector.SnapshotWithRect>}
+   * @return {!Promise<?SDK.SnapshotWithRect>}
    */
   pictureForRasterTile(tileId) {
     var tile = this._tileById.get('cc::Tile/' + tileId);
     if (!tile) {
-      WebInspector.console.error(`Tile ${tileId} is missing`);
-      return /** @type {!Promise<?WebInspector.SnapshotWithRect>} */ (Promise.resolve(null));
+      Common.console.error(`Tile ${tileId} is missing`);
+      return /** @type {!Promise<?SDK.SnapshotWithRect>} */ (Promise.resolve(null));
     }
     var layer = this.layerById(tile.layer_id);
     if (!layer) {
-      WebInspector.console.error(`Layer ${tile.layer_id} for tile ${tileId} is not found`);
-      return /** @type {!Promise<?WebInspector.SnapshotWithRect>} */ (Promise.resolve(null));
+      Common.console.error(`Layer ${tile.layer_id} for tile ${tileId} is not found`);
+      return /** @type {!Promise<?SDK.SnapshotWithRect>} */ (Promise.resolve(null));
     }
     return layer._pictureForRect(tile.content_rect);
   }
 
   /**
-   * @param {!Array<!WebInspector.LayerPaintEvent>} paints
+   * @param {!Array<!TimelineModel.LayerPaintEvent>} paints
    */
   _setPaints(paints) {
     for (var i = 0; i < paints.length; ++i) {
       var layer = this._layersById[paints[i].layerId()];
       if (layer)
         layer._addPaintEvent(paints[i]);
     }
   }
 
   /**
-   * @param {!Object<(string|number), !WebInspector.Layer>} oldLayersById
-   * @param {!WebInspector.TracingLayerPayload} payload
-   * @return {!WebInspector.TracingLayer}
+   * @param {!Object<(string|number), !SDK.Layer>} oldLayersById
+   * @param {!TimelineModel.TracingLayerPayload} payload
+   * @return {!TimelineModel.TracingLayer}
    */
   _innerSetLayers(oldLayersById, payload) {
-    var layer = /** @type {?WebInspector.TracingLayer} */ (oldLayersById[payload.layer_id]);
+    var layer = /** @type {?TimelineModel.TracingLayer} */ (oldLayersById[payload.layer_id]);
     if (layer)
       layer._reset(payload);
     else
-      layer = new WebInspector.TracingLayer(this.target(), payload);
+      layer = new TimelineModel.TracingLayer(this.target(), payload);
     this._layersById[payload.layer_id] = layer;
     if (payload.owner_node)
       layer._setNode(this._backendNodeIdToNode.get(payload.owner_node) || null);
     if (!this.contentRoot() && layer.drawsContent())
       this.setContentRoot(layer);
     for (var i = 0; payload.children && i < payload.children.length; ++i)
       layer.addChild(this._innerSetLayers(oldLayersById, payload.children[i]));
     return layer;
   }
 
   /**
    * @param {!Set<number>} nodeIdsToResolve
    * @param {!Object} seenNodeIds
-   * @param {!WebInspector.TracingLayerPayload} payload
+   * @param {!TimelineModel.TracingLayerPayload} payload
    */
   _extractNodeIdsToResolve(nodeIdsToResolve, seenNodeIds, payload) {
     var backendNodeId = payload.owner_node;
     if (backendNodeId && !this._backendNodeIdToNode.has(backendNodeId))
       nodeIdsToResolve.add(backendNodeId);
     for (var i = 0; payload.children && i < payload.children.length; ++i)
       this._extractNodeIdsToResolve(nodeIdsToResolve, seenNodeIds, payload.children[i]);
   }
 };
 
 /**
- * @implements {WebInspector.Layer}
+ * @implements {SDK.Layer}
  * @unrestricted
  */
-WebInspector.TracingLayer = class {
+TimelineModel.TracingLayer = class {
   /**
-   * @param {!WebInspector.TracingLayerPayload} payload
-   * @param {?WebInspector.Target} target
+   * @param {!TimelineModel.TracingLayerPayload} payload
+   * @param {?SDK.Target} target
    */
   constructor(target, payload) {
     this._target = target;
     this._reset(payload);
   }
 
   /**
-   * @param {!WebInspector.TracingLayerPayload} payload
+   * @param {!TimelineModel.TracingLayerPayload} payload
    */
   _reset(payload) {
-    /** @type {?WebInspector.DOMNode} */
+    /** @type {?SDK.DOMNode} */
     this._node = null;
     this._layerId = String(payload.layer_id);
     this._offsetX = payload.position[0];
     this._offsetY = payload.position[1];
     this._width = payload.bounds.width;
     this._height = payload.bounds.height;
     this._children = [];
     this._parentLayerId = null;
     this._parent = null;
     this._quad = payload.layer_quad || [];
@@ skipping 15 matching lines @@
   /**
    * @override
    * @return {?string}
    */
   parentId() {
     return this._parentLayerId;
   }
 
   /**
    * @override
-   * @return {?WebInspector.Layer}
+   * @return {?SDK.Layer}
    */
   parent() {
     return this._parent;
   }
 
   /**
    * @override
    * @return {boolean}
    */
   isRoot() {
     return !this.parentId();
   }
 
   /**
    * @override
-   * @return {!Array.<!WebInspector.Layer>}
+   * @return {!Array.<!SDK.Layer>}
    */
   children() {
     return this._children;
   }
 
   /**
    * @override
-   * @param {!WebInspector.Layer} child
+   * @param {!SDK.Layer} child
    */
   addChild(child) {
     if (child._parent)
       console.assert(false, 'Child already has a parent');
     this._children.push(child);
     child._parent = this;
     child._parentLayerId = this._layerId;
   }
 
   /**
-   * @param {?WebInspector.DOMNode} node
+   * @param {?SDK.DOMNode} node
    */
   _setNode(node) {
     this._node = node;
   }
 
   /**
    * @override
-   * @return {?WebInspector.DOMNode}
+   * @return {?SDK.DOMNode}
    */
   node() {
     return this._node;
   }
 
   /**
    * @override
-   * @return {?WebInspector.DOMNode}
+   * @return {?SDK.DOMNode}
    */
   nodeForSelfOrAncestor() {
     for (var layer = this; layer; layer = layer._parent) {
       if (layer._node)
         return layer._node;
     }
     return null;
   }
 
   /**
@@ skipping 87 matching lines @@
   /**
    * @override
    * @return {number}
    */
   gpuMemoryUsage() {
     return this._gpuMemoryUsage;
   }
 
   /**
    * @override
-   * @return {!Array<!Promise<?WebInspector.SnapshotWithRect>>}
+   * @return {!Array<!Promise<?SDK.SnapshotWithRect>>}
    */
   snapshots() {
     return this._paints.map(paint => paint.snapshotPromise().then(snapshot => {
       if (!snapshot)
         return null;
       var rect = {x: snapshot.rect[0], y: snapshot.rect[1], width: snapshot.rect[2], height: snapshot.rect[3]};
       return {rect: rect, snapshot: snapshot.snapshot};
     }));
   }
 
   /**
    * @param {!Array<number>} targetRect
-   * @return {!Promise<?WebInspector.SnapshotWithRect>}
+   * @return {!Promise<?SDK.SnapshotWithRect>}
    */
   _pictureForRect(targetRect) {
     return Promise.all(this._paints.map(paint => paint.picturePromise())).then(pictures => {
       var fragments =
           pictures.filter(picture => picture && rectsOverlap(picture.rect, targetRect))
               .map(picture => ({x: picture.rect[0], y: picture.rect[1], picture: picture.serializedPicture}));
       if (!fragments.length || !this._target)
         return null;
       var x0 = fragments.reduce((min, item) => Math.min(min, item.x), Infinity);
       var y0 = fragments.reduce((min, item) => Math.min(min, item.y), Infinity);
       // Rect is in layer content coordinates, make it relative to picture by offsetting to the top left corner.
       var rect = {x: targetRect[0] - x0, y: targetRect[1] - y0, width: targetRect[2], height: targetRect[3]};
-      return WebInspector.PaintProfilerSnapshot.loadFromFragments(this._target, fragments)
+      return SDK.PaintProfilerSnapshot.loadFromFragments(this._target, fragments)
           .then(snapshot => snapshot ? {rect: rect, snapshot: snapshot} : null);
     });
 
     /**
      * @param {number} a1
      * @param {number} a2
      * @param {number} b1
      * @param {number} b2
      * @return {boolean}
      */
@@ skipping 16 matching lines @@
   /**
    * @param {!Array.<number>} params
    * @param {string} type
    * @return {!Object}
    */
   _scrollRectsFromParams(params, type) {
     return {rect: {x: params[0], y: params[1], width: params[2], height: params[3]}, type: type};
   }
 
   /**
-   * @param {!WebInspector.TracingLayerPayload} payload
+   * @param {!TimelineModel.TracingLayerPayload} payload
    */
   _createScrollRects(payload) {
     this._scrollRects = [];
     if (payload.non_fast_scrollable_region)
       this._scrollRects.push(this._scrollRectsFromParams(
-          payload.non_fast_scrollable_region, WebInspector.Layer.ScrollRectType.NonFastScrollable.name));
+          payload.non_fast_scrollable_region, SDK.Layer.ScrollRectType.NonFastScrollable.name));
     if (payload.touch_event_handler_region)
       this._scrollRects.push(this._scrollRectsFromParams(
-          payload.touch_event_handler_region, WebInspector.Layer.ScrollRectType.TouchEventHandler.name));
+          payload.touch_event_handler_region, SDK.Layer.ScrollRectType.TouchEventHandler.name));
     if (payload.wheel_event_handler_region)
       this._scrollRects.push(this._scrollRectsFromParams(
-          payload.wheel_event_handler_region, WebInspector.Layer.ScrollRectType.WheelEventHandler.name));
+          payload.wheel_event_handler_region, SDK.Layer.ScrollRectType.WheelEventHandler.name));
     if (payload.scroll_event_handler_region)
       this._scrollRects.push(this._scrollRectsFromParams(
-          payload.scroll_event_handler_region, WebInspector.Layer.ScrollRectType.RepaintsOnScroll.name));
+          payload.scroll_event_handler_region, SDK.Layer.ScrollRectType.RepaintsOnScroll.name));
   }
 
   /**
-   * @param {!WebInspector.LayerPaintEvent} paint
+   * @param {!TimelineModel.LayerPaintEvent} paint
    */
   _addPaintEvent(paint) {
     this._paints.push(paint);
   }
 
   /**
    * @override
    * @param {function(!Array.<string>)} callback
    */
   requestCompositingReasons(callback) {
     callback(this._compositingReasons);
   }
 
   /**
    * @override
    * @return {boolean}
    */
   drawsContent() {
     return this._drawsContent;
   }
 };