Pinch/Zoom Infrastructure & Plumbing CL

cc/layers/scrollbar_layer_unittest.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 "base/containers/hash_tables.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/scrollbar_layer_interface.h"
@@ skipping 48 matching lines @@
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
       host.get(), scrollbar.Pass(), false, false, 0);
 
   LayerImpl* cc_child1 = layer_impl_tree_root->children()[0];
   PaintedScrollbarLayerImpl* cc_child2 =
       static_cast<PaintedScrollbarLayerImpl*>(
           layer_impl_tree_root->children()[1]);
 
-  EXPECT_EQ(cc_child1->horizontal_scrollbar_layer(), cc_child2);
+  EXPECT_EQ(cc_child1->scrollbars()->size(), 1UL);
+  EXPECT_EQ(*(cc_child1->scrollbars()->begin()), cc_child2);
 }
 
 TEST(ScrollbarLayerTest, ResolveScrollLayerPointer_ReverseOrder) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
       host.get(), scrollbar.Pass(), true, false, 0);
 
   PaintedScrollbarLayerImpl* cc_child1 =
       static_cast<PaintedScrollbarLayerImpl*>(
           layer_impl_tree_root->children()[0]);
   LayerImpl* cc_child2 = layer_impl_tree_root->children()[1];
 
-  EXPECT_EQ(cc_child2->horizontal_scrollbar_layer(), cc_child1);
+  EXPECT_EQ(cc_child2->scrollbars()->size(), 1UL);
+  EXPECT_EQ(*(cc_child2->scrollbars()->begin()), cc_child1);
 }
 
 TEST(ScrollbarLayerTest, ShouldScrollNonOverlayOnMainThread) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
 
   // Create and attach a non-overlay scrollbar.
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
       host.get(), scrollbar.Pass(), false, false, 0);
   PaintedScrollbarLayerImpl* scrollbar_layer_impl =
@@ skipping 20 matching lines @@
   EXPECT_EQ(InputHandler::ScrollIgnored,
             scrollbar_layer_impl->TryScroll(gfx::Point(0, 0),
                                             InputHandler::Gesture));
 }
 
 TEST(PaintedScrollbarLayerTest, ScrollOffsetSynchronization) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
 
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
+  scoped_refptr<Layer> scroll_layer = Layer::Create();
   scoped_refptr<Layer> content_layer = Layer::Create();
   scoped_refptr<Layer> scrollbar_layer =
       PaintedScrollbarLayer::Create(scrollbar.Pass(), layer_tree_root->id());
 
-  layer_tree_root->SetScrollable(true);
-  layer_tree_root->SetScrollOffset(gfx::Vector2d(10, 20));
-  layer_tree_root->SetMaxScrollOffset(gfx::Vector2d(30, 50));
-  layer_tree_root->SetBounds(gfx::Size(100, 200));
+  // Choose bounds to give max_scroll_offset = (30, 50).
+  layer_tree_root->SetBounds(gfx::Size(70, 150));
+  scroll_layer->SetScrollClipLayerId(layer_tree_root->id());
+  scroll_layer->SetScrollOffset(gfx::Vector2d(10, 20));
+  scroll_layer->SetBounds(gfx::Size(100, 200));
   content_layer->SetBounds(gfx::Size(100, 200));
 
   host->SetRootLayer(layer_tree_root);
-  layer_tree_root->AddChild(content_layer);
+  layer_tree_root->AddChild(scroll_layer);
+  scroll_layer->AddChild(content_layer);
   layer_tree_root->AddChild(scrollbar_layer);
+  scrollbar_layer->ToScrollbarLayer()->SetScrollLayer(scroll_layer->id());
+  scrollbar_layer->ToScrollbarLayer()->SetClipLayer(layer_tree_root->id());
 
   layer_tree_root->SavePaintProperties();
   content_layer->SavePaintProperties();
 
   LayerImpl* layer_impl_tree_root = host->CommitAndCreateLayerImplTree();
 
   ScrollbarLayerImplBase* cc_scrollbar_layer =
       static_cast<PaintedScrollbarLayerImpl*>(
           layer_impl_tree_root->children()[1]);
 
   EXPECT_EQ(10.f, cc_scrollbar_layer->current_pos());
   EXPECT_EQ(30, cc_scrollbar_layer->maximum());
 
