WIP: Construct SPV2's scroll paint property tree

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 132 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 27 matching lines @@
         , m_isFirstEffectEver(true)
 #endif
     {
         m_effectStack.append(BlinkEffectAndCcIdPair{nullptr, kSecondaryRootNodeId});
     }
 
     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*);
+    bool compositorIdExistsForScrollNode(const ScrollPaintPropertyNode* scrollNode)
+    {
+        return m_scrollNodeMap.contains(scrollNode);
+    }
+
+    // Scroll offset has special treatment in the compositor and needs an
+    // adjustment to the transform node (to switch from a transform to a scroll
+    // offset) as well as an update to the ScrollTree scroll offset.
+    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 71 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;
+
+    // TODO(pdr): Set scrollable properly.
+    compositorNode.scrollable = true;
+
+    // TODO(pdr): Set main thread scrolling reasons.
+    IntSize snappedClip = roundedIntSize(scrollNode->clip());
+    compositorNode.scroll_clip_layer_bounds.SetSize(snappedClip.width(), snappedClip.height());
+    IntSize snappedBounds = roundedIntSize(scrollNode->bounds());
+    compositorNode.scroll_clip_layer_bounds.SetSize(snappedBounds.width(), snappedBounds.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);
+
+    // The transform associated with a scroll should only contain a 2d scroll offset.
+    DCHECK(transformNode.local.IsIdentityOr2DTranslation());
+
+    // TODO(pdr): Set the transform node's scrollable bit from scrollNode.
+
+    auto scrollOffsetVector = transformNode.local.To2dTranslation();
+
+    // Remove the 2d scroll translation set from blink's transform paint property
+    // node.
+    transformNode.local.MakeIdentity();
+
+    gfx::ScrollOffset scrollOffset(scrollOffsetVector.x(), -scrollOffsetVector.y());
+    scrollTree().SetScrollOffset(layerId, scrollOffset);
+
+    // TODO(pdr): Is this needed or can we rely on SetScrollOffset handling it?
+    transformNode.scroll_offset = scrollOffset;
+}
+
 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 96 matching lines @@
     m_rootLayer->SetScrollTreeIndex(kRealRootNodeId);
 
     PropertyTreeManager propertyTreeManager(*host->GetLayerTree()->property_trees(), m_rootLayer.get());
     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