Pinch/Zoom Infrastructure & Plumbing CL

cc/trees/layer_tree_host_unittest_scroll.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/memory/weak_ptr.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 13 matching lines @@
 
 class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollSimple()
       : initial_scroll_(10, 20),
         second_scroll_(40, 5),
         scroll_amount_(2, -1),
         num_scrolls_(0) {}
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->root_layer()->SetScrollable(true);
-    layer_tree_host()->root_layer()
-        ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+//    layer_tree_host()->root_layer()->SetScrollable(true);  // WJM
+//    layer_tree_host()->root_layer()
+//        ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     layer_tree_host()->root_layer()->SetScrollOffset(initial_scroll_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void Layout() OVERRIDE {
     Layer* root = layer_tree_host()->root_layer();
     if (!layer_tree_host()->source_frame_number()) {
       EXPECT_VECTOR_EQ(initial_scroll_, root->scroll_offset());
     } else {
       EXPECT_VECTOR_EQ(initial_scroll_ + scroll_amount_, root->scroll_offset());
 
       // Pretend like Javascript updated the scroll position itself.
       root->SetScrollOffset(second_scroll_);
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root = impl->active_tree()->root_layer();
     EXPECT_VECTOR_EQ(gfx::Vector2d(), root->ScrollDelta());
 
-    root->SetScrollable(true);
-    root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+//    root->SetScrollable(true);  // WJM
+//    root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     root->ScrollBy(scroll_amount_);
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_VECTOR_EQ(initial_scroll_, root->scroll_offset());
         EXPECT_VECTOR_EQ(scroll_amount_, root->ScrollDelta());
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
         EXPECT_VECTOR_EQ(root->scroll_offset(), second_scroll_);
@@ skipping 19 matching lines @@
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollSimple);
 
 class LayerTreeHostScrollTestScrollMultipleRedraw
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollMultipleRedraw()
       : initial_scroll_(40, 10), scroll_amount_(-3, 17), num_scrolls_(0) {}
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->root_layer()->SetScrollable(true);
+//    layer_tree_host()->root_layer()->SetScrollable(true);  // WJM
     layer_tree_host()->root_layer()->SetScrollOffset(initial_scroll_);
     layer_tree_host()->root_layer()->SetBounds(gfx::Size(200, 200));
-    layer_tree_host()->root_layer()
-        ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+//    layer_tree_host()->root_layer()
+//        ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     Layer* root = layer_tree_host()->root_layer();
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
         break;
       case 1:
