Refactor LayerTreeImpl's scrollbar map to be keyed on element ids

cc/trees/layer_tree_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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 228 matching lines @@
     current_offset += InnerViewportScrollLayer()->CurrentScrollOffset();
     if (OuterViewportContainerLayer())
       clip_size.SetToMin(OuterViewportContainerLayer()->BoundsForScrolling());
     clip_size.Scale(1 / current_page_scale_factor());
   }
 
   bool scrollbar_needs_animation = false;
   bool clip_layer_size_did_change = false;
   bool scroll_layer_size_did_change = false;
   bool y_offset_did_change = false;
-  for (ScrollbarLayerImplBase* scrollbar : ScrollbarsFor(scroll_layer_id)) {
+  for (auto* scrollbar : ScrollbarsFor(scroll_layer->element_id())) {
     if (scrollbar->orientation() == HORIZONTAL) {
       scrollbar_needs_animation |= scrollbar->SetCurrentPos(current_offset.x());
       clip_layer_size_did_change |=
           scrollbar->SetClipLayerLength(clip_size.width());
       scroll_layer_size_did_change |=
           scrollbar->SetScrollLayerLength(scroll_size.width());
     } else {
       scrollbar_needs_animation |= y_offset_did_change |=
           scrollbar->SetCurrentPos(current_offset.y());
       clip_layer_size_did_change |=
@@ skipping 1200 matching lines @@
 
 gfx::Size LayerTreeImpl::DrawViewportSize() const {
   return layer_tree_host_impl_->DrawViewportSize();
 }
 
 const gfx::Rect LayerTreeImpl::ViewportRectForTilePriority() const {
   return layer_tree_host_impl_->ViewportRectForTilePriority();
 }
 
 std::unique_ptr<ScrollbarAnimationController>
-LayerTreeImpl::CreateScrollbarAnimationController(int scroll_layer_id) {
+LayerTreeImpl::CreateScrollbarAnimationController(ElementId scroll_element_id) {
   DCHECK(!settings().scrollbar_fade_out_delay.is_zero());
   DCHECK(!settings().scrollbar_fade_out_duration.is_zero());
   base::TimeDelta fade_out_delay = settings().scrollbar_fade_out_delay;
   base::TimeDelta fade_out_resize_delay =
       settings().scrollbar_fade_out_resize_delay;
   base::TimeDelta fade_out_duration = settings().scrollbar_fade_out_duration;
   switch (settings().scrollbar_animator) {
     case LayerTreeSettings::ANDROID_OVERLAY: {
       return ScrollbarAnimationController::
           CreateScrollbarAnimationControllerAndroid(
-              scroll_layer_id, layer_tree_host_impl_, fade_out_delay,
+              scroll_element_id, layer_tree_host_impl_, fade_out_delay,
               fade_out_resize_delay, fade_out_duration);
     }
     case LayerTreeSettings::AURA_OVERLAY: {
       DCHECK(!settings().scrollbar_show_delay.is_zero());
       base::TimeDelta show_delay = settings().scrollbar_show_delay;
       base::TimeDelta thinning_duration =
           settings().scrollbar_thinning_duration;
       return ScrollbarAnimationController::
           CreateScrollbarAnimationControllerAuraOverlay(
-              scroll_layer_id, layer_tree_host_impl_, show_delay,
+              scroll_element_id, layer_tree_host_impl_, show_delay,
               fade_out_delay, fade_out_resize_delay, fade_out_duration,
               thinning_duration);
     }
     case LayerTreeSettings::NO_ANIMATOR:
       NOTREACHED();
       break;
   }
   return nullptr;
 }
 
@@ skipping 211 matching lines @@
 }
 
 void LayerTreeImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 void LayerTreeImpl::RegisterScrollbar(ScrollbarLayerImplBase* scrollbar_layer) {
-  if (scrollbar_layer->ScrollLayerId() == Layer::INVALID_ID)
+  ElementId scroll_element_id = scrollbar_layer->scroll_element_id();
+  if (!scroll_element_id)
     return;
 
-  scrollbar_map_.insert(std::pair<int, int>(scrollbar_layer->ScrollLayerId(),
-                                            scrollbar_layer->id()));
+  element_id_to_scrollbar_layer_ids_.insert(
+      std::pair<ElementId, int>(scroll_element_id, scrollbar_layer->id()));
   if (IsActiveTree() && scrollbar_layer->is_overlay_scrollbar()) {
-    auto scroll_layer_id = scrollbar_layer->ScrollLayerId();
     layer_tree_host_impl_->RegisterScrollbarAnimationController(
-        scroll_layer_id, scrollbar_layer->scroll_element_id());
+        scroll_element_id);
   }
 
   DidUpdateScrollState(scrollbar_layer->ScrollLayerId());
 }
 
 void LayerTreeImpl::UnregisterScrollbar(
     ScrollbarLayerImplBase* scrollbar_layer) {
-  int scroll_layer_id = scrollbar_layer->ScrollLayerId();
-  if (scroll_layer_id == Layer::INVALID_ID)
+  ElementId scroll_element_id = scrollbar_layer->scroll_element_id();
+  if (!scroll_element_id)
     return;
 
-  auto scrollbar_range = scrollbar_map_.equal_range(scroll_layer_id);
+  auto scrollbar_range =
+      element_id_to_scrollbar_layer_ids_.equal_range(scroll_element_id);
   for (auto i = scrollbar_range.first; i != scrollbar_range.second; ++i)
     if (i->second == scrollbar_layer->id()) {
-      scrollbar_map_.erase(i);
+      element_id_to_scrollbar_layer_ids_.erase(i);
       break;
     }
 
-  if (IsActiveTree() && scrollbar_map_.count(scroll_layer_id) == 0) {
+  if (IsActiveTree() &&
+      element_id_to_scrollbar_layer_ids_.count(scroll_element_id) == 0) {
     layer_tree_host_impl_->UnregisterScrollbarAnimationController(
-        scrollbar_layer->scroll_element_id());
+        scroll_element_id);
   }
 }
 
-ScrollbarSet LayerTreeImpl::ScrollbarsFor(int scroll_layer_id) const {
+ScrollbarSet LayerTreeImpl::ScrollbarsFor(ElementId scroll_element_id) const {
   ScrollbarSet scrollbars;
-  auto scrollbar_range = scrollbar_map_.equal_range(scroll_layer_id);
+  auto scrollbar_range =
+      element_id_to_scrollbar_layer_ids_.equal_range(scroll_element_id);
   for (auto i = scrollbar_range.first; i != scrollbar_range.second; ++i)
     scrollbars.insert(LayerById(i->second)->ToScrollbarLayer());
   return scrollbars;
 }
 
 void LayerTreeImpl::RegisterScrollLayer(LayerImpl* layer) {
   if (layer->scroll_clip_layer_id() == Layer::INVALID_ID)
     return;
 
   clip_scroll_map_.insert(
@@ skipping 412 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc