cc: Move solid color scrollbar layer data in a seperate struct.

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"
 #include "cc/proto/cc_conversions.h"
 #include "cc/proto/layer.pb.h"
 
 namespace cc {
 
 std::unique_ptr<LayerImpl> SolidColorScrollbarLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   const bool kIsOverlayScrollbar = true;
-  return SolidColorScrollbarLayerImpl::Create(tree_impl,
-                                              id(),
-                                              orientation(),
-                                              thumb_thickness_,
-                                              track_start_,
-                                              is_left_side_vertical_scrollbar_,
-                                              kIsOverlayScrollbar);
+  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) {
   return make_scoped_refptr(new SolidColorScrollbarLayer(
       orientation, thumb_thickness, track_start,
       is_left_side_vertical_scrollbar, scroll_layer_id));
 }
 
+SolidColorScrollbarLayer::SolidColorScrollbarLayerInputs::
+    SolidColorScrollbarLayerInputs(ScrollbarOrientation orientation,
+                                   int thumb_thickness,
+                                   int track_start,
+                                   bool is_left_side_vertical_scrollbar,
+                                   int scroll_layer_id)
+    : scroll_layer_id(Layer::INVALID_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)
-    : scroll_layer_id_(Layer::INVALID_ID),
-      orientation_(orientation),
-      thumb_thickness_(thumb_thickness),
-      track_start_(track_start),
-      is_left_side_vertical_scrollbar_(is_left_side_vertical_scrollbar) {
+    : solid_color_scrollbar_layer_inputs_(orientation,
+                                          thumb_thickness,
+                                          track_start,
+                                          is_left_side_vertical_scrollbar,
+                                          scroll_layer_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(scroll_layer_id_);
+  scrollbar_layer->SetScrollLayerId(
+      solid_color_scrollbar_layer_inputs_.scroll_layer_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 scroll_layer_id_;
+  return solid_color_scrollbar_layer_inputs_.scroll_layer_id;
 }
 
 void SolidColorScrollbarLayer::SetScrollLayer(int layer_id) {
-  if (layer_id == scroll_layer_id_)
+  if (layer_id == solid_color_scrollbar_layer_inputs_.scroll_layer_id)
     return;
 
-  scroll_layer_id_ = layer_id;
+  solid_color_scrollbar_layer_inputs_.scroll_layer_id = layer_id;
   SetNeedsFullTreeSync();
 }
 
 ScrollbarOrientation SolidColorScrollbarLayer::orientation() const {
-  return orientation_;
+  return solid_color_scrollbar_layer_inputs_.orientation;
 }
 
 void SolidColorScrollbarLayer::SetTypeForProtoSerialization(
     proto::LayerNode* proto) const {
   proto->set_type(proto::LayerNode::SOLID_COLOR_SCROLLBAR_LAYER);
 }
 
 void SolidColorScrollbarLayer::LayerSpecificPropertiesToProto(
     proto::LayerProperties* proto) {
   Layer::LayerSpecificPropertiesToProto(proto);
 
   proto::SolidColorScrollbarLayerProperties* scrollbar =
       proto->mutable_solid_scrollbar();
-  scrollbar->set_scroll_layer_id(scroll_layer_id_);
-  scrollbar->set_thumb_thickness(thumb_thickness_);
-  scrollbar->set_track_start(track_start_);
+  scrollbar->set_scroll_layer_id(
+      solid_color_scrollbar_layer_inputs_.scroll_layer_id);
+  scrollbar->set_thumb_thickness(
+      solid_color_scrollbar_layer_inputs_.thumb_thickness);
+  scrollbar->set_track_start(solid_color_scrollbar_layer_inputs_.track_start);
   scrollbar->set_is_left_side_vertical_scrollbar(
-      is_left_side_vertical_scrollbar_);
-  scrollbar->set_orientation(ScrollbarOrientationToProto(orientation_));
+      solid_color_scrollbar_layer_inputs_.is_left_side_vertical_scrollbar);
+  scrollbar->set_orientation(ScrollbarOrientationToProto(
+      solid_color_scrollbar_layer_inputs_.orientation));
 }
 
 void SolidColorScrollbarLayer::FromLayerSpecificPropertiesProto(
     const proto::LayerProperties& proto) {
   Layer::FromLayerSpecificPropertiesProto(proto);
 
   const proto::SolidColorScrollbarLayerProperties& scrollbar =
       proto.solid_scrollbar();
-  scroll_layer_id_ = scrollbar.scroll_layer_id();
-  thumb_thickness_ = scrollbar.thumb_thickness();
-  track_start_ = scrollbar.track_start();
-  is_left_side_vertical_scrollbar_ =
+  solid_color_scrollbar_layer_inputs_.scroll_layer_id =
+      scrollbar.scroll_layer_id();
+  solid_color_scrollbar_layer_inputs_.thumb_thickness =
+      scrollbar.thumb_thickness();
+  solid_color_scrollbar_layer_inputs_.track_start = scrollbar.track_start();
+  solid_color_scrollbar_layer_inputs_.is_left_side_vertical_scrollbar =
       scrollbar.is_left_side_vertical_scrollbar();
-  orientation_ = ScrollbarOrientationFromProto(scrollbar.orientation());
+  solid_color_scrollbar_layer_inputs_.orientation =
+      ScrollbarOrientationFromProto(scrollbar.orientation());
 }
 
 }  // namespace cc