Set layer scroll data from PaintArtifactCompositor

third_party/WebKit/Source/platform/graphics/compositing/PropertyTreeManager.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/PropertyTreeManager.h"
 
 #include "cc/layers/layer.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/graphics/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/EffectPaintPropertyNode.h"
 #include "platform/graphics/paint/GeometryMapper.h"
 #include "platform/graphics/paint/ScrollPaintPropertyNode.h"
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
+#include "public/platform/WebLayerScrollClient.h"
 
 namespace blink {
 
 namespace {
 
 static constexpr int kInvalidNodeId = -1;
 // cc's property trees use 0 for the root node (always non-null).
 static constexpr int kRealRootNodeId = 0;
 // cc allocates special nodes for root effects such as the device scale.
 static constexpr int kSecondaryRootNodeId = 1;
@@ skipping 228 matching lines @@
     return kSecondaryRootNodeId;
 
   auto it = m_scrollNodeMap.find(scrollNode);
   if (it != m_scrollNodeMap.end())
     return it->value;
 
   int parentId = ensureCompositorScrollNode(scrollNode->parent());
   int id = scrollTree().Insert(cc::ScrollNode(), parentId);
 
   cc::ScrollNode& compositorNode = *scrollTree().Node(id);
-  // TODO(wkorman): Fix owning layer id to reference a layer id rather than a
-  // scroll node index.
-  compositorNode.owning_layer_id = parentId;
-  m_propertyTrees
-      .layer_id_to_scroll_node_index[compositorNode.owning_layer_id] = id;
-
   compositorNode.scrollable = true;
 
   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();
@@ skipping 29 matching lines @@
   // cc's transform node to remove the 2d scroll translation and instead set the
   // scroll_offset field.
   auto scrollOffsetSize = scrollOffsetNode->matrix().to2DTranslation();
   auto scrollOffset =
       gfx::ScrollOffset(-scrollOffsetSize.width(), -scrollOffsetSize.height());
   DCHECK(compositorTransformNode.local.IsIdentityOr2DTranslation());
   compositorTransformNode.scroll_offset = scrollOffset;
   compositorTransformNode.local.MakeIdentity();
   compositorTransformNode.scrolls = true;
   transformTree().set_needs_update(true);
-  // TODO(pdr): The scroll tree's scroll offset will need to be set here.
+  // TODO(pdr): Because of a layer dependancy, the scroll tree scroll offset is
+  // set in updateLayerScrollMapping but that should occur here.
+}
+
+void PropertyTreeManager::updateLayerScrollMapping(
+    cc::Layer* layer,
+    const TransformPaintPropertyNode* transform) {
+  auto* enclosingScrollNode = transform->findEnclosingScrollNode();
+  int scrollNodeId = ensureCompositorScrollNode(enclosingScrollNode);
+  layer->SetScrollTreeIndex(scrollNodeId);
+  int layerId = layer->id();
+  m_propertyTrees.layer_id_to_scroll_node_index[layerId] = scrollNodeId;
+
+  if (!transform->isScrollTranslation())
+    return;
+
+  auto& compositorScrollNode = *scrollTree().Node(scrollNodeId);
+
+  // TODO(pdr): Remove the scroll node's owning_layer_id. This approach of
+  // setting owning_layer_id only when it is not set lets us maintain a 1:1
+  // mapping from layer to scroll node.
+  if (compositorScrollNode.owning_layer_id == cc::Layer::INVALID_ID) {
+    compositorScrollNode.owning_layer_id = layerId;
+    auto& compositorTransformNode =
+        *transformTree().Node(compositorScrollNode.transform_id);
+    // TODO(pdr): Set this in updateScrollAndScrollTranslationNodes once the
+    // layer id is no longer needed.
+    scrollTree().SetScrollOffset(layerId,
+                                 compositorTransformNode.scroll_offset);
+    if (auto* scrollClient = enclosingScrollNode->scrollClient()) {
+      layer->set_did_scroll_callback(
+          base::Bind(&blink::WebLayerScrollClient::didScroll,
+                     base::Unretained(scrollClient)));
+    }
+  }
 }
 
 int PropertyTreeManager::switchToEffectNode(
     const EffectPaintPropertyNode& nextEffect) {
   const EffectPaintPropertyNode* ancestor =
       GeometryMapper::lowestCommonAncestor(currentEffectNode(), &nextEffect);
   DCHECK(ancestor) << "Malformed effect tree. All nodes must be descendant of "
                       "EffectPaintPropertyNode::root().";
   while (currentEffectNode() != ancestor)
     m_effectStack.pop_back();
@@ skipping 79 matching lines @@
   m_effectStack.push_back(BlinkEffectAndCcIdPair{nextEffect, effectNode.id});
 
   dummyLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
   dummyLayer->SetTransformTreeIndex(kSecondaryRootNodeId);
   dummyLayer->SetClipTreeIndex(outputClipId);
   dummyLayer->SetEffectTreeIndex(effectNode.id);
   dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
 }
 
 }  // namespace blink