Pinch/Zoom Infrastructure & Plumbing CL

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/containers/scoped_ptr_hash_map.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_impl_base.h"
 #include "cc/layers/scrollbar_layer_interface.h"
 
 namespace cc {
 
 typedef base::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;
 
+  layer_impl->ClearScrollbars();
+  if (ScrollbarLayerImplBase* scrollbar_layer =
+          layer_impl->ToScrollbarLayer()) {
+    scrollbar_layer->ClearClipLayer();
+    scrollbar_layer->ClearScrollLayer();
+  }
+
   OwnedLayerImplList& children = layer_impl->children();
   for (OwnedLayerImplList::iterator it = children.begin();
        it != children.end();
        ++it)
     CollectExistingLayerImplRecursive(old_layers, children.take(it));
 
   CollectExistingLayerImplRecursive(old_layers, layer_impl->TakeMaskLayer());
   CollectExistingLayerImplRecursive(old_layers, layer_impl->TakeReplicaLayer());
 
   int id = layer_impl->id();
@@ skipping 67 matching lines @@
   for (size_t i = 0; i < layer->children().size(); ++i) {
     layer_impl->AddChild(SynchronizeTreesRecursiveInternal(
         new_layers, old_layers, layer->child_at(i), tree_impl));
   }
 
   layer_impl->SetMaskLayer(SynchronizeTreesRecursiveInternal(
       new_layers, old_layers, layer->mask_layer(), tree_impl));
   layer_impl->SetReplicaLayer(SynchronizeTreesRecursiveInternal(
       new_layers, old_layers, layer->replica_layer(), tree_impl));
 
-  // Remove all dangling pointers. The pointers will be setup later in
-  // UpdateScrollbarLayerPointersRecursive phase
-  layer_impl->SetHorizontalScrollbarLayer(NULL);
-  layer_impl->SetVerticalScrollbarLayer(NULL);
-
   return layer_impl.Pass();
 }
 
 scoped_ptr<LayerImpl> SynchronizeTreesRecursive(
     RawPtrLayerImplMap* new_layers,
     ScopedPtrLayerImplMap* old_layers,
     Layer* layer,
     LayerTreeImpl* tree_impl) {
   return SynchronizeTreesRecursiveInternal(
       new_layers, old_layers, layer, tree_impl);
@@ skipping 23 matching lines @@
   ScrollbarLayerType* scrollbar_layer = layer->ToScrollbarLayer();
   if (!scrollbar_layer)
     return;
 
   RawPtrLayerImplMap::const_iterator iter =
       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->ScrollLayerId());
-  LayerImpl* scroll_layer_impl =
-      iter != new_layers->end() ? iter->second : NULL;
+  DCHECK(scrollbar_layer_impl);
 
-  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);
+  scrollbar_layer->PushScrollClipPropertiesTo(scrollbar_layer_impl);
 }
 
 void UpdateScrollbarLayerPointersRecursive(const RawPtrLayerImplMap* new_layers,
                                            Layer* layer) {
   UpdateScrollbarLayerPointersRecursiveInternal<Layer, ScrollbarLayerInterface>(
       new_layers, layer);
 }
 
 void UpdateScrollbarLayerPointersRecursive(const RawPtrLayerImplMap* new_layers,
                                            LayerImpl* layer) {
@@ skipping 14 matching lines @@
   }
 
   DCHECK_EQ(layer->id(), layer_impl->id());
 
   bool push_layer = layer->needs_push_properties();
   bool recurse_on_children_and_dependents =
       layer->descendant_needs_push_properties();
 
   if (push_layer)
     layer->PushPropertiesTo(layer_impl);
+  else if (layer->ToScrollbarLayer())
+    layer->ToScrollbarLayer()->PushScrollClipPropertiesTo(layer_impl);
 
   size_t num_dependents_need_push_properties = 0;
   if (recurse_on_children_and_dependents) {
     PushPropertiesInternal(layer->mask_layer(),
                            layer_impl->mask_layer(),
                            &num_dependents_need_push_properties);
     PushPropertiesInternal(layer->replica_layer(),
                            layer_impl->replica_layer(),
                            &num_dependents_need_push_properties);
 
@@ skipping 27 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