Add map from element id to scroll node index.

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 3924 matching lines @@
     layer->set_was_ever_ready_since_last_transform_animation(false);
 }
 
 void LayerTreeHostImpl::SetTreeLayerScrollOffsetMutated(
     ElementId element_id,
     LayerTreeImpl* tree,
     const gfx::ScrollOffset& scroll_offset) {
   if (!tree)
     return;
 
   const int layer_id = tree->LayerIdByElementId(element_id);

[wkorman, 2017/01/12 00:09:31]

Even after this change this method still looks up layer id by element id for
purposes of passing along to ScrollTree::OnScrollOffsetAnimated, which ends up:

(1) in ScrollTree::synced_scroll_offset referencing
ScrollTree::layer_id_to_scroll_offset_map_, and

(2) in LayerTreeImpl::DidUpdateScrollOffset, using the layer id to get the
transform tree index (which has a TODO noting we can replace with
layer-id-to-index maps when available, which they are now, but now I think we
can actually use element-id-to-transform-index instead), and looking up the
current scroll offset via ScrollTree::current_scroll_offset, which uses
ScrollTree::synced_scroll_offset, which is (1).

However, I currently believe that we want to keep this part of the scrolling
code layer-id-driven since there are many other scrolling related callsites that
use ScrollTree::synced_scroll_offset in ScrollTree, and really the layer is the
thing being operated on, and our main goal is to extricate the property nodes
from a layer id dependency.

But I wanted to raise to hear any ajuma@ feedback.

[ajuma, 2017/01/12 15:58:51]

I think scrolling should ultimately look the same as animation, driven by
element ids. Blink already sets an element id for each scrollable layer (in the
SPv1 codepath at least), so the corresponding scroll nodes should all have
element ids. I think most of the work to make this switch will be updating all
the unit tests that currently create scrollable layers without setting an
element id, and sorting out the scrollbar update logic
(LayerTreeImpl::UpdateScrollbars) that happens when DidUpdateScrollOffset gets
called.

   PropertyTrees* property_trees = tree->property_trees();
   DCHECK(property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::SCROLL,
                                           layer_id));
   DCHECK_EQ(
       1u, property_trees->element_id_to_transform_node_index.count(element_id));
   int transform_node_index =
       property_trees->element_id_to_transform_node_index[element_id];
-  // TODO(wkorman): Build map from element id to scroll node in property tree
-  // builder and make use of it below.
+  DCHECK_EQ(1u,
+            property_trees->element_id_to_scroll_node_index.count(element_id));
   const int scroll_node_index =
-      property_trees->scroll_id_to_index_map[layer_id];
-  if (scroll_node_index != ScrollTree::kInvalidNodeId) {
-    property_trees->scroll_tree.OnScrollOffsetAnimated(
-        layer_id, transform_node_index, scroll_node_index, scroll_offset, tree);
-    // Run mutation callbacks to respond to updated scroll offset.
-    Mutate(CurrentBeginFrameArgs().frame_time);
-  }
+      property_trees->element_id_to_scroll_node_index[element_id];
+  property_trees->scroll_tree.OnScrollOffsetAnimated(
+      layer_id, transform_node_index, scroll_node_index, scroll_offset, tree);
+  // Run mutation callbacks to respond to updated scroll offset.
+  Mutate(CurrentBeginFrameArgs().frame_time);
 }
 
 bool LayerTreeHostImpl::AnimationsPreserveAxisAlignment(
     const LayerImpl* layer) const {
   return mutator_host_->AnimationsPreserveAxisAlignment(layer->element_id());
 }
 
 void LayerTreeHostImpl::SetNeedUpdateGpuRasterizationStatus() {
   need_update_gpu_rasterization_status_ = true;
 }
@@ skipping 116 matching lines @@
       worker_context_visibility_ =
           worker_context->CacheController()->ClientBecameVisible();
     } else {
       worker_context->CacheController()->ClientBecameNotVisible(
           std::move(worker_context_visibility_));
     }
   }
 }
 
 }  // namespace cc