Refactor cc scrollbar layers to separate solid-color vs desktop.

cc/layers/layer_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/layers/layer_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/strings/stringprintf.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/scrollbar_animation_controller.h"
@@ skipping 604 matching lines @@
   if (replica_layer_)
     replica_layer_->set_parent(this);
   NoteLayerPropertyChangedForSubtree();
 }
 
 scoped_ptr<LayerImpl> LayerImpl::TakeReplicaLayer() {
   replica_layer_id_ = -1;
   return replica_layer_.Pass();
 }
 
-ScrollbarLayerImpl* LayerImpl::ToScrollbarLayer() {
+ScrollbarLayerImplBase* LayerImpl::ToScrollbarLayer() {
   return NULL;
 }
 
 void LayerImpl::SetDrawsContent(bool draws_content) {
   if (draws_content_ == draws_content)
     return;
 
   draws_content_ = draws_content;
   NoteLayerPropertyChanged();
 }
@@ skipping 188 matching lines @@
   *content_bounds = this->content_bounds();
 }
 
 void LayerImpl::UpdateScrollbarPositions() {
   gfx::Vector2dF current_offset = scroll_offset_ + ScrollDelta();
 
   gfx::RectF viewport(PointAtOffsetFromOrigin(current_offset), bounds_);
   gfx::SizeF scrollable_size(max_scroll_offset_.x() + bounds_.width(),
                              max_scroll_offset_.y() + bounds_.height());
   if (horizontal_scrollbar_layer_) {
-    horizontal_scrollbar_layer_->SetCurrentPos(current_offset.x());
-    horizontal_scrollbar_layer_->SetMaximum(max_scroll_offset_.x());
+    horizontal_scrollbar_layer_->set_current_pos(current_offset.x());
+    horizontal_scrollbar_layer_->set_maximum(max_scroll_offset_.x());
     horizontal_scrollbar_layer_->set_visible_to_total_length_ratio(
         viewport.width() / scrollable_size.width());
   }
   if (vertical_scrollbar_layer_) {
-    vertical_scrollbar_layer_->SetCurrentPos(current_offset.y());
-    vertical_scrollbar_layer_->SetMaximum(max_scroll_offset_.y());
+    vertical_scrollbar_layer_->set_current_pos(current_offset.y());
+    vertical_scrollbar_layer_->set_maximum(max_scroll_offset_.y());
     vertical_scrollbar_layer_->set_visible_to_total_length_ratio(
         viewport.height() / scrollable_size.height());
   }
 
   if (current_offset == last_scroll_offset_)
     return;
   last_scroll_offset_ = current_offset;
 
   if (scrollbar_animation_controller_ &&
       !scrollbar_animation_controller_->IsScrollGestureInProgress()) {
@@ skipping 121 matching lines @@
       scrollbar_animation_controller_ =
           ScrollbarAnimationControllerLinearFade::Create(
               this, fadeout_delay, fadeout_length)
               .PassAs<ScrollbarAnimationController>();
     }
   } else {
     scrollbar_animation_controller_.reset();
   }
 }
 void LayerImpl::SetHorizontalScrollbarLayer(
-    ScrollbarLayerImpl* scrollbar_layer) {
+    ScrollbarLayerImplBase* scrollbar_layer) {
   horizontal_scrollbar_layer_ = scrollbar_layer;
   if (horizontal_scrollbar_layer_)
     horizontal_scrollbar_layer_->set_scroll_layer_id(id());
 }
 
-void LayerImpl::SetVerticalScrollbarLayer(ScrollbarLayerImpl* scrollbar_layer) {
+void LayerImpl::SetVerticalScrollbarLayer(
+    ScrollbarLayerImplBase* scrollbar_layer) {
   vertical_scrollbar_layer_ = scrollbar_layer;
   if (vertical_scrollbar_layer_)
     vertical_scrollbar_layer_->set_scroll_layer_id(id());
 }
 
 static scoped_ptr<base::Value>
 CompositingReasonsAsValue(CompositingReasons reasons) {
   scoped_ptr<base::ListValue> reason_list(new base::ListValue());
 
   if (reasons == kCompositingReasonUnknown) {
@@ skipping 141 matching lines @@
 
 size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }
 
 scoped_ptr<base::Value> LayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   AsValueInto(state.get());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc