Replace layer id with Element id for tracking scrollbar animation controllers

cc/layers/solid_color_scrollbar_layer.cc

 // Copyright 2013 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/layers/solid_color_scrollbar_layer.h"
 
 #include <memory>
 
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
 
 namespace cc {
 
 std::unique_ptr<LayerImpl> SolidColorScrollbarLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   const bool kIsOverlayScrollbar = true;
   return SolidColorScrollbarLayerImpl::Create(
       tree_impl, id(), orientation(),
       solid_color_scrollbar_layer_inputs_.thumb_thickness,
       solid_color_scrollbar_layer_inputs_.track_start,
       solid_color_scrollbar_layer_inputs_.is_left_side_vertical_scrollbar,
       kIsOverlayScrollbar);
 }
 
 scoped_refptr<SolidColorScrollbarLayer> SolidColorScrollbarLayer::Create(
     ScrollbarOrientation orientation,
     int thumb_thickness,
     int track_start,
     bool is_left_side_vertical_scrollbar,
-    int scroll_layer_id) {
+    int scroll_layer_id,
+    ElementId scroll_element_id) {
   return make_scoped_refptr(new SolidColorScrollbarLayer(
       orientation, thumb_thickness, track_start,
-      is_left_side_vertical_scrollbar, scroll_layer_id));
+      is_left_side_vertical_scrollbar, scroll_layer_id, scroll_element_id));
 }
 
 SolidColorScrollbarLayer::SolidColorScrollbarLayerInputs::
     SolidColorScrollbarLayerInputs(ScrollbarOrientation orientation,
                                    int thumb_thickness,
                                    int track_start,
                                    bool is_left_side_vertical_scrollbar,
-                                   int scroll_layer_id)
+                                   int scroll_layer_id,
+                                   ElementId scroll_element_id)
     : scroll_layer_id(scroll_layer_id),
+      scroll_element_id(scroll_element_id),
       orientation(orientation),
       thumb_thickness(thumb_thickness),
       track_start(track_start),
       is_left_side_vertical_scrollbar(is_left_side_vertical_scrollbar) {}
 
 SolidColorScrollbarLayer::SolidColorScrollbarLayerInputs::
     ~SolidColorScrollbarLayerInputs() = default;
 
 SolidColorScrollbarLayer::SolidColorScrollbarLayer(
     ScrollbarOrientation orientation,
     int thumb_thickness,
     int track_start,
     bool is_left_side_vertical_scrollbar,
-    int scroll_layer_id)
+    int scroll_layer_id,
+    ElementId scroll_element_id)
     : solid_color_scrollbar_layer_inputs_(orientation,
                                           thumb_thickness,
                                           track_start,
                                           is_left_side_vertical_scrollbar,
-                                          scroll_layer_id) {
+                                          scroll_layer_id,
+                                          scroll_element_id) {
   Layer::SetOpacity(0.f);
 }
 
 SolidColorScrollbarLayer::~SolidColorScrollbarLayer() {}
 
 ScrollbarLayerInterface* SolidColorScrollbarLayer::ToScrollbarLayer() {
   return this;
 }
 
 void SolidColorScrollbarLayer::SetOpacity(float opacity) {
   // The opacity of a solid color scrollbar layer is always 0 on main thread.
   DCHECK_EQ(opacity, 0.f);
   Layer::SetOpacity(opacity);
 }
 
 void SolidColorScrollbarLayer::PushPropertiesTo(LayerImpl* layer) {
   Layer::PushPropertiesTo(layer);
   SolidColorScrollbarLayerImpl* scrollbar_layer =
       static_cast<SolidColorScrollbarLayerImpl*>(layer);
 
-  scrollbar_layer->SetScrollLayerId(
-      solid_color_scrollbar_layer_inputs_.scroll_layer_id);
+  scrollbar_layer->SetScrollInfo(
+      solid_color_scrollbar_layer_inputs_.scroll_layer_id,
+      solid_color_scrollbar_layer_inputs_.scroll_element_id);
 }
 
 void SolidColorScrollbarLayer::SetNeedsDisplayRect(const gfx::Rect& rect) {
   // Never needs repaint.
 }
 
 bool SolidColorScrollbarLayer::OpacityCanAnimateOnImplThread() const {
   return true;
 }
 
 bool SolidColorScrollbarLayer::AlwaysUseActiveTreeOpacity() const {
   return true;
 }
 
-int SolidColorScrollbarLayer::ScrollLayerId() const {
-  return solid_color_scrollbar_layer_inputs_.scroll_layer_id;
+ElementId SolidColorScrollbarLayer::scroll_element_id() const {
+  return solid_color_scrollbar_layer_inputs_.scroll_element_id;
 }
 
-void SolidColorScrollbarLayer::SetScrollLayer(int layer_id) {
-  if (layer_id == solid_color_scrollbar_layer_inputs_.scroll_layer_id)
+void SolidColorScrollbarLayer::SetScrollInfo(int layer_id,
+                                             ElementId element_id) {
+  if (layer_id == solid_color_scrollbar_layer_inputs_.scroll_layer_id &&
+      element_id == solid_color_scrollbar_layer_inputs_.scroll_element_id)
     return;
 
   solid_color_scrollbar_layer_inputs_.scroll_layer_id = layer_id;
+  solid_color_scrollbar_layer_inputs_.scroll_element_id = element_id;
   SetNeedsFullTreeSync();
 }
 
 ScrollbarOrientation SolidColorScrollbarLayer::orientation() const {
   return solid_color_scrollbar_layer_inputs_.orientation;
 }
 
 }  // namespace cc