Pinch/Zoom Infrastructure & Plumbing CL

cc/trees/layer_tree_host_common_unittest.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/layer_tree_host_common.h"
 
 #include <set>
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
@@ skipping 404 matching lines @@
   sublayer->SetContentsScale(kPageScale * kDeviceScale,
                              kPageScale * kDeviceScale);
   SetLayerPropertiesForTesting(sublayer,
                                identity_matrix,
                                identity_matrix,
                                gfx::Point(),
                                gfx::PointF(),
                                gfx::Size(500, 500),
                                false);
 
-  scoped_ptr<LayerImpl> scroll_layerScopedPtr(
+  scoped_ptr<LayerImpl> scroll_layer_scoped_ptr(
       LayerImpl::Create(host_impl.active_tree(), 2));
-  LayerImpl* scroll_layer = scroll_layerScopedPtr.get();
+  LayerImpl* scroll_layer = scroll_layer_scoped_ptr.get();
   SetLayerPropertiesForTesting(scroll_layer,
                                identity_matrix,
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(10, 20),
                                false);
-  scroll_layer->SetScrollable(true);
-  scroll_layer->SetMaxScrollOffset(kMaxScrollOffset);
+
+  scoped_ptr<LayerImpl> clip_layer_scoped_ptr(
+      LayerImpl::Create(host_impl.active_tree(), 4));
+  LayerImpl* clip_layer = clip_layer_scoped_ptr.get();
+
+  scroll_layer->SetScrollable(clip_layer->id());
+  clip_layer->SetBounds(
+      gfx::Size(scroll_layer->bounds().width() + kMaxScrollOffset.x(),
+                scroll_layer->bounds().height() + kMaxScrollOffset.y()));
   scroll_layer->SetScrollOffset(kScrollOffset);
   scroll_layer->SetScrollDelta(kScrollDelta);
   gfx::Transform impl_transform;
   scroll_layer->AddChild(sublayer_scoped_ptr.Pass());
+  clip_layer->AddChild(scroll_layer_scoped_ptr.Pass());
 
   scoped_ptr<LayerImpl> root(LayerImpl::Create(host_impl.active_tree(), 3));
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(3, 4),
                                false);
-  root->AddChild(scroll_layerScopedPtr.Pass());
+  root->AddChild(clip_layer_scoped_ptr.Pass());
 
   ExecuteCalculateDrawProperties(
       root.get(), kDeviceScale, kPageScale, scroll_layer->parent());
   gfx::Transform expected_transform = identity_matrix;
   gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta;
   sub_layer_screen_position.Scale(kPageScale * kDeviceScale);
   expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x()),
                                MathUtil::Round(sub_layer_screen_position.y()));
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->draw_transform());
@@ skipping 912 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   grand_child->draw_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
   // Transformations applied at the root of the tree should be forwarded
   // to child layers instead of applied to the root RenderSurface.
   const gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
-  child->SetScrollable(true);
+  child->SetScrollable(root.get());
   root->AddChild(child);
 
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(root);
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
@@ skipping 7132 matching lines @@
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + render_surface1 (sets opacity)
   //        + intervening (masks to bounds AND scrolls)
   //          + render_surface2 (also sets opacity)
   //            + clip_child
   //
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> clip_parent = Layer::Create();
   scoped_refptr<Layer> render_surface1 = Layer::Create();
+  scoped_refptr<Layer> clip_intervening = Layer::Create();
   scoped_refptr<Layer> intervening = Layer::Create();
   scoped_refptr<Layer> render_surface2 = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> clip_child =
       make_scoped_refptr(new LayerWithForcedDrawsContent);
 
   root->AddChild(clip_parent);
   clip_parent->AddChild(render_surface1);
-  render_surface1->AddChild(intervening);
+  render_surface1->AddChild(clip_intervening);
+  clip_intervening->AddChild(intervening);
   intervening->AddChild(render_surface2);
   render_surface2->AddChild(clip_child);
 
   clip_child->SetClipParent(clip_parent.get());
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
-  intervening->SetScrollable(true);
-  intervening->SetMaxScrollOffset(gfx::Vector2d(50, 50));
+  intervening->SetScrollable(clip_intervening.get());
+  clip_intervening->SetBounds(gfx::Size(5, 5));
   intervening->SetScrollOffset(gfx::Vector2d(3, 3));
 
   render_surface1->SetForceRenderSurface(true);
   render_surface2->SetForceRenderSurface(true);
 
   gfx::Transform translation_transform;
   translation_transform.Translate(2, 2);
 
   gfx::Transform identity_transform;
   SetLayerPropertiesForTesting(root.get(),
@@ skipping 15 matching lines @@
                                identity_transform,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false);
   SetLayerPropertiesForTesting(intervening.get(),
                                identity_transform,
                                identity_transform,
                                gfx::PointF(),
                                gfx::PointF(1.f, 1.f),
-                               gfx::Size(5, 5),
+                               gfx::Size(55, 55),
                                false);
   SetLayerPropertiesForTesting(render_surface2.get(),
                                identity_transform,
                                identity_transform,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false);
   SetLayerPropertiesForTesting(clip_child.get(),
                                identity_transform,
@@ skipping 944 matching lines @@
   // due to layer sorting).
   EXPECT_EQ(4u, root->render_surface()->layer_list().size());
   EXPECT_EQ(5, root->render_surface()->layer_list().at(0)->id());
   EXPECT_EQ(6, root->render_surface()->layer_list().at(1)->id());
   EXPECT_EQ(7, root->render_surface()->layer_list().at(2)->id());
   EXPECT_EQ(4, root->render_surface()->layer_list().at(3)->id());
 }
 
 }  // namespace
 }  // namespace cc