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

cc/trees/tree_synchronizer.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/tree_synchronizer.h"
 
 #include "base/containers/hash_tables.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/input/scrollbar.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
-#include "cc/layers/scrollbar_layer.h"
-#include "cc/layers/scrollbar_layer_impl.h"
+#include "cc/layers/scrollbar_layer_base.h"
+#include "cc/layers/scrollbar_layer_impl_base.h"
 
 namespace cc {
 
 typedef ScopedPtrHashMap<int, LayerImpl> ScopedPtrLayerImplMap;
 typedef base::hash_map<int, LayerImpl*> RawPtrLayerImplMap;
 
 void CollectExistingLayerImplRecursive(ScopedPtrLayerImplMap* old_layers,
                                        scoped_ptr<LayerImpl> layer_impl) {
   if (!layer_impl)
     return;
@@ skipping 116 matching lines @@
     const RawPtrLayerImplMap* new_layers,
     LayerType* layer) {
   if (!layer)
     return;
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     UpdateScrollbarLayerPointersRecursiveInternal<
         LayerType, ScrollbarLayerType>(new_layers, layer->child_at(i));
   }
 
-  ScrollbarLayerType* scrollbar_layer = layer->ToScrollbarLayer();
+  ScrollbarLayerType* scrollbar_layer = layer->ToScrollbarLayerBase();
   if (!scrollbar_layer)
     return;
 
   RawPtrLayerImplMap::const_iterator iter =
-      new_layers->find(scrollbar_layer->id());
-  ScrollbarLayerImpl* scrollbar_layer_impl =
-      iter != new_layers->end() ? static_cast<ScrollbarLayerImpl*>(iter->second)
-                               : NULL;
+      new_layers->find(layer->id());
+  ScrollbarLayerImplBase* scrollbar_layer_impl =
+      iter != new_layers->end()
+          ? static_cast<ScrollbarLayerImplBase*>(iter->second)
+          : NULL;
   iter = new_layers->find(scrollbar_layer->scroll_layer_id());
   LayerImpl* scroll_layer_impl =
       iter != new_layers->end() ? iter->second : NULL;
 
   DCHECK(scrollbar_layer_impl);
   DCHECK(scroll_layer_impl);
 
   if (scrollbar_layer->Orientation() == HORIZONTAL)
     scroll_layer_impl->SetHorizontalScrollbarLayer(scrollbar_layer_impl);
   else
     scroll_layer_impl->SetVerticalScrollbarLayer(scrollbar_layer_impl);
 }
 
 void UpdateScrollbarLayerPointersRecursive(const RawPtrLayerImplMap* new_layers,
                                            Layer* layer) {
-  UpdateScrollbarLayerPointersRecursiveInternal<Layer, ScrollbarLayer>(
+  UpdateScrollbarLayerPointersRecursiveInternal<Layer, ScrollbarLayerBase>(
       new_layers, layer);
 }
 
 void UpdateScrollbarLayerPointersRecursive(const RawPtrLayerImplMap* new_layers,
                                            LayerImpl* layer) {
-  UpdateScrollbarLayerPointersRecursiveInternal<LayerImpl, ScrollbarLayerImpl>(
-      new_layers, layer);
+  UpdateScrollbarLayerPointersRecursiveInternal<
+      LayerImpl,
+      ScrollbarLayerImplBase>(new_layers, layer);
 }
 
 template <typename LayerType>
 void PushPropertiesInternal(LayerType* layer, LayerImpl* layer_impl) {
   if (!layer) {
     DCHECK(!layer_impl);
     return;
   }
 
   DCHECK_EQ(layer->id(), layer_impl->id());
@@ skipping 12 matching lines @@
 
 void TreeSynchronizer::PushProperties(Layer* layer, LayerImpl* layer_impl) {
   PushPropertiesInternal(layer, layer_impl);
 }
 
 void TreeSynchronizer::PushProperties(LayerImpl* layer, LayerImpl* layer_impl) {
   PushPropertiesInternal(layer, layer_impl);
 }
 
 }  // namespace cc