Added showing slow scroll rectangles in Layers panel.

Source/devtools/front_end/Layers3DView.js

 /*
  * Copyright (C) 2014 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 32 matching lines @@
     this._model.addEventListener(WebInspector.LayerTreeModel.Events.LayerPainted, this._onLayerPainted, this);
     this._rotatingContainerElement = this.element.createChild("div", "fill rotating-container");
     this._transformController = new WebInspector.TransformController(this.element);
     this._transformController.addEventListener(WebInspector.TransformController.Events.TransformChanged, this._onTransformChanged, this);
     this.element.addEventListener("dblclick", this._onDoubleClick.bind(this), false);
     this.element.addEventListener("click", this._onClick.bind(this), false);
     this.element.addEventListener("mouseout", this._onMouseMove.bind(this), false);
     this.element.addEventListener("mousemove", this._onMouseMove.bind(this), false);
     this.element.addEventListener("contextmenu", this._onContextMenu.bind(this), false);
     this._elementsByLayerId = {};
+    this._scrollRectElementsByLayerId = {}

[caseq, 2014/03/11 11:14:38]

unused?

[malch, 2014/03/11 11:49:08]

Done.

     this._scaleAdjustmentStylesheet = this.element.ownerDocument.head.createChild("style");
     this._scaleAdjustmentStylesheet.disabled = true;
     this._lastOutlinedElement = {};
     this._layerImage = document.createElement("img");
     this._layerImage.style.width = "100%";
     this._layerImage.style.height = "100%";
     WebInspector.settings.showPaintRects.addChangeListener(this._update, this);
 }
 
 /**
@@ skipping 12 matching lines @@
     LayerSelected: "LayerSelected",
     LayerSnapshotRequested: "LayerSnapshotRequested"
 }
 
 WebInspector.Layers3DView.PaintRectColors = [
     WebInspector.Color.fromRGBA([0, 0x5F, 0, 0x3F]),
     WebInspector.Color.fromRGBA([0, 0xAF, 0, 0x3F]),
     WebInspector.Color.fromRGBA([0, 0xFF, 0, 0x3F])
 ]
 
+/**
+ * @enum {string}
+ */
+WebInspector.Layers3DView.ScrollRectTitles = {
+    RepaintsOnScroll: WebInspector.UIString("repaints on scroll"),
+    TouchEventHandler: WebInspector.UIString("touch event listener"),
+    WheelEventHandler: WebInspector.UIString("mousewheel event listener")
+}
+
 WebInspector.Layers3DView.prototype = {
     onResize: function()
     {
         this._update();
     },
 
     willHide: function()
     {
         this._scaleAdjustmentStylesheet.disabled = true;
     },
@@ skipping 51 matching lines @@
     {
         var element = this._elementForLayer(layer);
         this._layerImage.removeAttribute("src");
         if (imageURL)
             this._layerImage.src = imageURL;
         element.appendChild(this._layerImage);
     },
 
     _scaleToFit: function()
     {
-        var root = this._model.contentRoot();
-        if (!root)
+        // var root = this._model.root();
+        // TODO: RENAME
+        var contentRoot = this._model.contentRoot();

[caseq, 2014/03/11 11:14:38]

Do we really have to rename it here?

[malch, 2014/03/11 11:49:08]

Done.

+        if (!contentRoot)
             return;
 
         const padding = 40;
-        var scaleX = this._clientWidth / (root.width() + 2 * padding);
-        var scaleY = this._clientHeight / (root.height() + 2 * padding);
+        var scaleX = this._clientWidth / (contentRoot.width() + 2 * padding);
+        var scaleY = this._clientHeight / (contentRoot.height() + 2 * padding);
         var autoScale = Math.min(scaleX, scaleY);
 
         this._scale = autoScale * this._transformController.scale();
-        this._paddingX = ((this._clientWidth / autoScale - root.width()) >> 1) * this._scale;
-        this._paddingY = ((this._clientHeight / autoScale - root.height()) >> 1) * this._scale;
+        this._paddingX = ((this._clientWidth / autoScale - contentRoot.width()) >> 1) * this._scale;
+        this._paddingY = ((this._clientHeight / autoScale - contentRoot.height()) >> 1) * this._scale;
         const screenLayerSpacing = 20;
         this._layerSpacing = screenLayerSpacing + "px";
         const screenLayerThickness = 4;
         var layerThickness = screenLayerThickness + "px";
 
         var stylesheetContent = ".layer-container .side-wall { height: " + layerThickness + "; width: " + layerThickness + "; } " +
             ".layer-container .back-wall { -webkit-transform: translateZ(-" + layerThickness + "); } " +
             ".layer-container { -webkit-transform: translateZ(" + this._layerSpacing + "); }";
         // Workaround for double style recalculation upon assignment to style sheet's text content.
         var stylesheetTextNode = this._scaleAdjustmentStylesheet.firstChild;
         if (!stylesheetTextNode || stylesheetTextNode.nodeType !== Node.TEXT_NODE || stylesheetTextNode.nextSibling)
             this._scaleAdjustmentStylesheet.textContent = stylesheetContent;
         else
             stylesheetTextNode.nodeValue = stylesheetContent;
 
-        var style = this._elementForLayer(root).style;
+        var style = this._elementForLayer(contentRoot).style;
         style.left = Math.round(this._paddingX) + "px";
         style.top = Math.round(this._paddingY) + "px";
         style.webkitTransformOrigin = "";
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _onTransformChanged: function(event)
     {
@@ skipping 14 matching lines @@
         var style = this._rotatingContainerElement.style;
         // Translate well to front so that no matter how we turn the plane, no parts of it goes below  parent.
         // This makes sure mouse events go to proper layers, not straight to the parent.
         style.webkitTransform = "translateZ(10000px)" +
             " rotateX(" + this._transformController.rotateX() + "deg) rotateY(" + this._transformController.rotateY() + "deg)" +
             " translateX(" + offsetX + "px) translateY(" + offsetY + "px)";
         // Compute where the center of shitfted and scaled root layer would be and use is as origin for rotation.
         style.webkitTransformOrigin = Math.round(this._paddingX + offsetX + root.width() * this._scale / 2) + "px " + Math.round(this._paddingY + offsetY + root.height() * this._scale / 2) + "px";
     },
 
+    /**
+     * @param {!Element} element
+     */
+    _removeElement: function(element)

[caseq, 2014/03/11 11:14:38]

looks like you can define it within the only remaining function that uses it
now.

[malch, 2014/03/11 11:49:08]

Done.

+    {
+        element.remove()
+    },
+
+    /**
+     * @param {!WebInspector.Layer} layer
+     * @param {!LayerTreeAgent.ScrollRect} scrollRect
+     * @return {!Element}
+     */
+    _createScrollRectElement: function(layer, scrollRect)
+    {
+        var element = document.createElement("div");
+        var style = element.style;

[caseq, 2014/03/11 11:14:38]

unused?

[malch, 2014/03/11 11:49:08]

Done.

+        var parentLayerId = layer.id();

[caseq, 2014/03/11 11:14:38]

inline

[malch, 2014/03/11 11:49:08]

Done.

+        var parentLayerElement = this._elementsByLayerId[parentLayerId];
+        element.className = "scroll-rect";
+        element.title = WebInspector.Layers3DView.ScrollRectTitles[scrollRect.type];
+        parentLayerElement.appendChild(element);
+        return element;
+    },
+
+    /**
+     * @param {!Array.<!Element>} elements
+     * @param {!LayerTreeAgent.ScrollRect} scrollRect
+     * @param {!number} index
+     */
+    _updateScrollRectElement: function(elements, scrollRect, index)
+    {
+        var element = elements[index];
+        var style = element.style;
+        style.width = Math.round(scrollRect.rect.width * this._scale) + "px";
+        style.height = Math.round(scrollRect.rect.height * this._scale) + "px";
+        style.left = Math.round(scrollRect.rect.x * this._scale) + "px";
+        style.top = Math.round(scrollRect.rect.y * this._scale) + "px";
+    },
+
+    /**
+     * @param {!WebInspector.Layer} layer
+     */
+     _updateScrollRectsForLayer: function(layer)
+     {
+        var newScrollRects = layer.scrollRects(),
+            layerDetails = this._elementsByLayerId[layer.id()].__layerDetails;
+        if (newScrollRects != layerDetails.scrollRects) {

[caseq, 2014/03/11 11:14:38]

We use !==

[malch, 2014/03/11 11:49:08]

Done.

+            layerDetails.scrollRectElements.forEach(this._removeElement);
+            layerDetails.scrollRects = newScrollRects;
+            layerDetails.scrollRectElements = layerDetails.scrollRects.map(this._createScrollRectElement.bind(this, layer));
+        }
+        layerDetails.scrollRects.forEach(this._updateScrollRectElement.bind(this, layerDetails.scrollRectElements));
+    },
+
     _update: function()
     {
         if (!this.isShowing()) {
             this._needsUpdate = true;
             return;
         }
         if (!this._model.contentRoot()) {
             this._emptyView.show(this.element);
             this._rotatingContainerElement.removeChildren();
             return;
@@ skipping 10 matching lines @@
         this._clientWidth = this.element.clientWidth;
         this._clientHeight = this.element.clientHeight;
         for (var layerId in this._elementsByLayerId) {
             if (this._model.layerById(layerId))
                 continue;
             this._elementsByLayerId[layerId].remove();
             delete this._elementsByLayerId[layerId];
         }
         this._scaleToFit();
         this._updateTransform();
-        this._model.forEachLayer(updateLayer.bind(this), this._model.contentRoot());
+        this._model.forEachLayer(updateLayer.bind(this));
+        this._model.forEachLayer(this._updateScrollRectsForLayer.bind(this));
         this._needsUpdate = false;
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _onLayerPainted: function(event)
     {
         var layer = /** @type {!WebInspector.Layer} */ (event.data);
-        this._updatePaintRect(this._elementForLayer(layer));
+        if (layer.nodeId())
+            this._updatePaintRect(this._elementForLayer(layer));
     },
 
     /**
      * @param {!WebInspector.Layer} layer
      * @return {!Element}
      */
     _elementForLayer: function(layer)
     {
         var element = this._elementsByLayerId[layer.id()];
         if (element) {
             // We might have missed an update were a layer with given id was gone and re-created,
             // so update reference to point to proper layer object.
             element.__layerDetails.layer = layer;
             return element;
         }
         element = document.createElement("div");
-        element.className = "layer-container";
-        ["fill back-wall", "side-wall top", "side-wall right", "side-wall bottom", "side-wall left"].forEach(element.createChild.bind(element, "div"));
-        element.__layerDetails = new WebInspector.LayerDetails(layer, element.createChild("div", "paint-rect"));
+        if (layer.nodeId()) {
+            element.className = "layer-container";
+            ["fill back-wall", "side-wall top", "side-wall right", "side-wall bottom", "side-wall left"].forEach(element.createChild.bind(element, "div"));
+            element.__layerDetails = new WebInspector.LayerDetails(layer, element.createChild("div", "paint-rect"));
+        } else {
+            element.className = "layer-transparent";
+            element.__layerDetails = new WebInspector.LayerDetails(layer);
+        }
         this._elementsByLayerId[layer.id()] = element;
         return element;
     },
 
     /**
      * @param {!Element} element
      */
     _updateLayerElement: function(element)
     {
         var layer = element.__layerDetails.layer;
         var style = element.style;
-        var isContentRoot = layer === this._model.contentRoot();
-        var parentElement = isContentRoot ? this._rotatingContainerElement : this._elementForLayer(layer.parent());
+
+        var contentRoot = /** @type {!WebInspector.Layer} */ (this._model.contentRoot());
+        var isContentRoot = layer === contentRoot;
+        var isRoot = layer === this._model.root();
+        var parentElement = isContentRoot ? this._rotatingContainerElement : (isRoot ? this._elementForLayer(contentRoot) : this._elementForLayer(layer.parent()));
         element.__layerDetails.depth = parentElement.__layerDetails ? parentElement.__layerDetails.depth + 1 : 0;
         element.classList.toggle("invisible", layer.invisible());
-        this._updateElementColor(element);
+        if (layer.nodeId())
+            this._updateElementColor(element);
         if (parentElement !== element.parentElement)
             parentElement.appendChild(element);
 
         style.width = Math.round(layer.width() * this._scale) + "px";
         style.height = Math.round(layer.height() * this._scale) + "px";
-        this._updatePaintRect(element);
-        if (isContentRoot)
+        if (layer.nodeId())
+            this._updatePaintRect(element);
+        if (isContentRoot || isRoot)
             return;
         style.left = Math.round(layer.offsetX() * this._scale) + "px";
         style.top = Math.round(layer.offsetY() * this._scale) + "px";
         var transform = layer.transform();
         if (transform) {
             transform = transform.slice();
             // Adjust offset in the transform matrix according to scale.
             for (var i = 12; i < 15; ++i)
                 transform[i] *= this._scale;
             // Avoid exponential notation in CSS.
             style.webkitTransform = "matrix3d(" + transform.map(toFixed5).join(",") + ") translateZ(" + this._layerSpacing + ")";
             var anchor = layer.anchorPoint();
             style.webkitTransformOrigin = Math.round(anchor[0] * 100) + "% " + Math.round(anchor[1] * 100) + "% " + anchor[2];
         } else {
             style.webkitTransform = "";
             style.webkitTransformOrigin = "";
         }
 
         function toFixed5(x)
         {
             return x.toFixed(5);
         }
     },
 
+    /**
+     * @param {!Element} element
+     */
     _updatePaintRect: function(element)
     {
         var details = element.__layerDetails;
         var paintRect = details.layer.lastPaintRect();
         var paintRectElement = details.paintRectElement;
         if (!paintRect || !WebInspector.settings.showPaintRects.get()) {
             paintRectElement.classList.add("hidden");
             return;
         }
         paintRectElement.classList.remove("hidden");
@@ skipping 84 matching lines @@
             this.dispatchEventToListeners(WebInspector.Layers3DView.Events.LayerSnapshotRequested, layer);
         event.stopPropagation();
     },
 
     __proto__: WebInspector.View.prototype
 }
 
 /**
  * @constructor
  * @param {!WebInspector.Layer} layer
- * @param {!Element} paintRectElement
+ * @param {!Element=} paintRectElement
  */
 WebInspector.LayerDetails = function(layer, paintRectElement)
 {
     this.layer = layer;
     this.depth = 0;
-    this.paintRectElement = paintRectElement;
+    if (paintRectElement)

[caseq, 2014/03/11 11:14:38]

I think you can omit this check.

[malch, 2014/03/11 11:49:08]

Done.

+        this.paintRectElement = paintRectElement;
     this.paintCount = 0;
+    this.scrollRects = [];
+    this.scrollRectElements = [];
 }