-  layer_tree_root->SetScrollOffset(gfx::Vector2d(100, 200));
-  layer_tree_root->SetMaxScrollOffset(gfx::Vector2d(300, 500));
-  layer_tree_root->SetBounds(gfx::Size(1000, 2000));
+  layer_tree_root->SetBounds(gfx::Size(700, 1500));
   layer_tree_root->SavePaintProperties();
+  scroll_layer->SetBounds(gfx::Size(1000, 2000));
+  scroll_layer->SetScrollOffset(gfx::Vector2d(100, 200));
+  scroll_layer->SavePaintProperties();
   content_layer->SetBounds(gfx::Size(1000, 2000));
   content_layer->SavePaintProperties();
 
   ScrollbarAnimationController* scrollbar_controller =
       layer_impl_tree_root->scrollbar_animation_controller();
   layer_impl_tree_root = host->CommitAndCreateLayerImplTree();
   EXPECT_EQ(scrollbar_controller,
             layer_impl_tree_root->scrollbar_animation_controller());
 
   EXPECT_EQ(100.f, cc_scrollbar_layer->current_pos());
   EXPECT_EQ(300, cc_scrollbar_layer->maximum());
 
-  layer_impl_tree_root->ScrollBy(gfx::Vector2d(12, 34));
+  LayerImpl* scroll_layer_impl = layer_impl_tree_root->children()[0];
+  scroll_layer_impl->ScrollBy(gfx::Vector2d(12, 34));
 
   EXPECT_EQ(112.f, cc_scrollbar_layer->current_pos());
   EXPECT_EQ(300, cc_scrollbar_layer->maximum());
 }
 
+#define UPDATE_AND_EXTRACT_LAYER_POINTERS()                         \
+  do {                                                              \
+    scrollbar_layer->UpdateThumbAndTrackGeometry();                 \
+    root_clip_layer_impl = host->CommitAndCreateLayerImplTree();    \
+    root_layer_impl = root_clip_layer_impl->children()[0];          \
+    scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>( \
+        root_layer_impl->children()[1]);                            \
+    scrollbar_layer_impl->ScrollbarParametersDidChange();           \
+  } while (false)
+
 TEST(ScrollbarLayerTest, ThumbRect) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_refptr<Layer> root_clip_layer = Layer::Create();
   scoped_refptr<Layer> root_layer = Layer::Create();
   scoped_refptr<Layer> content_layer = Layer::Create();
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
       FakePaintedScrollbarLayer::Create(false, true, root_layer->id());
 
-  root_layer->SetScrollable(true);
-  root_layer->SetMaxScrollOffset(gfx::Vector2d(80, 0));
+  root_layer->SetScrollClipLayerId(root_clip_layer->id());
+  // Give the root-clip a size that will result in MaxScrollOffset = (80, 0).
+  root_clip_layer->SetBounds(gfx::Size(20, 50));
   root_layer->SetBounds(gfx::Size(100, 50));
   content_layer->SetBounds(gfx::Size(100, 50));
 
-  host->SetRootLayer(root_layer);
+  host->SetRootLayer(root_clip_layer);
+  root_clip_layer->AddChild(root_layer);
   root_layer->AddChild(content_layer);
   root_layer->AddChild(scrollbar_layer);
 
   root_layer->SetScrollOffset(gfx::Vector2d(0, 0));
   scrollbar_layer->SetBounds(gfx::Size(70, 10));
+  scrollbar_layer->SetScrollLayer(root_layer->id());
+  scrollbar_layer->SetClipLayer(root_clip_layer->id());
   scrollbar_layer->fake_scrollbar()->set_location(gfx::Point(20, 10));
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
   scrollbar_layer->fake_scrollbar()->set_thumb_thickness(10);
   scrollbar_layer->fake_scrollbar()->set_thumb_length(4);
   scrollbar_layer->UpdateThumbAndTrackGeometry();
