cc: Consider scroll offset in CalcDrawProperties

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 122 matching lines @@
     } else if (impl->active_tree()->source_frame_number() == 0 &&
                impl->SourceAnimationFrameNumber() == 2) {
       // Second draw after first commit.
       EXPECT_EQ(root->ScrollDelta(), scroll_amount_);
       root->ScrollBy(scroll_amount_);
       EXPECT_VECTOR_EQ(root->ScrollDelta(), scroll_amount_ + scroll_amount_);
 
       EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
       PostSetNeedsCommitToMainThread();
     } else if (impl->active_tree()->source_frame_number() == 1) {
-      // Third or later draw after second commit.
-      EXPECT_GE(impl->SourceAnimationFrameNumber(), 3);
+      // Any draw after second commit.  The animation frame may not update
+      // if no damage occurs here and the draw is skipped.
+      EXPECT_GE(impl->SourceAnimationFrameNumber(), 2);

[danakj, 2013/07/08 21:53:42]

Does this mean we do the above elseif{} block (sourceframe=0,
sourceanimationframe=2) and then also this block (sourceframe=1,
sourceanimationframe=2)? Ie, new source frame, but the source animation frame
number didn't change?

Or is the block above being skipped and some of this test isn't testing
anything?

[enne (OOO), 2013/07/08 22:03:46]

All three blocks run in order on different "draws".  The third time the draw may
not occur because there's no damage, as the comment implies.  I could force some
damage if you think that'd make it clearer.
Nope.  The above block is also running.

[enne (OOO), 2013/07/09 00:49:45]

I fixed this case by resizing the root.  Now that scroll offsets move layers
(via the large initial scroll offset in this test), this layer got scrolled
offscreen and so its damage no longer affected the viewport.

       EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d());
       EXPECT_VECTOR_EQ(root->scroll_offset(),
                        initial_scroll_ + scroll_amount_ + scroll_amount_);
       EndTest();
     }
   }
 
   virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta, float scale)
       OVERRIDE {
     gfx::Vector2d offset = layer_tree_host()->root_layer()->scroll_offset();
@@ skipping 76 matching lines @@
 
   virtual void SetupTree() OVERRIDE {
     layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
 
     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(0, 0));
+    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_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));
 
-    // 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));
+    if (scroll_child_layer_) {
+      child_layer_->SetPosition(gfx::Point());
+    } else {
+      // Offset the child layer further than the sum of all scrolls so that
+      // scrolls beginning at the viewport origin will always hit the root.
+      child_layer_->SetPosition(gfx::Point(60, 60));
+      EXPECT_GT(child_layer_->position().x(),
+                (initial_offset_ + javascript_scroll_).x());
+      EXPECT_GT(child_layer_->position().y(),
+                (initial_offset_ + javascript_scroll_).y());
+    }
     child_layer_->SetAnchorPoint(gfx::PointF());
 
     child_layer_->SetIsDrawable(true);
     child_layer_->SetScrollable(true);
     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_;
@@ skipping 69 matching lines @@
     EXPECT_SIZE_EQ(expected_content_bounds,
                    root_scroll_layer_->content_bounds());
 
     expected_content_bounds = gfx::ToCeiledSize(
         gfx::ScaleSize(child_layer_impl->bounds(), device_scale_factor_));
     EXPECT_SIZE_EQ(expected_content_bounds, child_layer_->content_bounds());
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0: {
         // Gesture scroll on impl thread.
-        InputHandler::ScrollStatus status = impl->ScrollBegin(
-            gfx::ToCeiledPoint(expected_scroll_layer_impl->position() +
-                               gfx::Vector2dF(0.5f, 0.5f)),
-            InputHandler::Gesture);
+        InputHandler::ScrollStatus status =
+            impl->ScrollBegin(gfx::Point(), InputHandler::Gesture);
         EXPECT_EQ(InputHandler::ScrollStarted, status);
         impl->ScrollBy(gfx::Point(), scroll_amount_);
         impl->ScrollEnd();
 
         // Check the scroll is applied as a delta.
         EXPECT_VECTOR_EQ(initial_offset_,
                          expected_scroll_layer_impl->scroll_offset());
         EXPECT_VECTOR_EQ(scroll_amount_,
                          expected_scroll_layer_impl->ScrollDelta());
         break;
       }
       case 1: {
         // Wheel scroll on impl thread.
-        InputHandler::ScrollStatus status = impl->ScrollBegin(
-            gfx::ToCeiledPoint(expected_scroll_layer_impl->position() +
-                               gfx::Vector2dF(0.5f, 0.5f)),
-            InputHandler::Wheel);
+        InputHandler::ScrollStatus status =
+            impl->ScrollBegin(gfx::Point(), InputHandler::Wheel);
         EXPECT_EQ(InputHandler::ScrollStarted, status);
         impl->ScrollBy(gfx::Point(), scroll_amount_);
         impl->ScrollEnd();
 
         // Check the scroll is applied as a delta.
         EXPECT_VECTOR_EQ(javascript_scroll_,
                          expected_scroll_layer_impl->scroll_offset());
         EXPECT_VECTOR_EQ(scroll_amount_,
                          expected_scroll_layer_impl->ScrollDelta());
         break;
@@ skipping 464 matching lines @@
     RunTest(true, false, false);
 }
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyWholeTree) {
     scroll_destroy_whole_tree_ = true;
     RunTest(true, false, false);
 }
 
 }  // namespace
 }  // namespace cc