@@ skipping 64 matching lines @@
         num_will_commits_(0),
         num_did_commits_(0),
         num_impl_commits_(0),
         num_impl_scrolls_(0) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void SetupTree() OVERRIDE {
     LayerTreeHostScrollTest::SetupTree();
     scoped_refptr<Layer> root_scroll_layer = Layer::Create();
-    root_scroll_layer->SetScrollable(true);
+//    root_scroll_layer->SetScrollable(true);  // WJM
     root_scroll_layer->SetScrollOffset(initial_scroll_);
     root_scroll_layer->SetBounds(gfx::Size(200, 200));
-    root_scroll_layer->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+//    root_scroll_layer->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     root_scroll_layer->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(root_scroll_layer);
 
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
   }
 
   virtual void WillBeginMainFrame() OVERRIDE {
     num_will_begin_main_frames_++;
     Layer* root_scroll_layer = layer_tree_host()->root_layer()->children()[0];
     switch (num_will_begin_main_frames_) {
@@ skipping 137 matching lines @@
   int num_impl_scrolls_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollAbortedCommit);
 
 class LayerTreeHostScrollTestFractionalScroll : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestFractionalScroll() : scroll_amount_(1.75, 0) {}
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->root_layer()->SetScrollable(true);
-    layer_tree_host()->root_layer()
-        ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+//    layer_tree_host()->root_layer()->SetScrollable(true); // WJM
+//    layer_tree_host()->root_layer()
+//        ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root = impl->active_tree()->root_layer();
 
     // Check that a fractional scroll delta is correctly accumulated over
     // multiple commits.
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
@@ skipping 43 matching lines @@
     scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetBounds(gfx::Size(10, 10));
 
     root_scroll_layer_ = ContentLayer::Create(&fake_content_layer_client_);
     root_scroll_layer_->SetBounds(gfx::Size(110, 110));
 
     root_scroll_layer_->SetPosition(gfx::Point());
     root_scroll_layer_->SetAnchorPoint(gfx::PointF());
 
     root_scroll_layer_->SetIsDrawable(true);
-    root_scroll_layer_->SetScrollable(true);
-    root_scroll_layer_->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+//    root_scroll_layer_->SetScrollable(true);  // WJM
+//    root_scroll_layer_->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     root_layer->AddChild(root_scroll_layer_);
 
     child_layer_ = ContentLayer::Create(&fake_content_layer_client_);
     child_layer_->set_did_scroll_callback(
         base::Bind(&LayerTreeHostScrollTestCaseWithChild::DidScroll,
                    base::Unretained(this)));
     child_layer_->SetBounds(gfx::Size(110, 110));
 
     if (scroll_child_layer_) {
       // Scrolls on the child layer will happen at 5, 5. If they are treated
       // like device pixels, and device scale factor is 2, then they will
       // be considered at 2.5, 2.5 in logical pixels, and will miss this layer.
       child_layer_->SetPosition(gfx::Point(5, 5));
     } else {
       // Adjust the child layer horizontally so that scrolls will never hit it.
       child_layer_->SetPosition(gfx::Point(60, 5));
     }
     child_layer_->SetAnchorPoint(gfx::PointF());
 
     child_layer_->SetIsDrawable(true);
-    child_layer_->SetScrollable(true);
-    child_layer_->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+//    child_layer_->SetScrollable(true);  // WJM
+//    child_layer_->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     root_scroll_layer_->AddChild(child_layer_);
 
     if (scroll_child_layer_) {
       expected_scroll_layer_ = child_layer_;
       expected_no_scroll_layer_ = root_scroll_layer_;
     } else {
       expected_scroll_layer_ = root_scroll_layer_;
       expected_no_scroll_layer_ = child_layer_;
     }
 
@@ skipping 270 matching lines @@
 class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
  public:
   ImplSidePaintingScrollTestSimple()
       : initial_scroll_(10, 20),
         main_thread_scroll_(40, 5),
         impl_thread_scroll1_(2, -1),
         impl_thread_scroll2_(-3, 10),
         num_scrolls_(0) {}
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->root_layer()->SetScrollable(true);
-    layer_tree_host()->root_layer()
-        ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+//    layer_tree_host()->root_layer()->SetScrollable(true);  // WJM
+//    layer_tree_host()->root_layer()
+//        ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     layer_tree_host()->root_layer()->SetScrollOffset(initial_scroll_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void Layout() OVERRIDE {
     Layer* root = layer_tree_host()->root_layer();
     if (!layer_tree_host()->source_frame_number()) {
       EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
     } else {
       EXPECT_VECTOR_EQ(root->scroll_offset(),
@@ skipping 85 matching lines @@
 // beginning a commit and finishing a commit (aka scroll deltas not
 // included in sent scroll delta) still apply to layers that don't
 // push properties.
 class ImplSidePaintingScrollTestImplOnlyScroll
     : public ImplSidePaintingScrollTest {
  public:
   ImplSidePaintingScrollTestImplOnlyScroll()
       : initial_scroll_(20, 10), impl_thread_scroll_(-2, 3) {}
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->root_layer()->SetScrollable(true);
-    layer_tree_host()->root_layer()->SetMaxScrollOffset(
-        gfx::Vector2d(100, 100));
+//    layer_tree_host()->root_layer()->SetScrollable(true); // WJM
+//    layer_tree_host()->root_layer()->SetMaxScrollOffset(
+//        gfx::Vector2d(100, 100));
     layer_tree_host()->root_layer()->SetScrollOffset(initial_scroll_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void WillCommit() OVERRIDE {
     Layer* root = layer_tree_host()->root_layer();
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         EXPECT_TRUE(root->needs_push_properties());
         break;
@@ skipping 83 matching lines @@
 
 class LayerTreeHostScrollTestScrollZeroMaxScrollOffset
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollZeroMaxScrollOffset() {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root = impl->active_tree()->root_layer();
-    root->SetScrollable(true);
+//    root->SetScrollable(true);  // WJM
 
-    root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+//    root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     EXPECT_EQ(InputHandler::ScrollStarted,
               root->TryScroll(gfx::PointF(0.0f, 1.0f), InputHandler::Gesture));
 
-    root->SetMaxScrollOffset(gfx::Vector2d(0, 0));
+//    root->SetMaxScrollOffset(gfx::Vector2d(0, 0));
     EXPECT_EQ(InputHandler::ScrollIgnored,
               root->TryScroll(gfx::PointF(0.0f, 1.0f), InputHandler::Gesture));
 
-    root->SetMaxScrollOffset(gfx::Vector2d(-100, -100));
+//    root->SetMaxScrollOffset(gfx::Vector2d(-100, -100));
     EXPECT_EQ(InputHandler::ScrollIgnored,
               root->TryScroll(gfx::PointF(0.0f, 1.0f), InputHandler::Gesture));
 
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ skipping 123 matching lines @@
     Layer* layer_;
   };
 
   Layer* CreateScrollLayer(Layer* parent, FakeLayerScrollClient* client) {
     scoped_refptr<Layer> scroll_layer =
         ContentLayer::Create(&fake_content_layer_client_);
     scroll_layer->SetBounds(gfx::Size(110, 110));
     scroll_layer->SetPosition(gfx::Point(0, 0));
     scroll_layer->SetAnchorPoint(gfx::PointF());
     scroll_layer->SetIsDrawable(true);
-    scroll_layer->SetScrollable(true);
-    scroll_layer->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+//    scroll_layer->SetScrollable(true);  // WJM
+//    scroll_layer->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     scroll_layer->set_did_scroll_callback(base::Bind(
         &FakeLayerScrollClient::DidScroll, base::Unretained(client)));
     client->owner_ = this;
     client->layer_ = scroll_layer.get();
     parent->AddChild(scroll_layer);
     return scroll_layer.get();
   }
 
   FakeLayerScrollClient root_scroll_layer_client_;
   FakeLayerScrollClient sibling_scroll_layer_client_;
   FakeLayerScrollClient child_scroll_layer_client_;
 
   FakeContentLayerClient fake_content_layer_client_;
 
   bool scroll_destroy_whole_tree_;
 };
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyLayer) {
     RunTest(true, false, false);
 }
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyWholeTree) {
     scroll_destroy_whole_tree_ = true;
     RunTest(true, false, false);
 }
 
 }  // namespace
 }  // namespace cc