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();

[enne (OOO), 2013/08/12 23:15:01]

I agree with jamesr that there's really not that much in ScrollbarLayerBase
going on that needs to be shared.

One suggestion would be to have a ScrollbarLayerInterface that exposed
Orientation() and ScrollLayerId() and have both ScrollbarLayer and
SolidColorScrollbarLayer implement that interface.  Then
SolidColorScrollbarLayer would no longer need to inherit from
ContentsScalingLayer, but you wouldn't have to complicate TreeSynchronizer with
different kinds of scrollbars.

[wjmaclean, 2013/08/14 18:19:44]

Sure, that sounds good. I've converted to an interface as you suggest (let me
know if the way I've done this seems reasonable).

   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)
+  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);
 }
 
 // static
 void TreeSynchronizer::SetNumDependentsNeedPushProperties(
     Layer* layer, size_t num) {
   layer->num_dependents_need_push_properties_ = num;
 }
 
 // static
 void TreeSynchronizer::SetNumDependentsNeedPushProperties(
@@ skipping 59 matching lines @@
       layer, layer_impl, &num_dependents_need_push_properties);
 }
 
 void TreeSynchronizer::PushProperties(LayerImpl* layer, LayerImpl* layer_impl) {
   size_t num_dependents_need_push_properties = 0;
   PushPropertiesInternal(
       layer, layer_impl, &num_dependents_need_push_properties);
 }
 
 }  // namespace cc