DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/layers/LayerTreeModel.js

 /*
  * Copyright (C) 2013 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 copyright
  * 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.LayerTreeModel = class extends WebInspector.SDKModel {
+Layers.LayerTreeModel = class extends SDK.SDKModel {
   constructor(target) {
-    super(WebInspector.LayerTreeModel, target);
-    target.registerLayerTreeDispatcher(new WebInspector.LayerTreeDispatcher(this));
-    WebInspector.targetManager.addEventListener(
-        WebInspector.TargetManager.Events.MainFrameNavigated, this._onMainFrameNavigated, this);
-    /** @type {?WebInspector.LayerTreeBase} */
+    super(Layers.LayerTreeModel, target);
+    target.registerLayerTreeDispatcher(new Layers.LayerTreeDispatcher(this));
+    SDK.targetManager.addEventListener(
+        SDK.TargetManager.Events.MainFrameNavigated, this._onMainFrameNavigated, this);
+    /** @type {?SDK.LayerTreeBase} */
     this._layerTree = null;
   }
 
   /**
-   * @param {!WebInspector.Target} target
-   * @return {?WebInspector.LayerTreeModel}
+   * @param {!SDK.Target} target
+   * @return {?Layers.LayerTreeModel}
    */
   static fromTarget(target) {
     if (!target.hasDOMCapability())
       return null;
 
-    var model = /** @type {?WebInspector.LayerTreeModel} */ (target.model(WebInspector.LayerTreeModel));
+    var model = /** @type {?Layers.LayerTreeModel} */ (target.model(Layers.LayerTreeModel));
     if (!model)
-      model = new WebInspector.LayerTreeModel(target);
+      model = new Layers.LayerTreeModel(target);
     return model;
   }
 
   disable() {
     if (!this._enabled)
       return;
     this._enabled = false;
     this.target().layerTreeAgent().disable();
   }
 
   enable() {
     if (this._enabled)
       return;
     this._enabled = true;
     this._forceEnable();
   }
 
   _forceEnable() {
     this._lastPaintRectByLayerId = {};
     if (!this._layerTree)
-      this._layerTree = new WebInspector.AgentLayerTree(this.target());
+      this._layerTree = new Layers.AgentLayerTree(this.target());
     this.target().layerTreeAgent().enable();
   }
 
   /**
-   * @return {?WebInspector.LayerTreeBase}
+   * @return {?SDK.LayerTreeBase}
    */
   layerTree() {
     return this._layerTree;
   }
 
   /**
    * @param {?Array.<!Protocol.LayerTree.Layer>} layers
    */
   _layerTreeChanged(layers) {
     if (!this._enabled)
       return;
-    var layerTree = /** @type {!WebInspector.AgentLayerTree} */ (this._layerTree);
+    var layerTree = /** @type {!Layers.AgentLayerTree} */ (this._layerTree);
     layerTree.setLayers(layers, onLayersSet.bind(this));
 
     /**
-     * @this {WebInspector.LayerTreeModel}
+     * @this {Layers.LayerTreeModel}
      */
     function onLayersSet() {
       for (var layerId in this._lastPaintRectByLayerId) {
         var lastPaintRect = this._lastPaintRectByLayerId[layerId];
         var layer = layerTree.layerById(layerId);
         if (layer)
           layer._lastPaintRect = lastPaintRect;
       }
       this._lastPaintRectByLayerId = {};
 
-      this.dispatchEventToListeners(WebInspector.LayerTreeModel.Events.LayerTreeChanged);
+      this.dispatchEventToListeners(Layers.LayerTreeModel.Events.LayerTreeChanged);
     }
   }
 
   /**
    * @param {!Protocol.LayerTree.LayerId} layerId
    * @param {!Protocol.DOM.Rect} clipRect
    */
   _layerPainted(layerId, clipRect) {
     if (!this._enabled)
       return;
-    var layerTree = /** @type {!WebInspector.AgentLayerTree} */ (this._layerTree);
+    var layerTree = /** @type {!Layers.AgentLayerTree} */ (this._layerTree);
     var layer = layerTree.layerById(layerId);
     if (!layer) {
       this._lastPaintRectByLayerId[layerId] = clipRect;
       return;
     }
     layer._didPaint(clipRect);
-    this.dispatchEventToListeners(WebInspector.LayerTreeModel.Events.LayerPainted, layer);
+    this.dispatchEventToListeners(Layers.LayerTreeModel.Events.LayerPainted, layer);
   }
 
   _onMainFrameNavigated() {
     this._layerTree = null;
     if (this._enabled)
       this._forceEnable();
   }
 };
 
 /** @enum {symbol} */