+  LayerImpl* root_clip_layer_impl = NULL;
   LayerImpl* root_layer_impl = NULL;
   PaintedScrollbarLayerImpl* scrollbar_layer_impl = NULL;
 
   // Thumb is at the edge of the scrollbar (should be inset to
   // the start of the track within the scrollbar layer's
   // position).
-  scrollbar_layer->UpdateThumbAndTrackGeometry();
-  root_layer_impl = host->CommitAndCreateLayerImplTree();
-  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      root_layer_impl->children()[1]);
+  UPDATE_AND_EXTRACT_LAYER_POINTERS();
   EXPECT_EQ(gfx::Rect(10, 0, 4, 10).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 
   // Under-scroll (thumb position should clamp and be unchanged).
   root_layer->SetScrollOffset(gfx::Vector2d(-5, 0));
 
-  scrollbar_layer->UpdateThumbAndTrackGeometry();
-  root_layer_impl = host->CommitAndCreateLayerImplTree();
-  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      root_layer_impl->children()[1]);
+  UPDATE_AND_EXTRACT_LAYER_POINTERS();
   EXPECT_EQ(gfx::Rect(10, 0, 4, 10).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 
   // Over-scroll (thumb position should clamp on the far side).
   root_layer->SetScrollOffset(gfx::Vector2d(85, 0));
 
-  scrollbar_layer->UpdateThumbAndTrackGeometry();
-  root_layer_impl = host->CommitAndCreateLayerImplTree();
-  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      root_layer_impl->children()[1]);
+  UPDATE_AND_EXTRACT_LAYER_POINTERS();
   EXPECT_EQ(gfx::Rect(56, 0, 4, 10).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 
   // Change thumb thickness and length.
   scrollbar_layer->fake_scrollbar()->set_thumb_thickness(4);
   scrollbar_layer->fake_scrollbar()->set_thumb_length(6);
 
-  scrollbar_layer->UpdateThumbAndTrackGeometry();
-  root_layer_impl = host->CommitAndCreateLayerImplTree();
-  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      root_layer_impl->children()[1]);
+  UPDATE_AND_EXTRACT_LAYER_POINTERS();
   EXPECT_EQ(gfx::Rect(54, 0, 6, 4).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 
   // Shrink the scrollbar layer to cover only the track.
   scrollbar_layer->SetBounds(gfx::Size(50, 10));
   scrollbar_layer->fake_scrollbar()->set_location(gfx::Point(30, 10));
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
 
-  scrollbar_layer->UpdateThumbAndTrackGeometry();
-  root_layer_impl = host->CommitAndCreateLayerImplTree();
-  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      root_layer_impl->children()[1]);
+  UPDATE_AND_EXTRACT_LAYER_POINTERS();
   EXPECT_EQ(gfx::Rect(44, 0, 6, 4).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 
   // Shrink the track in the non-scrolling dimension so that it only covers the
   // middle third of the scrollbar layer (this does not affect the thumb
   // position).
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 12, 50, 6));
 
