Added showing slow scroll rectangles in Layers panel.

Source/core/inspector/InspectorLayerTreeAgent.cpp

 /*
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  * 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.
@@ skipping 55 matching lines @@
     }
     int layerId;
     RefPtr<GraphicsContextSnapshot> graphicsSnapshot;
 };
 
 inline String idForLayer(const GraphicsLayer* graphicsLayer)
 {
     return String::number(graphicsLayer->platformLayer()->id());
 }
 
+static void buildRegionObjects(const blink::WebVector<blink::WebRect>& regions,
+    TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect>& scrollRects,
+    const TypeBuilder::LayerTree::ScrollRect::Type::Enum& type,
+    const TypeBuilder::LayerTree::LayerId& layerId)
+{
+    for (size_t i = 0; i < regions.size(); ++i) {
+        RefPtr<TypeBuilder::DOM::Rect> rectObject = TypeBuilder::DOM::Rect::create()
+            .setX(regions[i].x)
+            .setY(regions[i].y)
+            .setHeight(regions[i].height)
+            .setWidth(regions[i].width);
+        RefPtr<TypeBuilder::LayerTree::ScrollRect> regionObject = TypeBuilder::LayerTree::ScrollRect::create()
+            .setRect(rectObject)
+            .setType(type);
+        scrollRects.addItem(regionObject);
+    }
+}
+
+static PassRefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect> > buildScrollRectsForLayer(GraphicsLayer* graphicsLayer)
+{
+    RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect> > scrollRects = TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect>::create();
+    blink::WebLayer* webLayer = graphicsLayer->platformLayer();
+    buildRegionObjects(webLayer->nonFastScrollableRegion(), *scrollRects, TypeBuilder::LayerTree::ScrollRect::Type::RepaintsOnScroll, idForLayer(graphicsLayer));
+    buildRegionObjects(webLayer->touchEventHandlerRegion(), *scrollRects, TypeBuilder::LayerTree::ScrollRect::Type::TouchEventHandler, idForLayer(graphicsLayer));
+    if (webLayer->haveWheelEventHandlers()) {
+        RefPtr<TypeBuilder::DOM::Rect> rectObject = TypeBuilder::DOM::Rect::create()
+            .setX(webLayer->position().x)
+            .setY(webLayer->position().y)
+            .setHeight(webLayer->bounds().height)
+            .setWidth(webLayer->bounds().width);
+        RefPtr<TypeBuilder::LayerTree::ScrollRect> regionObject = TypeBuilder::LayerTree::ScrollRect::create()
+            .setRect(rectObject)
+            .setType(TypeBuilder::LayerTree::ScrollRect::Type::WheelEventHandler);
+        scrollRects->addItem(regionObject);
+    }
+    return scrollRects->length() ? scrollRects : nullptr;
+}
+
 static PassRefPtr<TypeBuilder::LayerTree::Layer> buildObjectForLayer(GraphicsLayer* graphicsLayer, int nodeId)
 {
     blink::WebLayer* webLayer = graphicsLayer->platformLayer();
     RefPtr<TypeBuilder::LayerTree::Layer> layerObject = TypeBuilder::LayerTree::Layer::create()
         .setLayerId(idForLayer(graphicsLayer))
         .setOffsetX(webLayer->position().x)
         .setOffsetY(webLayer->position().y)
         .setWidth(webLayer->bounds().width)
         .setHeight(webLayer->bounds().height)
         .setPaintCount(graphicsLayer->paintCount());
@@ skipping 14 matching lines @@
         transform.toColumnMajorFloatArray(flattenedMatrix);
         RefPtr<TypeBuilder::Array<double> > transformArray = TypeBuilder::Array<double>::create();
         for (size_t i = 0; i < WTF_ARRAY_LENGTH(flattenedMatrix); ++i)
             transformArray->addItem(flattenedMatrix[i]);
         layerObject->setTransform(transformArray);
         const FloatPoint3D& anchor = graphicsLayer->anchorPoint();
         layerObject->setAnchorX(anchor.x());
         layerObject->setAnchorY(anchor.y());
         layerObject->setAnchorZ(anchor.z());
     }
+    RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::ScrollRect> > scrollRects =
+        buildScrollRectsForLayer(graphicsLayer);
+    if (scrollRects)
+        layerObject->setScrollRects(buildScrollRectsForLayer(graphicsLayer));
     return layerObject;
 }
 
 InspectorLayerTreeAgent::InspectorLayerTreeAgent(InspectorDOMAgent* domAgent, Page* page)
     : InspectorBaseAgent<InspectorLayerTreeAgent>("LayerTree")
     , m_frontend(0)
     , m_page(page)
     , m_domAgent(domAgent)
 {
 }
@@ skipping 27 matching lines @@
 }
 
 void InspectorLayerTreeAgent::disable(ErrorString*)
 {
     m_instrumentingAgents->setInspectorLayerTreeAgent(0);
     m_snapshotById.clear();
 }
 
 void InspectorLayerTreeAgent::layerTreeDidChange()
 {
-    m_frontend->layerTreeDidChange(buildLayerTree());
+    RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::Layer> > layers = TypeBuilder::Array<TypeBuilder::LayerTree::Layer>::create();
+    if (buildLayerTree(*layers))
+        m_frontend->layerTreeDidChange(layers);
+    else
+        m_frontend->layerTreeDidChange(nullptr);
 }
 
 void InspectorLayerTreeAgent::didPaint(RenderObject*, const GraphicsLayer* graphicsLayer, GraphicsContext*, const LayoutRect& rect)
 {
     // Should only happen for FrameView paints when compositing is off. Consider different instrumentation method for that.
     if (!graphicsLayer)
         return;
 
     RefPtr<TypeBuilder::DOM::Rect> domRect = TypeBuilder::DOM::Rect::create()
         .setX(rect.x())
         .setY(rect.y())
         .setWidth(rect.width())
         .setHeight(rect.height());
     m_frontend->layerPainted(idForLayer(graphicsLayer), domRect.release());
 }
 
-PassRefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::Layer> > InspectorLayerTreeAgent::buildLayerTree()
+bool InspectorLayerTreeAgent::buildLayerTree(TypeBuilder::Array<TypeBuilder::LayerTree::Layer>& layers)
 {
     RenderLayerCompositor* compositor = renderLayerCompositor();
     if (!compositor || !compositor->inCompositingMode())
-        return nullptr;
+        return false;
     LayerIdToNodeIdMap layerIdToNodeIdMap;
-    RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::Layer> > layers = TypeBuilder::Array<TypeBuilder::LayerTree::Layer>::create();
     buildLayerIdToNodeIdMap(compositor->rootRenderLayer(), layerIdToNodeIdMap);
     gatherGraphicsLayers(compositor->rootGraphicsLayer(), layerIdToNodeIdMap, layers);
-    return layers.release();
+    return true;
 }
 
 void InspectorLayerTreeAgent::buildLayerIdToNodeIdMap(RenderLayer* root, LayerIdToNodeIdMap& layerIdToNodeIdMap)
 {
     if (root->hasCompositedLayerMapping()) {
         if (Node* node = root->renderer()->generatingNode()) {
             GraphicsLayer* graphicsLayer = root->compositedLayerMapping()->childForSuperlayers();
             layerIdToNodeIdMap.set(graphicsLayer->platformLayer()->id(), idForNode(node));
         }
     }
     for (RenderLayer* child = root->firstChild(); child; child = child->nextSibling())
         buildLayerIdToNodeIdMap(child, layerIdToNodeIdMap);
     if (!root->renderer()->isRenderIFrame())
         return;
     FrameView* childFrameView = toFrameView(toRenderWidget(root->renderer())->widget());
     if (RenderView* childRenderView = childFrameView->renderView()) {
         if (RenderLayerCompositor* childCompositor = childRenderView->compositor())
             buildLayerIdToNodeIdMap(childCompositor->rootRenderLayer(), layerIdToNodeIdMap);
     }
 }
 
-void InspectorLayerTreeAgent::gatherGraphicsLayers(GraphicsLayer* root, HashMap<int, int>& layerIdToNodeIdMap, RefPtr<TypeBuilder::Array<TypeBuilder::LayerTree::Layer> >& layers)
+void InspectorLayerTreeAgent::gatherGraphicsLayers(GraphicsLayer* root, HashMap<int, int>& layerIdToNodeIdMap,
+    TypeBuilder::Array<TypeBuilder::LayerTree::Layer>& layers)
 {
     int layerId = root->platformLayer()->id();
     if (m_pageOverlayLayerIds.find(layerId) != WTF::kNotFound)
         return;
-    layers->addItem(buildObjectForLayer(root, layerIdToNodeIdMap.get(layerId)));
+    layers.addItem(buildObjectForLayer(root, layerIdToNodeIdMap.get(layerId)));
     if (GraphicsLayer* replica = root->replicaLayer())
         gatherGraphicsLayers(replica, layerIdToNodeIdMap, layers);
     for (size_t i = 0, size = root->children().size(); i < size; ++i)
         gatherGraphicsLayers(root->children()[i], layerIdToNodeIdMap, layers);
 }
 
 int InspectorLayerTreeAgent::idForNode(Node* node)
 {
     int nodeId = m_domAgent->boundNodeId(node);
     if (!nodeId) {
@@ skipping 132 matching lines @@
 void InspectorLayerTreeAgent::didRemovePageOverlay(const GraphicsLayer* layer)
 {
     size_t index = m_pageOverlayLayerIds.find(layer->platformLayer()->id());
     if (index == WTF::kNotFound)
         return;
     m_pageOverlayLayerIds.remove(index);
 }
 
 
 } // namespace WebCore