Construct cc scroll tree from blink [spv2]

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.cpp

 // Copyright 2015 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.
 
 #include "platform/graphics/compositing/PaintArtifactCompositor.h"
 
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/playback/display_item_list.h"
 #include "cc/playback/display_item_list_settings.h"
 #include "cc/playback/drawing_display_item.h"
 #include "cc/playback/transform_display_item.h"
 #include "cc/trees/clip_node.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/property_tree.h"
+#include "cc/trees/scroll_node.h"
 #include "cc/trees/transform_node.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 #include "platform/graphics/paint/ForeignLayerDisplayItem.h"
 #include "platform/graphics/paint/PaintArtifact.h"
 #include "platform/graphics/paint/PropertyTreeState.h"
+#include "platform/graphics/paint/ScrollPaintPropertyNode.h"
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebLayer.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/geometry/size_conversions.h"
@@ skipping 97 matching lines @@
         return nullptr;
 
     const auto& foreignLayerDisplayItem = static_cast<const ForeignLayerDisplayItem&>(displayItem);
     layerOffset = gfx::Vector2dF(foreignLayerDisplayItem.location().x(), foreignLayerDisplayItem.location().y());
     scoped_refptr<cc::Layer> layer = foreignLayerDisplayItem.layer();
     layer->SetBounds(foreignLayerDisplayItem.bounds());
     layer->SetIsDrawable(true);
     return layer;
 }
 
-
+// cc's property trees use 0 for the root node (always non-null).
 constexpr int kRealRootNodeId = 0;
+// cc allocates special nodes for root effects such as the device scale.
 constexpr int kSecondaryRootNodeId = 1;
 constexpr int kPropertyTreeSequenceNumber = 1;
 
 // Creates a minimal set of property trees for the compositor.
 void setMinimalPropertyTrees(cc::PropertyTrees* propertyTrees, int ownerId)
 {
     // cc is hardcoded to use transform node index 1 for device scale and transform.
     cc::TransformTree& transformTree = propertyTrees->transform_tree;
     transformTree.clear();
     cc::TransformNode& transformNode = *transformTree.Node(transformTree.Insert(cc::TransformNode(), kRealRootNodeId));
@@ skipping 13 matching lines @@
     cc::EffectTree& effectTree = propertyTrees->effect_tree;
     effectTree.clear();
     cc::EffectNode& effectNode = *effectTree.Node(effectTree.Insert(cc::EffectNode(), kRealRootNodeId));
     DCHECK_EQ(effectNode.id, kSecondaryRootNodeId);
     effectNode.owner_id = ownerId;
     effectNode.clip_id = clipNode.id;
     effectNode.has_render_surface = true;
 
     cc::ScrollTree& scrollTree = propertyTrees->scroll_tree;
     scrollTree.clear();
+    cc::ScrollNode& scrollNode = *scrollTree.Node(scrollTree.Insert(cc::ScrollNode(), kRealRootNodeId));
+    DCHECK_EQ(scrollNode.id, kSecondaryRootNodeId);
+    scrollNode.owner_id = ownerId;
+    scrollNode.transform_id = kRealRootNodeId;
 }
 
 } // namespace
 
 scoped_refptr<cc::Layer> PaintArtifactCompositor::layerForPaintChunk(const PaintArtifact& paintArtifact, const PaintChunk& paintChunk, gfx::Vector2dF& layerOffset)
 {
     DCHECK(paintChunk.size());
 
     // If the paint chunk is a foreign layer, just return that layer.
     if (scoped_refptr<cc::Layer> foreignLayer = foreignLayerForPaintChunk(paintArtifact, paintChunk, layerOffset))
@@ skipping 30 matching lines @@
         m_effectStack.append(BlinkEffectAndCcIdPair{nullptr, kSecondaryRootNodeId});
     }
 
     // TODO(pdr): This will need to be unified with how viewport scale works.
     void setDeviceScaleFactor(float);
 
     int compositorIdForTransformNode(const TransformPaintPropertyNode*);
     int compositorIdForClipNode(const ClipPaintPropertyNode*);
     int switchToEffectNode(const EffectPaintPropertyNode& nextEffect);
     int compositorIdForCurrentEffectNode() const { return m_effectStack.last().id; }
+    int compositorIdForScrollNode(const ScrollPaintPropertyNode*);
+
+    // Scroll offset has special treatment in the transform and scroll trees.
+    void updateScrollOffset(int layerId, int scrollId);
 
 private:
     void buildEffectNodesRecursively(const EffectPaintPropertyNode* nextEffect);
 
     cc::TransformTree& transformTree() { return m_propertyTrees.transform_tree; }
     cc::ClipTree& clipTree() { return m_propertyTrees.clip_tree; }
     cc::EffectTree& effectTree() { return m_propertyTrees.effect_tree; }
+    cc::ScrollTree& scrollTree() { return m_propertyTrees.scroll_tree; }
 
     const EffectPaintPropertyNode* currentEffectNode() const { return m_effectStack.last().effect; }
 
     // Property trees which should be updated by the manager.
     cc::PropertyTrees& m_propertyTrees;
 
     // Layer to which transform "owner" layers should be added. These will not
     // have any actual children, but at present must exist in the tree.
     cc::Layer* m_rootLayer;
 
     // Maps from Blink-side property tree nodes to cc property node indices.
     HashMap<const TransformPaintPropertyNode*, int> m_transformNodeMap;
     HashMap<const ClipPaintPropertyNode*, int> m_clipNodeMap;