-  scrollbar_layer->UpdateThumbAndTrackGeometry();
-  root_layer_impl = host->CommitAndCreateLayerImplTree();
-  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      root_layer_impl->children()[1]);
+  UPDATE_AND_EXTRACT_LAYER_POINTERS();
   EXPECT_EQ(gfx::Rect(44, 0, 6, 4).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 }
 
 TEST(ScrollbarLayerTest, SolidColorDrawQuads) {
   const int kThumbThickness = 3;
   const int kTrackLength = 100;
 
   LayerTreeSettings layer_tree_settings;
   scoped_ptr<FakeLayerTreeHost> host =
@@ skipping 55 matching lines @@
 
 TEST(ScrollbarLayerTest, LayerDrivenSolidColorDrawQuads) {
   const int kThumbThickness = 3;
   const int kTrackLength = 10;
 
   LayerTreeSettings layer_tree_settings;
   scoped_ptr<FakeLayerTreeHost> host =
       FakeLayerTreeHost::Create(layer_tree_settings);
 
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar(false, true, true));
-  LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
-      host.get(), scrollbar.Pass(), false, true, kThumbThickness);
+
+  {
+    scoped_refptr<Layer> layer_tree_root = Layer::Create();
+    scoped_refptr<Layer> scroll_layer = Layer::Create();
+    scroll_layer->SetScrollClipLayerId(layer_tree_root->id());
+    scoped_refptr<Layer> child1 = Layer::Create();
+    scoped_refptr<Layer> child2;
+    const bool kIsLeftSideVerticalScrollbar = false;
+    child2 = SolidColorScrollbarLayer::Create(scrollbar->Orientation(),
+                                              kThumbThickness,
+                                              kIsLeftSideVerticalScrollbar,
+                                              child1->id());
+    child2->ToScrollbarLayer()->SetScrollLayer(scroll_layer->id());
+    child2->ToScrollbarLayer()->SetClipLayer(layer_tree_root->id());
+    scroll_layer->AddChild(child1);
+    scroll_layer->InsertChild(child2, 1);
+    layer_tree_root->AddChild(scroll_layer);
+    host->SetRootLayer(layer_tree_root);
+  }
+  LayerImpl* layer_impl_tree_root = host->CommitAndCreateLayerImplTree();
+  LayerImpl* scroll_layer_impl = layer_impl_tree_root->children()[0];
+
   ScrollbarLayerImplBase* scrollbar_layer_impl =
-      static_cast<PaintedScrollbarLayerImpl*>(
-          layer_impl_tree_root->children()[1]);
+      static_cast<PaintedScrollbarLayerImpl*>(scroll_layer_impl->children()[1]);
+
+  // Choose layer bounds to give max_scroll_offset = (8, 8).
+  layer_impl_tree_root->SetBounds(gfx::Size(2, 2));
+  scroll_layer_impl->SetBounds(gfx::Size(10, 10));
+  scroll_layer_impl->ScrollBy(gfx::Vector2dF(4.f, 0.f));
 
   scrollbar_layer_impl->SetBounds(gfx::Size(kTrackLength, kThumbThickness));
   scrollbar_layer_impl->SetCurrentPos(4.f);
   scrollbar_layer_impl->SetMaximum(8);
 
