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 79 matching lines @@
 
 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()->SetScrollOffset(initial_scroll_);
+    layer_tree_host()->root_layer()->SetBounds(gfx::Size(200, 200));
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     Layer* root = layer_tree_host()->root_layer();
     switch (layer_tree_host()->commit_number()) {
       case 0:
         EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
         break;
       case 1:
@@ skipping 121 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_) {
+      // 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));
     root_scroll_layer_->AddChild(child_layer_);
 
     if (scroll_child_layer_) {
       expected_scroll_layer_ = child_layer_;
       expected_no_scroll_layer_ = root_scroll_layer_;
@@ skipping 70 matching lines @@
                    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::ToCeiledPoint(expected_scroll_layer_impl->position() -
                                gfx::Vector2dF(0.5f, 0.5f)),
             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_,
@@ skipping 483 matching lines @@
     RunTest(true, false, false);
 }
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyWholeTree) {
     scroll_destroy_whole_tree_ = true;
     RunTest(true, false, false);
 }
 
 }  // namespace
 }  // namespace cc