+    HashMap<const ScrollPaintPropertyNode*, int> m_scrollNodeMap;
 
     struct BlinkEffectAndCcIdPair {
         const EffectPaintPropertyNode* effect;
         int id;
     };
     Vector<BlinkEffectAndCcIdPair> m_effectStack;
 
 #if DCHECK_IS_ON()
     HashSet<const EffectPaintPropertyNode*> m_effectNodesConverted;
     bool m_isFirstEffectEver;
@@ skipping 77 matching lines @@
     dummyLayer->SetEffectTreeIndex(kSecondaryRootNodeId);
     dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
     dummyLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
 
     auto result = m_clipNodeMap.set(clipNode, id);
     DCHECK(result.isNewEntry);
     clipTree().set_needs_update(true);
     return id;
 }
 
+int PropertyTreeManager::compositorIdForScrollNode(const ScrollPaintPropertyNode* scrollNode)
+{
+    if (!scrollNode)
+        return kSecondaryRootNodeId;
+
+    auto it = m_scrollNodeMap.find(scrollNode);
+    if (it != m_scrollNodeMap.end())
+        return it->value;
+
+    int parentId = compositorIdForScrollNode(scrollNode->parent());
+    int id = scrollTree().Insert(cc::ScrollNode(), parentId);
+
+    cc::ScrollNode& compositorNode = *scrollTree().Node(id);
+    compositorNode.owner_id = parentId;
+
+    compositorNode.scrollable = true;
+
+    // TODO(pdr): Set main thread scrolling reasons.
+    compositorNode.scroll_clip_layer_bounds.SetSize(scrollNode->clip().width(), scrollNode->clip().height());
+    compositorNode.bounds.SetSize(scrollNode->bounds().width(), scrollNode->bounds().height());
+    compositorNode.user_scrollable_horizontal = scrollNode->userScrollableHorizontal();
+    compositorNode.user_scrollable_vertical = scrollNode->userScrollableVertical();
+    compositorNode.transform_id = compositorIdForTransformNode(scrollNode->scrollOffsetTranslation());
+
+    auto result = m_scrollNodeMap.set(scrollNode, id);
+    DCHECK(result.isNewEntry);
+    scrollTree().set_needs_update(true);
+
+    return id;
+}
+
+void PropertyTreeManager::updateScrollOffset(int layerId, int scrollId)
+{
+    cc::ScrollNode& scrollNode = *scrollTree().Node(scrollId);
+    cc::TransformNode& transformNode = *transformTree().Node(scrollNode.transform_id);
+
+    transformNode.scrolls = true;
+
+    // Blink creates a 2d transform node just for scroll offset whereas cc's
+    // transform node has a special scroll offset field. To handle this we
+    // adjust cc's transform node to remove the 2d scroll translation and
+    // let the cc scroll tree update the cc scroll offset.
+    DCHECK(transformNode.local.IsIdentityOr2DTranslation());
+    auto offset = transformNode.local.To2dTranslation();
+    transformNode.local.MakeIdentity();
+    scrollTree().SetScrollOffset(layerId, gfx::ScrollOffset(-offset.x(), -offset.y()));
+    scrollTree().set_needs_update(true);
+}
+
 unsigned depth(const EffectPaintPropertyNode* node)
 {
     unsigned result = 0;
     for (; node; node = node->parent())
         result++;
     return result;
 }
 
 const EffectPaintPropertyNode* lowestCommonAncestor(const EffectPaintPropertyNode* nodeA, const EffectPaintPropertyNode* nodeB)
 {
@@ skipping 99 matching lines @@
     PropertyTreeManager propertyTreeManager(*host->GetLayerTree()->property_trees(), m_rootLayer.get());
     propertyTreeManager.setDeviceScaleFactor(host->GetLayerTree()->device_scale_factor());
 
     m_contentLayerClients.clear();
     m_contentLayerClients.reserveCapacity(paintArtifact.paintChunks().size());
     for (const PaintChunk& paintChunk : paintArtifact.paintChunks()) {
         gfx::Vector2dF layerOffset;
         scoped_refptr<cc::Layer> layer = layerForPaintChunk(paintArtifact, paintChunk, layerOffset);
 
         int transformId = propertyTreeManager.compositorIdForTransformNode(paintChunk.properties.transform.get());
+        int scrollId = propertyTreeManager.compositorIdForScrollNode(paintChunk.properties.scroll.get());
         int clipId = propertyTreeManager.compositorIdForClipNode(paintChunk.properties.clip.get());
         int effectId = propertyTreeManager.switchToEffectNode(*paintChunk.properties.effect.get());
 
+        propertyTreeManager.updateScrollOffset(layer->id(), scrollId);
+
         layer->set_offset_to_transform_parent(layerOffset);
 
         m_rootLayer->AddChild(layer);
         layer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
         layer->SetTransformTreeIndex(transformId);
         layer->SetClipTreeIndex(clipId);
         layer->SetEffectTreeIndex(effectId);
-        layer->SetScrollTreeIndex(kRealRootNodeId);
+        layer->SetScrollTreeIndex(scrollId);
 
         // TODO(jbroman): This probably shouldn't be necessary, but it is still
         // queried by RenderSurfaceImpl.
         layer->Set3dSortingContextId(host->GetLayerTree()->property_trees()->transform_tree.Node(transformId)->sorting_context_id);
 
         layer->SetShouldCheckBackfaceVisibility(paintChunk.properties.backfaceHidden);
 
         if (m_extraDataForTestingEnabled)
             m_extraDataForTesting->contentLayers.append(layer);
     }
 
     // Mark the property trees as having been rebuilt.
     host->GetLayerTree()->property_trees()->sequence_number = kPropertyTreeSequenceNumber;
     host->GetLayerTree()->property_trees()->needs_rebuild = false;
 }
 
 } // namespace blink