-  layer_impl_tree_root->SetScrollable(true);
-  layer_impl_tree_root->SetHorizontalScrollbarLayer(scrollbar_layer_impl);
-  layer_impl_tree_root->SetMaxScrollOffset(gfx::Vector2d(8, 8));
-  layer_impl_tree_root->SetBounds(gfx::Size(2, 2));
-  layer_impl_tree_root->ScrollBy(gfx::Vector2dF(4.f, 0.f));
-
   {
     MockQuadCuller quad_culler;
     AppendQuadsData data;
     scrollbar_layer_impl->AppendQuads(&quad_culler, &data);
 
     const QuadList& quads = quad_culler.quad_list();
     ASSERT_EQ(1u, quads.size());
     EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
     EXPECT_RECT_EQ(gfx::Rect(3, 0, 3, 3), quads[0]->rect);
   }
 }
 
 class ScrollbarLayerSolidColorThumbTest : public testing::Test {
  public:
   ScrollbarLayerSolidColorThumbTest() {
     LayerTreeSettings layer_tree_settings;
     host_impl_.reset(new FakeLayerTreeHostImpl(layer_tree_settings, &proxy_));
 
     const int kThumbThickness = 3;
     const bool kIsLeftSideVerticalScrollbar = false;
+    const bool kIsOverlayScrollbar = false;
 
-    horizontal_scrollbar_layer_ = SolidColorScrollbarLayerImpl::Create(
-        host_impl_->active_tree(), 1, HORIZONTAL, kThumbThickness,
-        kIsLeftSideVerticalScrollbar);
-    vertical_scrollbar_layer_ = SolidColorScrollbarLayerImpl::Create(
-        host_impl_->active_tree(), 2, VERTICAL, kThumbThickness,
-        kIsLeftSideVerticalScrollbar);
+    horizontal_scrollbar_layer_ =
+        SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(),
+                                             1,
+                                             HORIZONTAL,
+                                             kThumbThickness,
+                                             kIsLeftSideVerticalScrollbar,
+                                             kIsOverlayScrollbar);
+    vertical_scrollbar_layer_ =
+        SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(),
+                                             2,
+                                             VERTICAL,
+                                             kThumbThickness,
+                                             kIsLeftSideVerticalScrollbar,
+                                             kIsOverlayScrollbar);
   }
 
  protected:
   FakeImplProxy proxy_;
   scoped_ptr<FakeLayerTreeHostImpl> host_impl_;
   scoped_ptr<SolidColorScrollbarLayerImpl> horizontal_scrollbar_layer_;
   scoped_ptr<SolidColorScrollbarLayerImpl> vertical_scrollbar_layer_;
 };
 
 TEST_F(ScrollbarLayerSolidColorThumbTest, SolidColorThumbLength) {
@@ skipping 61 matching lines @@
                  vertical_scrollbar_layer_->ComputeThumbQuadRect());
 }
 
 class ScrollbarLayerTestMaxTextureSize : public LayerTreeTest {
  public:
   ScrollbarLayerTestMaxTextureSize() {}
 
   void SetScrollbarBounds(const gfx::Size& bounds) { bounds_ = bounds; }
 
   virtual void BeginTest() OVERRIDE {
+    scroll_layer_ = Layer::Create();
+    layer_tree_host()->root_layer()->AddChild(scroll_layer_);
+
     scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
-    scrollbar_layer_ = PaintedScrollbarLayer::Create(scrollbar.Pass(), 1);
+    scrollbar_layer_ =
+        PaintedScrollbarLayer::Create(scrollbar.Pass(), scroll_layer_->id());
+    scrollbar_layer_->SetScrollLayer(scroll_layer_->id());
     scrollbar_layer_->SetLayerTreeHost(layer_tree_host());
     scrollbar_layer_->SetBounds(bounds_);
     layer_tree_host()->root_layer()->AddChild(scrollbar_layer_);
 
-    scroll_layer_ = Layer::Create();
-    scrollbar_layer_->SetScrollLayerId(scroll_layer_->id());
-    layer_tree_host()->root_layer()->AddChild(scroll_layer_);
-
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     const int kMaxTextureSize =
         layer_tree_host()->GetRendererCapabilities().max_texture_size;
 
     // Check first that we're actually testing something.
     EXPECT_GT(scrollbar_layer_->bounds().width(), kMaxTextureSize);
 
@@ skipping 111 matching lines @@
                                                       layer_tree_root->id());
     }
     layer_tree_root->AddChild(content_layer);
     layer_tree_root->AddChild(scrollbar_layer);
 
     layer_tree_host_->SetRootLayer(layer_tree_root);
 
     scrollbar_layer->SetIsDrawable(true);
     scrollbar_layer->SetBounds(gfx::Size(100, 100));
     layer_tree_root->SetScrollOffset(gfx::Vector2d(10, 20));
-    layer_tree_root->SetMaxScrollOffset(gfx::Vector2d(30, 50));
     layer_tree_root->SetBounds(gfx::Size(100, 200));
     content_layer->SetBounds(gfx::Size(100, 200));
     scrollbar_layer->draw_properties().content_bounds = gfx::Size(100, 200);
     scrollbar_layer->draw_properties().visible_content_rect =
         gfx::Rect(0, 0, 100, 200);
     scrollbar_layer->CreateRenderSurface();
     scrollbar_layer->draw_properties().render_target = scrollbar_layer.get();
 
     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
     EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
@@ skipping 116 matching lines @@
 TEST_F(ScaledScrollbarLayerTestResourceCreation, ScaledResourceUpload) {
   // Pick a test scale that moves the scrollbar's (non-zero) position to
   // a non-pixel-aligned location.
   TestResourceUpload(.041f);
   TestResourceUpload(1.41f);
   TestResourceUpload(4.1f);
 }
 
 }  // namespace
 }  // namespace cc