-WebInspector.LayerTreeModel.Events = {
+Layers.LayerTreeModel.Events = {
   LayerTreeChanged: Symbol('LayerTreeChanged'),
   LayerPainted: Symbol('LayerPainted'),
 };
 
 /**
  * @unrestricted
  */
-WebInspector.AgentLayerTree = class extends WebInspector.LayerTreeBase {
+Layers.AgentLayerTree = class extends SDK.LayerTreeBase {
   /**
-   * @param {?WebInspector.Target} target
+   * @param {?SDK.Target} target
    */
   constructor(target) {
     super(target);
   }
 
   /**
    * @param {?Array.<!Protocol.LayerTree.Layer>} payload
    * @param {function()} callback
    */
   setLayers(payload, callback) {
     if (!payload) {
       onBackendNodeIdsResolved.call(this);
       return;
     }
 
     var idsToResolve = new Set();
     for (var i = 0; i < payload.length; ++i) {
       var backendNodeId = payload[i].backendNodeId;
       if (!backendNodeId || this._backendNodeIdToNode.has(backendNodeId))
         continue;
       idsToResolve.add(backendNodeId);
     }
     this._resolveBackendNodeIds(idsToResolve, onBackendNodeIdsResolved.bind(this));
 
     /**
-     * @this {WebInspector.AgentLayerTree}
+     * @this {Layers.AgentLayerTree}
      */
     function onBackendNodeIdsResolved() {
       this._innerSetLayers(payload);
       callback();
     }
   }
 
   /**
    * @param {?Array.<!Protocol.LayerTree.Layer>} layers
    */
   _innerSetLayers(layers) {
     this.setRoot(null);
     this.setContentRoot(null);
     // Payload will be null when not in the composited mode.
     if (!layers)
       return;
     var root;
     var oldLayersById = this._layersById;
     this._layersById = {};
     for (var i = 0; i < layers.length; ++i) {
       var layerId = layers[i].layerId;
       var layer = oldLayersById[layerId];
       if (layer)
         layer._reset(layers[i]);
       else
-        layer = new WebInspector.AgentLayer(this._target, layers[i]);
+        layer = new Layers.AgentLayer(this._target, layers[i]);
       this._layersById[layerId] = layer;
       var backendNodeId = layers[i].backendNodeId;
       if (backendNodeId)
         layer._setNode(this._backendNodeIdToNode.get(backendNodeId));
       if (!this.contentRoot() && layer.drawsContent())
         this.setContentRoot(layer);
       var parentId = layer.parentId();
       if (parentId) {
         var parent = this._layersById[parentId];
         if (!parent)
           console.assert(parent, 'missing parent ' + parentId + ' for layer ' + layerId);
         parent.addChild(layer);
       } else {
         if (root)
           console.assert(false, 'Multiple root layers');
         root = layer;
       }
     }
     if (root) {
       this.setRoot(root);
       root._calculateQuad(new WebKitCSSMatrix());
     }
   }
 };
 
 /**
- * @implements {WebInspector.Layer}
+ * @implements {SDK.Layer}
  * @unrestricted
  */
-WebInspector.AgentLayer = class {
+Layers.AgentLayer = class {
   /**
-   * @param {?WebInspector.Target} target
+   * @param {?SDK.Target} target
    * @param {!Protocol.LayerTree.Layer} layerPayload
    */
   constructor(target, layerPayload) {
     this._target = target;
     this._reset(layerPayload);
   }
 
   /**
    * @override
    * @return {string}
    */
   id() {
     return this._layerPayload.layerId;
   }
 
   /**
    * @override
    * @return {?string}
    */
   parentId() {
     return this._layerPayload.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;
   }
 
   /**
-   * @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 118 matching lines @@
   gpuMemoryUsage() {
     /**
      * @const
      */
     var bytesPerPixel = 4;
     return this.drawsContent() ? this.width() * this.height() * bytesPerPixel : 0;
   }
 
   /**
    * @override
-   * @return {!Array<!Promise<?WebInspector.SnapshotWithRect>>}
+   * @return {!Array<!Promise<?SDK.SnapshotWithRect>>}
    */
   snapshots() {
     var rect = {x: 0, y: 0, width: this.width(), height: this.height()};
     var promise = this._target.layerTreeAgent().makeSnapshot(
         this.id(), (error, snapshotId) => error || !this._target ?
             null :
-            {rect: rect, snapshot: new WebInspector.PaintProfilerSnapshot(this._target, snapshotId)});
+            {rect: rect, snapshot: new SDK.PaintProfilerSnapshot(this._target, snapshotId)});
     return [promise];
   }
 
   /**
    * @param {!Protocol.DOM.Rect} rect
    */
   _didPaint(rect) {
     this._lastPaintRect = rect;
     this._paintCount = this.paintCount() + 1;
     this._image = null;
   }
 
   /**
    * @param {!Protocol.LayerTree.Layer} layerPayload
    */
   _reset(layerPayload) {
-    /** @type {?WebInspector.DOMNode} */
+    /** @type {?SDK.DOMNode} */
     this._node = null;
     this._children = [];
     this._parent = null;
     this._paintCount = 0;
     this._layerPayload = layerPayload;
     this._image = null;
     this._scrollRects = this._layerPayload.scrollRects || [];
   }
 
   /**
@@ skipping 10 matching lines @@
   /**
    * @param {!CSSMatrix} parentTransform
    * @return {!CSSMatrix}
    */
   _calculateTransformToViewport(parentTransform) {
     var offsetMatrix = new WebKitCSSMatrix().translate(this._layerPayload.offsetX, this._layerPayload.offsetY);
     var matrix = offsetMatrix;
 
     if (this._layerPayload.transform) {
       var transformMatrix = this._matrixFromArray(this._layerPayload.transform);
-      var anchorVector = new WebInspector.Geometry.Vector(
+      var anchorVector = new Common.Geometry.Vector(
           this._layerPayload.width * this.anchorPoint()[0], this._layerPayload.height * this.anchorPoint()[1],
           this.anchorPoint()[2]);
-      var anchorPoint = WebInspector.Geometry.multiplyVectorByMatrixAndNormalize(anchorVector, matrix);
+      var anchorPoint = Common.Geometry.multiplyVectorByMatrixAndNormalize(anchorVector, matrix);
       var anchorMatrix = new WebKitCSSMatrix().translate(-anchorPoint.x, -anchorPoint.y, -anchorPoint.z);
       matrix = anchorMatrix.inverse().multiply(transformMatrix.multiply(anchorMatrix.multiply(matrix)));
     }
 
     matrix = parentTransform.multiply(matrix);
     return matrix;
   }
 
   /**
    * @param {number} width
    * @param {number} height
    * @return {!Array.<number>}
    */
   _createVertexArrayForRect(width, height) {
     return [0, 0, 0, width, 0, 0, width, height, 0, 0, height, 0];
   }
 
   /**
    * @param {!CSSMatrix} parentTransform
    */
   _calculateQuad(parentTransform) {
     var matrix = this._calculateTransformToViewport(parentTransform);
     this._quad = [];
     var vertices = this._createVertexArrayForRect(this._layerPayload.width, this._layerPayload.height);
     for (var i = 0; i < 4; ++i) {
-      var point = WebInspector.Geometry.multiplyVectorByMatrixAndNormalize(
-          new WebInspector.Geometry.Vector(vertices[i * 3], vertices[i * 3 + 1], vertices[i * 3 + 2]), matrix);
+      var point = Common.Geometry.multiplyVectorByMatrixAndNormalize(
+          new Common.Geometry.Vector(vertices[i * 3], vertices[i * 3 + 1], vertices[i * 3 + 2]), matrix);
       this._quad.push(point.x, point.y);
     }
 
     function calculateQuadForLayer(layer) {
       layer._calculateQuad(matrix);
     }
 
     this._children.forEach(calculateQuadForLayer);
   }
 };
 
 /**
  * @implements {Protocol.LayerTreeDispatcher}
  * @unrestricted
  */
-WebInspector.LayerTreeDispatcher = class {
+Layers.LayerTreeDispatcher = class {
   /**
-   * @param {!WebInspector.LayerTreeModel} layerTreeModel
+   * @param {!Layers.LayerTreeModel} layerTreeModel
    */
   constructor(layerTreeModel) {
     this._layerTreeModel = layerTreeModel;
   }
 
   /**
    * @override
    * @param {!Array.<!Protocol.LayerTree.Layer>=} layers
    */
   layerTreeDidChange(layers) {
     this._layerTreeModel._layerTreeChanged(layers || null);
   }
 
   /**
    * @override
    * @param {!Protocol.LayerTree.LayerId} layerId
    * @param {!Protocol.DOM.Rect} clipRect
    */
   layerPainted(layerId, clipRect) {
     this._layerTreeModel._layerPainted(layerId, clipRect);
   }
 };