Pinch/Zoom Infrastructure & Plumbing CL

cc/trees/layer_tree_host_unittest_damage.cc

 // Copyright 2012 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.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 404 matching lines @@
 
 SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F(LayerTreeHostDamageTestForcedFullDamage);
 
 class LayerTreeHostScrollbarDamageTest : public LayerTreeHostDamageTest {
   virtual void SetupTree() OVERRIDE {
     scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetBounds(gfx::Size(400, 400));
     root_layer->SetMasksToBounds(true);
     layer_tree_host()->SetRootLayer(root_layer);
 
+    scoped_refptr<Layer> scroll_clip_layer = Layer::Create();
     scoped_refptr<Layer> content_layer = FakeContentLayer::Create(&client_);
-    content_layer->SetScrollable(true);
+    content_layer->SetScrollable(scroll_clip_layer.get());
     content_layer->SetScrollOffset(gfx::Vector2d(10, 20));
-    content_layer->SetMaxScrollOffset(gfx::Vector2d(30, 50));
     content_layer->SetBounds(gfx::Size(100, 200));
-    root_layer->AddChild(content_layer);
+    scroll_clip_layer->SetBounds(
+        gfx::Size(content_layer->bounds().width() - 30,
+                  content_layer->bounds().height() - 50));
+    scroll_clip_layer->AddChild(content_layer);
+    root_layer->AddChild(scroll_clip_layer);
 
     scoped_refptr<Layer> scrollbar_layer =
-        FakePaintedScrollbarLayer::Create(false, true, content_layer->id());
+        FakePaintedScrollbarLayer::Create(false, true, content_layer.get());
     scrollbar_layer->SetPosition(gfx::Point(300, 300));
     scrollbar_layer->SetBounds(gfx::Size(10, 100));
+    scrollbar_layer->ToScrollbarLayer()->SetClipLayer(scroll_clip_layer);
+    scrollbar_layer->ToScrollbarLayer()->SetScrollLayer(content_layer);
     root_layer->AddChild(scrollbar_layer);
 
     gfx::RectF content_rect(content_layer->position(),
                             content_layer->bounds());
     gfx::RectF scrollbar_rect(scrollbar_layer->position(),
                               scrollbar_layer->bounds());
     EXPECT_FALSE(content_rect.Intersects(scrollbar_rect));
 
     LayerTreeHostDamageTest::SetupTree();
   }
@@ skipping 37 matching lines @@
         break;
     }
     return result;
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     ++did_swaps_;
     EXPECT_TRUE(result);
     LayerImpl* root = host_impl->active_tree()->root_layer();
-    LayerImpl* scroll_layer = root->children()[0];
+    LayerImpl* scroll_clip_layer = root->children()[0];
+    LayerImpl* scroll_layer = scroll_clip_layer->children()[0];
     switch (did_swaps_) {
       case 1:
         // Test that modifying the position of the content layer (not
         // scrolling) won't damage the scrollbar.
         scroll_layer->SetPosition(gfx::Point(1, 1));
         scroll_layer->SetScrollOffset(scroll_layer->scroll_offset());
         host_impl->SetNeedsRedraw();
         break;
       case 2:
         scroll_layer->ScrollBy(gfx::Vector2dF(10.f, 10.f));
         host_impl->SetNeedsRedraw();
         break;
       case 3:
-        scroll_layer->SetMaxScrollOffset(gfx::Vector2d(60, 100));
+        scroll_layer->SetBounds(gfx::Size(root->bounds().width() + 60,
+                                          root->bounds().height() + 100));
         host_impl->SetNeedsRedraw();
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {
     EXPECT_EQ(4, did_swaps_);
   }
 
   int did_swaps_;
@@ skipping 38 matching lines @@
         break;
     }
     return result;
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     ++did_swaps_;
     EXPECT_TRUE(result);
     LayerImpl* root = host_impl->active_tree()->root_layer();
-    LayerImpl* scroll_layer = root->children()[0];
+    LayerImpl* scroll_clip_layer = root->children()[0];
+    LayerImpl* scroll_layer = scroll_clip_layer->children()[0];
     switch (did_swaps_) {
       case 1:
         // Scroll on the thread.  This should damage the scrollbar for the
         // next draw on the thread.
         scroll_layer->ScrollBy(gfx::Vector2dF(10.f, 10.f));
         host_impl->SetNeedsRedraw();
         break;
       case 2:
         // Forcibly send the scroll to the main thread.
         PostSetNeedsCommitToMainThread();
@@ skipping 109 matching lines @@
   FakeContentLayerClient client_;
   int swap_count_;
   int prepare_to_draw_count_;
   int update_visible_tile_count_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestVisibleTilesStillTriggerDraws);
 
 }  // namespace
 }  // namespace cc