Refactor IsScrolledBy and IsClosestScrollAncestor to use ScrollNode ids

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 136 matching lines @@
   bool scroll_on_main_thread = (scroll_thread == MAIN_THREAD);
   if (IsWheelBasedScroll(type)) {
     UMA_HISTOGRAM_BOOLEAN("Renderer4.CompositorWheelScrollUpdateThread",
                           scroll_on_main_thread);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Renderer4.CompositorTouchScrollUpdateThread",
                           scroll_on_main_thread);
   }
 }
 
-// Return true if scrollable 'ancestor' is the same layer as 'child' or its
+// Return true if scrollable node for 'ancestor' is the same as 'child' or an
 // ancestor along the scroll tree.
 bool IsScrolledBy(LayerImpl* child, LayerImpl* ancestor) {
   DCHECK(ancestor && ancestor->scrollable());
   if (!child)
     return false;
 
-  ScrollTree& scroll_tree =
-      child->layer_tree_impl()->property_trees()->scroll_tree;
+  auto* property_trees = child->layer_tree_impl()->property_trees();
+  auto ancestor_scroll_id =
+      property_trees->layer_id_to_scroll_node_index.find(ancestor->id());

[ajuma, 2017/02/23 14:19:00]

Is the idea that for SPv2, we'd potentially have multiple layer ids mapped to
the same scroll node index?

[pdr., 2017/02/23 19:19:18]

Yeah, here's my mental model of a usecase and how it would work:

Imagine we have a scrollable area that paints 3 horizontal sections of content
with a total area of 6*3:
+------+-+
|AAAAAA|^|
|BBBBBB| |
|AAAAAA|v|
+------+-+

In SPV1, we would always create a layer for the AAAAAA content of at least size
6*3, and this layer would own the scroll node. If the user specifies will-change
on the BBBBBB, a child layer may be created of size 6*1.

In SPV2, we want to be able to create 3 non-overlapping layers for the
will-change:B case: A1, B, and A2, each of size 6*1. Each of these layers would
be in the layer_id_to_scroll_node_index map, sort of as if they collectively
"own" the scroll node.

+  if (ancestor_scroll_id == property_trees->layer_id_to_scroll_node_index.end())
+    return false;
+
+  ScrollTree& scroll_tree = property_trees->scroll_tree;
   for (ScrollNode* scroll_node = scroll_tree.Node(child->scroll_tree_index());
        scroll_node; scroll_node = scroll_tree.parent(scroll_node)) {
-    if (scroll_node->owning_layer_id == ancestor->id())
+    if (scroll_node->id == ancestor_scroll_id->second)
       return true;
   }
   return false;
 }
 
 }  // namespace
 
 DEFINE_SCOPED_UMA_HISTOGRAM_TIMER(PendingTreeDurationHistogramTimer,
                                   "Scheduling.%s.PendingTreeDuration");
 
@@ skipping 2442 matching lines @@
   if (!impl_scroll_node)
     return nullptr;
   return active_tree_->LayerById(impl_scroll_node->owning_layer_id);
 }
 
 static bool IsClosestScrollAncestor(LayerImpl* child,
                                     LayerImpl* scroll_ancestor) {
   DCHECK(scroll_ancestor);
   if (!child)
     return false;
-  ScrollTree& scroll_tree =
-      child->layer_tree_impl()->property_trees()->scroll_tree;
+
+  auto* property_trees = child->layer_tree_impl()->property_trees();
+  auto ancestor_scroll_id =
+      property_trees->layer_id_to_scroll_node_index.find(scroll_ancestor->id());
+  if (ancestor_scroll_id == property_trees->layer_id_to_scroll_node_index.end())
+    return false;
+
+  ScrollTree& scroll_tree = property_trees->scroll_tree;
   ScrollNode* scroll_node = scroll_tree.Node(child->scroll_tree_index());
   for (; scroll_tree.parent(scroll_node);
        scroll_node = scroll_tree.parent(scroll_node)) {
     if (scroll_node->scrollable)
-      return scroll_node->owning_layer_id == scroll_ancestor->id();
+      return scroll_node->id == ancestor_scroll_id->second;
   }
   return false;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBeginImpl(
     ScrollState* scroll_state,
     LayerImpl* scrolling_layer_impl,
     InputHandler::ScrollInputType type) {
   DCHECK(scroll_state);
   DCHECK(scroll_state->delta_x() == 0 && scroll_state->delta_y() == 0);
@@ skipping 1482 matching lines @@
       worker_context_visibility_ =
           worker_context->CacheController()->ClientBecameVisible();
     } else {
       worker_context->CacheController()->ClientBecameNotVisible(
           std::move(worker_context_visibility_));
     }
   }
 }
 
 }  // namespace cc