cc/trees/layer_tree_host_unittest_scroll.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/trees/layer_tree_host.h"
   6
   7 #include "base/memory/weak_ptr.h"
   8 #include "cc/layers/layer.h"
   9 #include "cc/layers/layer_impl.h"
  10 #include "cc/layers/picture_layer.h"
  11 #include "cc/test/fake_content_layer_client.h"
  12 #include "cc/test/fake_layer_tree_host_client.h"
  13 #include "cc/test/fake_picture_layer.h"
  14 #include "cc/test/fake_picture_layer_impl.h"
  15 #include "cc/test/geometry_test_utils.h"
  16 #include "cc/test/layer_tree_test.h"
  17 #include "cc/test/test_shared_bitmap_manager.h"
  18 #include "cc/trees/layer_tree_impl.h"
  19 #include "ui/gfx/point_conversions.h"
  20 #include "ui/gfx/size_conversions.h"
  21 #include "ui/gfx/vector2d_conversions.h"
  22
  23 namespace cc {
  24 namespace {
  25
  26 class LayerTreeHostScrollTest : public LayerTreeTest {};
  27
  28 class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
  29  public:
  30   LayerTreeHostScrollTestScrollSimple()
  31       : initial_scroll_(10, 20),
  32         second_scroll_(40, 5),
  33         scroll_amount_(2, -1),
  34         num_scrolls_(0) {}
  35
  36   virtual void BeginTest() OVERRIDE {
  37     Layer* root_layer = layer_tree_host()->root_layer();
  38     scoped_refptr<Layer> scroll_layer = Layer::Create();
  39     root_layer->AddChild(scroll_layer);
  40     // Create an effective max_scroll_offset of (100, 100).
  41     scroll_layer->SetBounds(gfx::Size(root_layer->bounds().width() + 100,
  42                                       root_layer->bounds().height() + 100));
  43     scroll_layer->SetIsDrawable(true);
  44     scroll_layer->SetIsContainerForFixedPositionLayers(true);
  45     scroll_layer->SetScrollClipLayerId(root_layer->id());
  46     scroll_layer->SetScrollOffset(initial_scroll_);
  47     layer_tree_host()->RegisterViewportLayers(root_layer, scroll_layer, NULL);
  48     PostSetNeedsCommitToMainThread();
  49   }
  50
  51   virtual void Layout() OVERRIDE {
  52     Layer* root = layer_tree_host()->root_layer();
  53     Layer* scroll_layer = root->children()[0].get();
  54     if (!layer_tree_host()->source_frame_number()) {
  55       EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
  56     } else {
  57       EXPECT_VECTOR_EQ(initial_scroll_ + scroll_amount_,
  58                        scroll_layer->scroll_offset());
  59
  60       // Pretend like Javascript updated the scroll position itself.
  61       scroll_layer->SetScrollOffset(second_scroll_);
  62     }
  63   }
  64
  65   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
  66     LayerImpl* root = impl->active_tree()->root_layer();
  67     LayerImpl* scroll_layer = root->children()[0];
  68     EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());
  69
  70     scroll_layer->SetScrollClipLayer(root->id());
  71     scroll_layer->SetBounds(
  72         gfx::Size(root->bounds().width() + 100, root->bounds().height() + 100));
  73     scroll_layer->ScrollBy(scroll_amount_);
  74
  75     switch (impl->active_tree()->source_frame_number()) {
  76       case 0:
  77         EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
  78         EXPECT_VECTOR_EQ(scroll_amount_, scroll_layer->ScrollDelta());
  79         PostSetNeedsCommitToMainThread();
  80         break;
  81       case 1:
  82         EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), second_scroll_);
  83         EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
  84         EndTest();
  85         break;
  86     }
  87   }
  88
  89   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
  90                                    float scale,
  91                                    float top_controls_delta) OVERRIDE {
  92     num_scrolls_++;
  93   }
  94
  95   virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }
  96
  97  private:
  98   gfx::Vector2d initial_scroll_;
  99   gfx::Vector2d second_scroll_;
 100   gfx::Vector2d scroll_amount_;
 101   int num_scrolls_;
 102 };
 103
 104 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollSimple);
 105
 106 class LayerTreeHostScrollTestScrollMultipleRedraw
 107     : public LayerTreeHostScrollTest {
 108  public:
 109   LayerTreeHostScrollTestScrollMultipleRedraw()
 110       : initial_scroll_(40, 10), scroll_amount_(-3, 17), num_scrolls_(0) {}
 111
 112   virtual void BeginTest() OVERRIDE {
 113     Layer* root_layer = layer_tree_host()->root_layer();
 114     scroll_layer_ = Layer::Create();
 115     root_layer->AddChild(scroll_layer_);
 116     // Create an effective max_scroll_offset of (100, 100).
 117     scroll_layer_->SetBounds(gfx::Size(root_layer->bounds().width() + 100,
 118                                        root_layer->bounds().height() + 100));
 119     scroll_layer_->SetIsDrawable(true);
 120     scroll_layer_->SetIsContainerForFixedPositionLayers(true);
 121     scroll_layer_->SetScrollClipLayerId(root_layer->id());
 122     scroll_layer_->SetScrollOffset(initial_scroll_);
 123     layer_tree_host()->RegisterViewportLayers(root_layer, scroll_layer_, NULL);
 124     PostSetNeedsCommitToMainThread();
 125   }
 126
 127   virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 128     switch (layer_tree_host()->source_frame_number()) {
 129       case 0:
 130         EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(), initial_scroll_);
 131         break;
 132       case 1:
 133         EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(),
 134                          initial_scroll_ + scroll_amount_ + scroll_amount_);
 135       case 2:
 136         EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(),
 137                          initial_scroll_ + scroll_amount_ + scroll_amount_);
 138         break;
 139     }
 140   }
 141
 142   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 143     LayerImpl* scroll_layer =
 144         impl->active_tree()->LayerById(scroll_layer_->id());
 145     if (impl->active_tree()->source_frame_number() == 0 &&
 146         impl->SourceAnimationFrameNumber() == 1) {
 147       // First draw after first commit.
 148       EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());
 149       scroll_layer->ScrollBy(scroll_amount_);
 150       EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
 151
 152       EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
 153       PostSetNeedsRedrawToMainThread();
 154     } else if (impl->active_tree()->source_frame_number() == 0 &&
 155                impl->SourceAnimationFrameNumber() == 2) {
 156       // Second draw after first commit.
 157       EXPECT_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
 158       scroll_layer->ScrollBy(scroll_amount_);
 159       EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),
 160                        scroll_amount_ + scroll_amount_);
 161
 162       EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(), initial_scroll_);
 163       PostSetNeedsCommitToMainThread();
 164     } else if (impl->active_tree()->source_frame_number() == 1) {
 165       // Third or later draw after second commit.
 166       EXPECT_GE(impl->SourceAnimationFrameNumber(), 3);
 167       EXPECT_VECTOR_EQ(scroll_layer_->ScrollDelta(), gfx::Vector2d());
 168       EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(),
 169                        initial_scroll_ + scroll_amount_ + scroll_amount_);
 170       EndTest();
 171     }
 172   }
 173
 174   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
 175                                    float scale,
 176                                    float top_controls_delta) OVERRIDE {
 177     num_scrolls_++;
 178   }
 179
 180   virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }
 181
 182  private:
 183   gfx::Vector2d initial_scroll_;
 184   gfx::Vector2d scroll_amount_;
 185   int num_scrolls_;
 186   scoped_refptr<Layer> scroll_layer_;
 187 };
 188
 189 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollMultipleRedraw);
 190
 191 class LayerTreeHostScrollTestScrollAbortedCommit
 192     : public LayerTreeHostScrollTest {
 193  public:
 194   LayerTreeHostScrollTestScrollAbortedCommit()
 195       : initial_scroll_(50, 60),
 196         impl_scroll_(-3, 2),
 197         second_main_scroll_(14, -3),
 198         impl_scale_(2.f),
 199         num_will_begin_main_frames_(0),
 200         num_did_begin_main_frames_(0),
 201         num_will_commits_(0),
 202         num_did_commits_(0),
 203         num_impl_commits_(0),
 204         num_impl_scrolls_(0) {}
 205
 206   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 207
 208   virtual void SetupTree() OVERRIDE {
 209     LayerTreeHostScrollTest::SetupTree();
 210     Layer* root_layer = layer_tree_host()->root_layer();
 211     scoped_refptr<Layer> root_scroll_layer = Layer::Create();
 212     root_scroll_layer->SetScrollClipLayerId(root_layer->id());
 213     root_scroll_layer->SetScrollOffset(initial_scroll_);
 214     root_scroll_layer->SetBounds(gfx::Size(200, 200));
 215     root_scroll_layer->SetIsDrawable(true);
 216     root_scroll_layer->SetIsContainerForFixedPositionLayers(true);
 217     root_layer->AddChild(root_scroll_layer);
 218
 219     layer_tree_host()->RegisterViewportLayers(
 220         root_layer, root_scroll_layer, NULL);
 221     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
 222   }
 223
 224   virtual void WillBeginMainFrame() OVERRIDE {
 225     num_will_begin_main_frames_++;
 226     Layer* root_scroll_layer =
 227         layer_tree_host()->root_layer()->children()[0].get();
 228     switch (num_will_begin_main_frames_) {
 229       case 1:
 230         // This will not be aborted because of the initial prop changes.
 231         EXPECT_EQ(0, num_impl_scrolls_);
 232         EXPECT_EQ(0, layer_tree_host()->source_frame_number());
 233         EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(), initial_scroll_);
 234         EXPECT_EQ(1.f, layer_tree_host()->page_scale_factor());
 235         break;
 236       case 2:
 237         // This commit will be aborted, and another commit will be
 238         // initiated from the redraw.
 239         EXPECT_EQ(1, num_impl_scrolls_);
 240         EXPECT_EQ(1, layer_tree_host()->source_frame_number());
 241         EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
 242                          initial_scroll_ + impl_scroll_);
 243         EXPECT_EQ(impl_scale_, layer_tree_host()->page_scale_factor());
 244         PostSetNeedsRedrawToMainThread();
 245         break;
 246       case 3:
 247         // This commit will not be aborted because of the scroll change.
 248         EXPECT_EQ(2, num_impl_scrolls_);
 249         // The source frame number still increases even with the abort.
 250         EXPECT_EQ(2, layer_tree_host()->source_frame_number());
 251         EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
 252                          initial_scroll_ + impl_scroll_ + impl_scroll_);
 253         EXPECT_EQ(impl_scale_ * impl_scale_,
 254                   layer_tree_host()->page_scale_factor());
 255         root_scroll_layer->SetScrollOffset(root_scroll_layer->scroll_offset() +
 256                                            second_main_scroll_);
 257         break;
 258       case 4:
 259         // This commit will also be aborted.
 260         EXPECT_EQ(3, num_impl_scrolls_);
 261         EXPECT_EQ(3, layer_tree_host()->source_frame_number());
 262         EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
 263                          initial_scroll_ + impl_scroll_ + impl_scroll_ +
 264                              impl_scroll_ + second_main_scroll_);
 265         // End the test by drawing to verify this commit is also aborted.
 266         PostSetNeedsRedrawToMainThread();
 267         break;
 268     }
 269   }
 270
 271   virtual void DidBeginMainFrame() OVERRIDE { num_did_begin_main_frames_++; }
 272
 273   virtual void WillCommit() OVERRIDE { num_will_commits_++; }
 274
 275   virtual void DidCommit() OVERRIDE { num_did_commits_++; }
 276
 277   virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 278     num_impl_commits_++;
 279   }
 280
 281   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 282     LayerImpl* root_scroll_layer =
 283         impl->active_tree()->root_layer()->children()[0];
 284
 285     if (impl->active_tree()->source_frame_number() == 0 &&
 286         impl->SourceAnimationFrameNumber() == 1) {
 287       // First draw
 288       EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());
 289       root_scroll_layer->ScrollBy(impl_scroll_);
 290       EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);
 291       EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(), initial_scroll_);
 292
 293       EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
 294       EXPECT_EQ(1.f, impl->active_tree()->total_page_scale_factor());
 295       impl->active_tree()->SetPageScaleDelta(impl_scale_);
 296       EXPECT_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
 297       EXPECT_EQ(impl_scale_, impl->active_tree()->total_page_scale_factor());
 298
 299       // To simplify the testing flow, don't redraw here, just commit.
 300       impl->SetNeedsCommit();
 301     } else if (impl->active_tree()->source_frame_number() == 0 &&
 302                impl->SourceAnimationFrameNumber() == 2) {
 303       // Test a second draw after an aborted commit.
 304       // The scroll/scale values should be baked into the offset/scale factor
 305       // since the main thread consumed but aborted the begin frame.
 306       EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());
 307       root_scroll_layer->ScrollBy(impl_scroll_);
 308       EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);
 309       EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
 310                        initial_scroll_ + impl_scroll_);
 311
 312       EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
 313       EXPECT_EQ(impl_scale_, impl->active_tree()->total_page_scale_factor());
 314       impl->active_tree()->SetPageScaleDelta(impl_scale_);
 315       EXPECT_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
 316       EXPECT_EQ(impl_scale_ * impl_scale_,
 317                 impl->active_tree()->total_page_scale_factor());
 318
 319       impl->SetNeedsCommit();
 320     } else if (impl->active_tree()->source_frame_number() == 1) {
 321       // Commit for source frame 1 is aborted.
 322       NOTREACHED();
 323     } else if (impl->active_tree()->source_frame_number() == 2 &&
 324                impl->SourceAnimationFrameNumber() == 3) {
 325       // Third draw after the second full commit.
 326       EXPECT_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());
 327       root_scroll_layer->ScrollBy(impl_scroll_);
 328       impl->SetNeedsCommit();
 329       EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);
 330       EXPECT_VECTOR_EQ(
 331           root_scroll_layer->scroll_offset(),
 332           initial_scroll_ + impl_scroll_ + impl_scroll_ + second_main_scroll_);
 333     } else if (impl->active_tree()->source_frame_number() == 2 &&
 334                impl->SourceAnimationFrameNumber() == 4) {
 335       // Final draw after the second aborted commit.
 336       EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());
 337       EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
 338                        initial_scroll_ + impl_scroll_ + impl_scroll_ +
 339                            impl_scroll_ + second_main_scroll_);
 340       EndTest();
 341     } else {
 342       // Commit for source frame 3 is aborted.
 343       NOTREACHED();
 344     }
 345   }
 346
 347   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
 348                                    float scale,
 349                                    float top_controls_delta) OVERRIDE {
 350     num_impl_scrolls_++;
 351   }
 352
 353   virtual void AfterTest() OVERRIDE {
 354     EXPECT_EQ(3, num_impl_scrolls_);
 355     // Verify that the embedder sees aborted commits as real commits.
 356     EXPECT_EQ(4, num_will_begin_main_frames_);
 357     EXPECT_EQ(4, num_did_begin_main_frames_);
 358     EXPECT_EQ(4, num_will_commits_);
 359     EXPECT_EQ(4, num_did_commits_);
 360     // ...but the compositor thread only sees two real ones.
 361     EXPECT_EQ(2, num_impl_commits_);
 362   }
 363
 364  private:
 365   gfx::Vector2d initial_scroll_;
 366   gfx::Vector2d impl_scroll_;
 367   gfx::Vector2d second_main_scroll_;
 368   float impl_scale_;
 369   int num_will_begin_main_frames_;
 370   int num_did_begin_main_frames_;
 371   int num_will_commits_;
 372   int num_did_commits_;
 373   int num_impl_commits_;
 374   int num_impl_scrolls_;
 375 };
 376
 377 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollAbortedCommit);
 378
 379 class LayerTreeHostScrollTestFractionalScroll : public LayerTreeHostScrollTest {
 380  public:
 381   LayerTreeHostScrollTestFractionalScroll() : scroll_amount_(1.75, 0) {}
 382
 383   virtual void SetupTree() OVERRIDE {
 384     LayerTreeHostScrollTest::SetupTree();
 385     Layer* root_layer = layer_tree_host()->root_layer();
 386     scoped_refptr<Layer> root_scroll_layer = Layer::Create();
 387     root_scroll_layer->SetScrollClipLayerId(root_layer->id());
 388     root_scroll_layer->SetBounds(
 389         gfx::Size(root_layer->bounds().width() + 100,
 390                   root_layer->bounds().height() + 100));
 391     root_scroll_layer->SetIsDrawable(true);
 392     root_scroll_layer->SetIsContainerForFixedPositionLayers(true);
 393     root_layer->AddChild(root_scroll_layer);
 394
 395     layer_tree_host()->RegisterViewportLayers(
 396         root_layer, root_scroll_layer, NULL);
 397     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
 398   }
 399
 400   virtual void BeginTest() OVERRIDE {
 401     PostSetNeedsCommitToMainThread();
 402   }
 403
 404   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 405     LayerImpl* root = impl->active_tree()->root_layer();
 406     LayerImpl* scroll_layer = root->children()[0];
 407
 408     // Check that a fractional scroll delta is correctly accumulated over
 409     // multiple commits.
 410     switch (impl->active_tree()->source_frame_number()) {
 411       case 0:
 412         EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), gfx::Vector2d(0, 0));
 413         EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d(0, 0));
 414         PostSetNeedsCommitToMainThread();
 415         break;
 416       case 1:
 417         EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(),
 418                          gfx::ToFlooredVector2d(scroll_amount_));
 419         EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),
 420                          gfx::Vector2dF(fmod(scroll_amount_.x(), 1.0f), 0.0f));
 421         PostSetNeedsCommitToMainThread();
 422         break;
 423       case 2:
 424         EXPECT_VECTOR_EQ(
 425             scroll_layer->scroll_offset(),
 426             gfx::ToFlooredVector2d(scroll_amount_ + scroll_amount_));
 427         EXPECT_VECTOR_EQ(
 428             scroll_layer->ScrollDelta(),
 429             gfx::Vector2dF(fmod(2.0f * scroll_amount_.x(), 1.0f), 0.0f));
 430         EndTest();
 431         break;
 432     }
 433     scroll_layer->ScrollBy(scroll_amount_);
 434   }
 435
 436   virtual void AfterTest() OVERRIDE {}
 437
 438  private:
 439   gfx::Vector2dF scroll_amount_;
 440 };
 441
 442 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestFractionalScroll);
 443
 444 class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {
 445  public:
 446   LayerTreeHostScrollTestCaseWithChild()
 447       : initial_offset_(10, 20),
 448         javascript_scroll_(40, 5),
 449         scroll_amount_(2, -1),
 450         num_scrolls_(0) {}
 451
 452   virtual void SetupTree() OVERRIDE {
 453     layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
 454
 455     scoped_refptr<Layer> root_layer = Layer::Create();
 456     root_layer->SetBounds(gfx::Size(10, 10));
 457
 458     root_scroll_layer_ = FakePictureLayer::Create(&fake_content_layer_client_);
 459     root_scroll_layer_->SetBounds(gfx::Size(110, 110));
 460
 461     root_scroll_layer_->SetPosition(gfx::Point());
 462
 463     root_scroll_layer_->SetIsDrawable(true);
 464     root_scroll_layer_->SetScrollClipLayerId(root_layer->id());
 465     root_scroll_layer_->SetIsContainerForFixedPositionLayers(true);
 466     root_layer->AddChild(root_scroll_layer_);
 467
 468     child_layer_ = FakePictureLayer::Create(&fake_content_layer_client_);
 469     child_layer_->set_did_scroll_callback(
 470         base::Bind(&LayerTreeHostScrollTestCaseWithChild::DidScroll,
 471                    base::Unretained(this)));
 472     child_layer_->SetBounds(gfx::Size(110, 110));
 473
 474     if (scroll_child_layer_) {
 475       // Scrolls on the child layer will happen at 5, 5. If they are treated
 476       // like device pixels, and device scale factor is 2, then they will
 477       // be considered at 2.5, 2.5 in logical pixels, and will miss this layer.
 478       child_layer_->SetPosition(gfx::Point(5, 5));
 479     } else {
 480       // Adjust the child layer horizontally so that scrolls will never hit it.
 481       child_layer_->SetPosition(gfx::Point(60, 5));
 482     }
 483
 484     child_layer_->SetIsDrawable(true);
 485     child_layer_->SetScrollClipLayerId(root_layer->id());
 486     child_layer_->SetBounds(root_scroll_layer_->bounds());
 487     root_scroll_layer_->AddChild(child_layer_);
 488
 489     if (scroll_child_layer_) {
 490       expected_scroll_layer_ = child_layer_;
 491       expected_no_scroll_layer_ = root_scroll_layer_;
 492     } else {
 493       expected_scroll_layer_ = root_scroll_layer_;
 494       expected_no_scroll_layer_ = child_layer_;
 495     }
 496
 497     expected_scroll_layer_->SetScrollOffset(initial_offset_);
 498
 499     layer_tree_host()->SetRootLayer(root_layer);
 500     layer_tree_host()->RegisterViewportLayers(
 501         root_layer, root_scroll_layer_, NULL);
 502     LayerTreeHostScrollTest::SetupTree();
 503   }
 504
 505   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 506
 507   virtual void WillCommit() OVERRIDE {
 508     // Keep the test committing (otherwise the early out for no update
 509     // will stall the test).
 510     if (layer_tree_host()->source_frame_number() < 2) {
 511       layer_tree_host()->SetNeedsCommit();
 512     }
 513   }
 514
 515   void DidScroll() {
 516     final_scroll_offset_ = expected_scroll_layer_->scroll_offset();
 517   }
 518
 519   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
 520                                    float scale,
 521                                    float top_controls_delta) OVERRIDE {
 522     num_scrolls_++;
 523   }
 524
 525   virtual void Layout() OVERRIDE {
 526     EXPECT_VECTOR_EQ(gfx::Vector2d(),
 527                      expected_no_scroll_layer_->scroll_offset());
 528
 529     switch (layer_tree_host()->source_frame_number()) {
 530       case 0:
 531         EXPECT_VECTOR_EQ(initial_offset_,
 532                          expected_scroll_layer_->scroll_offset());
 533         break;
 534       case 1:
 535         EXPECT_VECTOR_EQ(initial_offset_ + scroll_amount_,
 536                          expected_scroll_layer_->scroll_offset());
 537
 538         // Pretend like Javascript updated the scroll position itself.
 539         expected_scroll_layer_->SetScrollOffset(javascript_scroll_);
 540         break;
 541       case 2:
 542         EXPECT_VECTOR_EQ(javascript_scroll_ + scroll_amount_,
 543                          expected_scroll_layer_->scroll_offset());
 544         break;
 545     }
 546   }
 547
 548   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 549     LayerImpl* root_impl = impl->active_tree()->root_layer();
 550     FakePictureLayerImpl* root_scroll_layer_impl =
 551         static_cast<FakePictureLayerImpl*>(root_impl->children()[0]);
 552     FakePictureLayerImpl* child_layer_impl = static_cast<FakePictureLayerImpl*>(
 553         root_scroll_layer_impl->children()[0]);
 554
 555     LayerImpl* expected_scroll_layer_impl = NULL;
 556     LayerImpl* expected_no_scroll_layer_impl = NULL;
 557     if (scroll_child_layer_) {
 558       expected_scroll_layer_impl = child_layer_impl;
 559       expected_no_scroll_layer_impl = root_scroll_layer_impl;
 560     } else {
 561       expected_scroll_layer_impl = root_scroll_layer_impl;
 562       expected_no_scroll_layer_impl = child_layer_impl;
 563     }
 564
 565     EXPECT_VECTOR_EQ(gfx::Vector2d(), root_impl->ScrollDelta());
 566     EXPECT_VECTOR_EQ(gfx::Vector2d(),
 567                      expected_no_scroll_layer_impl->ScrollDelta());
 568
 569     // Ensure device scale factor matches the active tree.
 570     EXPECT_EQ(device_scale_factor_, impl->active_tree()->device_scale_factor());
 571     switch (impl->active_tree()->source_frame_number()) {
 572       case 0: {
 573         // Gesture scroll on impl thread.
 574         InputHandler::ScrollStatus status = impl->ScrollBegin(
 575             gfx::ToCeiledPoint(expected_scroll_layer_impl->position() -
 576                                gfx::Vector2dF(0.5f, 0.5f)),
 577             InputHandler::Gesture);
 578         EXPECT_EQ(InputHandler::ScrollStarted, status);
 579         impl->ScrollBy(gfx::Point(), scroll_amount_);
 580         impl->ScrollEnd();
 581
 582         // Check the scroll is applied as a delta.
 583         EXPECT_VECTOR_EQ(initial_offset_,
 584                          expected_scroll_layer_impl->scroll_offset());
 585         EXPECT_VECTOR_EQ(scroll_amount_,
 586                          expected_scroll_layer_impl->ScrollDelta());
 587         break;
 588       }
 589       case 1: {
 590         // Wheel scroll on impl thread.
 591         InputHandler::ScrollStatus status = impl->ScrollBegin(
 592             gfx::ToCeiledPoint(expected_scroll_layer_impl->position() +
 593                                gfx::Vector2dF(0.5f, 0.5f)),
 594             InputHandler::Wheel);
 595         EXPECT_EQ(InputHandler::ScrollStarted, status);
 596         impl->ScrollBy(gfx::Point(), scroll_amount_);
 597         impl->ScrollEnd();
 598
 599         // Check the scroll is applied as a delta.
 600         EXPECT_VECTOR_EQ(javascript_scroll_,
 601                          expected_scroll_layer_impl->scroll_offset());
 602         EXPECT_VECTOR_EQ(scroll_amount_,
 603                          expected_scroll_layer_impl->ScrollDelta());
 604         break;
 605       }
 606       case 2:
 607
 608         EXPECT_VECTOR_EQ(javascript_scroll_ + scroll_amount_,
 609                          expected_scroll_layer_impl->scroll_offset());
 610         EXPECT_VECTOR_EQ(gfx::Vector2d(),
 611                          expected_scroll_layer_impl->ScrollDelta());
 612
 613         EndTest();
 614         break;
 615     }
 616   }
 617
 618   virtual void AfterTest() OVERRIDE {
 619     if (scroll_child_layer_) {
 620       EXPECT_EQ(0, num_scrolls_);
 621       EXPECT_VECTOR_EQ(javascript_scroll_ + scroll_amount_,
 622                        final_scroll_offset_);
 623     } else {
 624       EXPECT_EQ(2, num_scrolls_);
 625       EXPECT_VECTOR_EQ(gfx::Vector2d(), final_scroll_offset_);
 626     }
 627   }
 628
 629  protected:
 630   float device_scale_factor_;
 631   bool scroll_child_layer_;
 632
 633   gfx::Vector2d initial_offset_;
 634   gfx::Vector2d javascript_scroll_;
 635   gfx::Vector2d scroll_amount_;
 636   int num_scrolls_;
 637   gfx::Vector2d final_scroll_offset_;
 638
 639   FakeContentLayerClient fake_content_layer_client_;
 640
 641   scoped_refptr<Layer> root_scroll_layer_;
 642   scoped_refptr<Layer> child_layer_;
 643   scoped_refptr<Layer> expected_scroll_layer_;
 644   scoped_refptr<Layer> expected_no_scroll_layer_;
 645 };
 646
 647 TEST_F(LayerTreeHostScrollTestCaseWithChild,
 648        DeviceScaleFactor1_ScrollChild_DirectRenderer) {
 649   device_scale_factor_ = 1.f;
 650   scroll_child_layer_ = true;
 651   RunTest(true, false, true);
 652 }
 653
 654 TEST_F(LayerTreeHostScrollTestCaseWithChild,
 655        DeviceScaleFactor1_ScrollChild_DelegatingRenderer) {
 656   device_scale_factor_ = 1.f;
 657   scroll_child_layer_ = true;
 658   RunTest(true, true, true);
 659 }
 660
 661 TEST_F(LayerTreeHostScrollTestCaseWithChild,
 662        DeviceScaleFactor15_ScrollChild_DirectRenderer) {
 663   device_scale_factor_ = 1.5f;
 664   scroll_child_layer_ = true;
 665   RunTest(true, false, true);
 666 }
 667
 668 TEST_F(LayerTreeHostScrollTestCaseWithChild,
 669        DeviceScaleFactor15_ScrollChild_DelegatingRenderer) {
 670   device_scale_factor_ = 1.5f;
 671   scroll_child_layer_ = true;
 672   RunTest(true, true, true);
 673 }
 674
 675 TEST_F(LayerTreeHostScrollTestCaseWithChild,
 676        DeviceScaleFactor2_ScrollChild_DirectRenderer) {
 677   device_scale_factor_ = 2.f;
 678   scroll_child_layer_ = true;
 679   RunTest(true, false, true);
 680 }
 681
 682 TEST_F(LayerTreeHostScrollTestCaseWithChild,
 683        DeviceScaleFactor2_ScrollChild_DelegatingRenderer) {
 684   device_scale_factor_ = 2.f;
 685   scroll_child_layer_ = true;
 686   RunTest(true, true, true);
 687 }
 688
 689 TEST_F(LayerTreeHostScrollTestCaseWithChild,
 690        DeviceScaleFactor1_ScrollRootScrollLayer_DirectRenderer) {
 691   device_scale_factor_ = 1.f;
 692   scroll_child_layer_ = false;
 693   RunTest(true, false, true);
 694 }
 695
 696 TEST_F(LayerTreeHostScrollTestCaseWithChild,
 697        DeviceScaleFactor1_ScrollRootScrollLayer_DelegatingRenderer) {
 698   device_scale_factor_ = 1.f;
 699   scroll_child_layer_ = false;
 700   RunTest(true, true, true);
 701 }
 702
 703 TEST_F(LayerTreeHostScrollTestCaseWithChild,
 704        DeviceScaleFactor15_ScrollRootScrollLayer_DirectRenderer) {
 705   device_scale_factor_ = 1.5f;
 706   scroll_child_layer_ = false;
 707   RunTest(true, false, true);
 708 }
 709
 710 TEST_F(LayerTreeHostScrollTestCaseWithChild,
 711        DeviceScaleFactor15_ScrollRootScrollLayer_DelegatingRenderer) {
 712   device_scale_factor_ = 1.5f;
 713   scroll_child_layer_ = false;
 714   RunTest(true, true, true);
 715 }
 716
 717 TEST_F(LayerTreeHostScrollTestCaseWithChild,
 718        DeviceScaleFactor2_ScrollRootScrollLayer_DirectRenderer) {
 719   device_scale_factor_ = 2.f;
 720   scroll_child_layer_ = false;
 721   RunTest(true, false, true);
 722 }
 723
 724 TEST_F(LayerTreeHostScrollTestCaseWithChild,
 725        DeviceScaleFactor2_ScrollRootScrollLayer_DelegatingRenderer) {
 726   device_scale_factor_ = 2.f;
 727   scroll_child_layer_ = false;
 728   RunTest(true, true, true);
 729 }
 730
 731 class ImplSidePaintingScrollTest : public LayerTreeHostScrollTest {
 732  public:
 733   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
 734     settings->impl_side_painting = true;
 735   }
 736
 737   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 738     if (impl->pending_tree())
 739       impl->SetNeedsRedraw();
 740   }
 741 };
 742
 743 class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
 744  public:
 745   ImplSidePaintingScrollTestSimple()
 746       : initial_scroll_(10, 20),
 747         main_thread_scroll_(40, 5),
 748         impl_thread_scroll1_(2, -1),
 749         impl_thread_scroll2_(-3, 10),
 750         num_scrolls_(0) {}
 751
 752   virtual void SetupTree() OVERRIDE {
 753     LayerTreeHostScrollTest::SetupTree();
 754     Layer* root_layer = layer_tree_host()->root_layer();
 755     scoped_refptr<Layer> root_scroll_layer = Layer::Create();
 756     root_scroll_layer->SetScrollClipLayerId(root_layer->id());
 757     root_scroll_layer->SetScrollOffset(initial_scroll_);
 758     root_scroll_layer->SetBounds(
 759         gfx::Size(root_layer->bounds().width() + 100,
 760                   root_layer->bounds().height() + 100));
 761     root_scroll_layer->SetIsDrawable(true);
 762     root_scroll_layer->SetIsContainerForFixedPositionLayers(true);
 763     root_layer->AddChild(root_scroll_layer);
 764
 765     layer_tree_host()->RegisterViewportLayers(
 766         root_layer, root_scroll_layer, NULL);
 767     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
 768   }
 769
 770   virtual void BeginTest() OVERRIDE {
 771     PostSetNeedsCommitToMainThread();
 772   }
 773
 774   virtual void Layout() OVERRIDE {
 775     Layer* root = layer_tree_host()->root_layer();
 776     Layer* scroll_layer = root->children()[0].get();
 777     if (!layer_tree_host()->source_frame_number()) {
 778       EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
 779     } else {
 780       EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(),
 781                        initial_scroll_ + impl_thread_scroll1_);
 782
 783       // Pretend like Javascript updated the scroll position itself with a
 784       // change of main_thread_scroll.
 785       scroll_layer->SetScrollOffset(initial_scroll_ + main_thread_scroll_ +
 786                                     impl_thread_scroll1_);
 787     }
 788   }
 789
 790   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 791     // We force a second draw here of the first commit before activating
 792     // the second commit.
 793     if (impl->active_tree()->source_frame_number() == 0)
 794       impl->SetNeedsRedraw();
 795   }
 796
 797   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 798     ImplSidePaintingScrollTest::DrawLayersOnThread(impl);
 799
 800     LayerImpl* root = impl->active_tree()->root_layer();
 801     LayerImpl* scroll_layer = root->children()[0];
 802     LayerImpl* pending_root =
 803         impl->active_tree()->FindPendingTreeLayerById(root->id());
 804
 805     switch (impl->active_tree()->source_frame_number()) {
 806       case 0:
 807         if (!impl->pending_tree()) {
 808           impl->BlockNotifyReadyToActivateForTesting(true);
 809           EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());
 810           scroll_layer->ScrollBy(impl_thread_scroll1_);
 811
 812           EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
 813           EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll1_);
 814           EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
 815           PostSetNeedsCommitToMainThread();
 816
 817           // CommitCompleteOnThread will trigger this function again
 818           // and cause us to take the else clause.
 819         } else {
 820           impl->BlockNotifyReadyToActivateForTesting(false);
 821           ASSERT_TRUE(pending_root);
 822           EXPECT_EQ(impl->pending_tree()->source_frame_number(), 1);
 823
 824           scroll_layer->ScrollBy(impl_thread_scroll2_);
 825           EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
 826           EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),
 827                            impl_thread_scroll1_ + impl_thread_scroll2_);
 828           EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(),
 829                            impl_thread_scroll1_);
 830
 831           LayerImpl* pending_scroll_layer = pending_root->children()[0];
 832           EXPECT_VECTOR_EQ(
 833               pending_scroll_layer->scroll_offset(),
 834               initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
 835           EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(),
 836                            impl_thread_scroll2_);
 837           EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
 838                            gfx::Vector2d());
 839         }
 840         break;
 841       case 1:
 842         EXPECT_FALSE(impl->pending_tree());
 843         EXPECT_VECTOR_EQ(
 844             scroll_layer->scroll_offset(),
 845             initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
 846         EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll2_);
 847         EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
 848         EndTest();
 849         break;
 850     }
 851   }
 852
 853   virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
 854                                    float scale,
 855                                    float top_controls_delta) OVERRIDE {
 856     num_scrolls_++;
 857   }
 858
 859   virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }
 860
 861  private:
 862   gfx::Vector2d initial_scroll_;
 863   gfx::Vector2d main_thread_scroll_;
 864   gfx::Vector2d impl_thread_scroll1_;
 865   gfx::Vector2d impl_thread_scroll2_;
 866   int num_scrolls_;
 867 };
 868
 869 MULTI_THREAD_TEST_F(ImplSidePaintingScrollTestSimple);
 870
 871 // This test makes sure that layers pick up scrolls that occur between
 872 // beginning a commit and finishing a commit (aka scroll deltas not
 873 // included in sent scroll delta) still apply to layers that don't
 874 // push properties.
 875 class ImplSidePaintingScrollTestImplOnlyScroll
 876     : public ImplSidePaintingScrollTest {
 877  public:
 878   ImplSidePaintingScrollTestImplOnlyScroll()
 879       : initial_scroll_(20, 10), impl_thread_scroll_(-2, 3) {}
 880
 881   virtual void SetupTree() OVERRIDE {
 882     LayerTreeHostScrollTest::SetupTree();
 883     Layer* root_layer = layer_tree_host()->root_layer();
 884     scoped_refptr<Layer> root_scroll_layer = Layer::Create();
 885     root_scroll_layer->SetScrollClipLayerId(root_layer->id());
 886     root_scroll_layer->SetScrollOffset(initial_scroll_);
 887     root_scroll_layer->SetBounds(
 888         gfx::Size(root_layer->bounds().width() + 100,
 889                   root_layer->bounds().height() + 100));
 890     root_scroll_layer->SetIsDrawable(true);
 891     root_scroll_layer->SetIsContainerForFixedPositionLayers(true);
 892     root_layer->AddChild(root_scroll_layer);
 893
 894     layer_tree_host()->RegisterViewportLayers(
 895         root_layer, root_scroll_layer, NULL);
 896     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
 897   }
 898
 899   virtual void BeginTest() OVERRIDE {
 900     PostSetNeedsCommitToMainThread();
 901   }
 902
 903   virtual void WillCommit() OVERRIDE {
 904     Layer* root = layer_tree_host()->root_layer();
 905     Layer* scroll_layer = root->children()[0].get();
 906     switch (layer_tree_host()->source_frame_number()) {
 907       case 0:
 908         EXPECT_TRUE(scroll_layer->needs_push_properties());
 909         break;
 910       case 1:
 911         // Even if this layer doesn't need push properties, it should
 912         // still pick up scrolls that happen on the active layer during
 913         // commit.
 914         EXPECT_FALSE(scroll_layer->needs_push_properties());
 915         break;
 916     }
 917   }
 918
 919   virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 920     // Scroll after the 2nd commit has started.
 921     if (impl->active_tree()->source_frame_number() == 0) {
 922       LayerImpl* active_root = impl->active_tree()->root_layer();
 923       LayerImpl* active_scroll_layer = active_root->children()[0];
 924       ASSERT_TRUE(active_root);
 925       ASSERT_TRUE(active_scroll_layer);
 926       active_scroll_layer->ScrollBy(impl_thread_scroll_);
 927     }
 928   }
 929
 930   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 931     // We force a second draw here of the first commit before activating
 932     // the second commit.
 933     LayerImpl* active_root = impl->active_tree()->root_layer();
 934     LayerImpl* active_scroll_layer =
 935         active_root ? active_root->children()[0] : NULL;
 936     LayerImpl* pending_root = impl->pending_tree()->root_layer();
 937     LayerImpl* pending_scroll_layer = pending_root->children()[0];
 938
 939     ASSERT_TRUE(pending_root);
 940     ASSERT_TRUE(pending_scroll_layer);
 941     switch (impl->pending_tree()->source_frame_number()) {
 942       case 0:
 943         EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),
 944                          initial_scroll_);
 945         EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(), gfx::Vector2d());
 946         EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
 947                          gfx::Vector2d());
 948         EXPECT_FALSE(active_root);
 949         break;
 950       case 1:
 951         // Even though the scroll happened during the commit, both layers
 952         // should have the appropriate scroll delta.
 953         EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),
 954                          initial_scroll_);
 955         EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(),
 956                          impl_thread_scroll_);
 957         EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
 958                          gfx::Vector2d());
 959         ASSERT_TRUE(active_root);
 960         EXPECT_VECTOR_EQ(active_scroll_layer->scroll_offset(), initial_scroll_);
 961         EXPECT_VECTOR_EQ(active_scroll_layer->ScrollDelta(),
 962                          impl_thread_scroll_);
 963         EXPECT_VECTOR_EQ(active_scroll_layer->sent_scroll_delta(),
 964                          gfx::Vector2d());
 965         break;
 966       case 2:
 967         // On the next commit, this delta should have been sent and applied.
 968         EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),
 969                          initial_scroll_ + impl_thread_scroll_);
 970         EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(), gfx::Vector2d());
 971         EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
 972                          gfx::Vector2d());
 973         EndTest();
 974         break;
 975     }
 976   }
 977
 978   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
 979     ImplSidePaintingScrollTest::DrawLayersOnThread(impl);
 980
 981     LayerImpl* root = impl->active_tree()->root_layer();
 982     LayerImpl* scroll_layer = root->children()[0];
 983
 984     switch (impl->active_tree()->source_frame_number()) {
 985       case 0:
 986         EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
 987         EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());
 988         EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
 989         PostSetNeedsCommitToMainThread();
 990         break;
 991       case 1:
 992         EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
 993         EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll_);
 994         EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
 995         PostSetNeedsCommitToMainThread();
 996         break;
 997     }
 998   }
 999
1000   virtual void AfterTest() OVERRIDE {}
1001
1002  private:
1003   gfx::Vector2d initial_scroll_;
1004   gfx::Vector2d impl_thread_scroll_;
1005 };
1006
1007 MULTI_THREAD_TEST_F(ImplSidePaintingScrollTestImplOnlyScroll);
1008
1009 class LayerTreeHostScrollTestScrollZeroMaxScrollOffset
1010     : public LayerTreeHostScrollTest {
1011  public:
1012   LayerTreeHostScrollTestScrollZeroMaxScrollOffset() {}
1013
1014   virtual void SetupTree() OVERRIDE {
1015     LayerTreeTest::SetupTree();
1016     scoped_refptr<Layer> scroll_layer = Layer::Create();
1017     layer_tree_host()->root_layer()->AddChild(scroll_layer);
1018   }
1019
1020   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
1021
1022   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
1023     LayerImpl* root = impl->active_tree()->root_layer();
1024     LayerImpl* scroll_layer = root->children()[0];
1025     scroll_layer->SetScrollClipLayer(root->id());
1026
1027     // Set max_scroll_offset = (100, 100).
1028     scroll_layer->SetBounds(
1029         gfx::Size(root->bounds().width() + 100, root->bounds().height() + 100));
1030     EXPECT_EQ(InputHandler::ScrollStarted,
1031               scroll_layer->TryScroll(gfx::PointF(0.0f, 1.0f),
1032                                       InputHandler::Gesture));
1033
1034     // Set max_scroll_offset = (0, 0).
1035     scroll_layer->SetBounds(root->bounds());
1036     EXPECT_EQ(InputHandler::ScrollIgnored,
1037               scroll_layer->TryScroll(gfx::PointF(0.0f, 1.0f),
1038                                       InputHandler::Gesture));
1039
1040     // Set max_scroll_offset = (-100, -100).
1041     scroll_layer->SetBounds(gfx::Size());
1042     EXPECT_EQ(InputHandler::ScrollIgnored,
1043               scroll_layer->TryScroll(gfx::PointF(0.0f, 1.0f),
1044                                       InputHandler::Gesture));
1045
1046     EndTest();
1047   }
1048
1049   virtual void AfterTest() OVERRIDE {}
1050 };
1051
1052 SINGLE_AND_MULTI_THREAD_TEST_F(
1053     LayerTreeHostScrollTestScrollZeroMaxScrollOffset);
1054
1055 class ThreadCheckingInputHandlerClient : public InputHandlerClient {
1056  public:
1057   ThreadCheckingInputHandlerClient(base::SingleThreadTaskRunner* runner,
1058                                    bool* received_stop_flinging)
1059       : task_runner_(runner), received_stop_flinging_(received_stop_flinging) {}
1060
1061   virtual void WillShutdown() OVERRIDE {
1062     if (!received_stop_flinging_)
1063       ADD_FAILURE() << "WillShutdown() called before fling stopped";
1064   }
1065
1066   virtual void Animate(base::TimeTicks time) OVERRIDE {
1067     if (!task_runner_->BelongsToCurrentThread())
1068       ADD_FAILURE() << "Animate called on wrong thread";
1069   }
1070
1071   virtual void MainThreadHasStoppedFlinging() OVERRIDE {
1072     if (!task_runner_->BelongsToCurrentThread())
1073       ADD_FAILURE() << "MainThreadHasStoppedFlinging called on wrong thread";
1074     *received_stop_flinging_ = true;
1075   }
1076
1077   virtual void DidOverscroll(
1078       const gfx::PointF& causal_event_viewport_point,
1079       const gfx::Vector2dF& accumulated_overscroll,
1080       const gfx::Vector2dF& latest_overscroll_delta) OVERRIDE {
1081     if (!task_runner_->BelongsToCurrentThread())
1082       ADD_FAILURE() << "DidOverscroll called on wrong thread";
1083   }
1084
1085  private:
1086   base::SingleThreadTaskRunner* task_runner_;
1087   bool* received_stop_flinging_;
1088 };
1089
1090 void BindInputHandlerOnCompositorThread(
1091     const base::WeakPtr<InputHandler>& input_handler,
1092     ThreadCheckingInputHandlerClient* client) {
1093   input_handler->BindToClient(client);
1094 }
1095
1096 TEST(LayerTreeHostFlingTest, DidStopFlingingThread) {
1097   base::Thread impl_thread("cc");
1098   ASSERT_TRUE(impl_thread.Start());
1099
1100   bool received_stop_flinging = false;
1101   LayerTreeSettings settings;
1102
1103   ThreadCheckingInputHandlerClient input_handler_client(
1104           impl_thread.message_loop_proxy().get(), &received_stop_flinging);
1105   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
1106
1107   ASSERT_TRUE(impl_thread.message_loop_proxy().get());
1108   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
1109       new TestSharedBitmapManager());
1110   scoped_ptr<LayerTreeHost> layer_tree_host =
1111       LayerTreeHost::CreateThreaded(&client,
1112                                     shared_bitmap_manager.get(),
1113                                     settings,
1114                                     base::MessageLoopProxy::current(),
1115                                     impl_thread.message_loop_proxy());
1116
1117   impl_thread.message_loop_proxy()
1118       ->PostTask(FROM_HERE,
1119                  base::Bind(&BindInputHandlerOnCompositorThread,
1120                             layer_tree_host->GetInputHandler(),
1121                             base::Unretained(&input_handler_client)));
1122
1123   layer_tree_host->DidStopFlinging();
1124   layer_tree_host.reset();
1125   impl_thread.Stop();
1126   EXPECT_TRUE(received_stop_flinging);
1127 }
1128
1129 class LayerTreeHostScrollTestLayerStructureChange
1130     : public LayerTreeHostScrollTest {
1131  public:
1132   LayerTreeHostScrollTestLayerStructureChange()
1133       : scroll_destroy_whole_tree_(false) {}
1134
1135   virtual void SetupTree() OVERRIDE {
1136     scoped_refptr<Layer> root_layer = Layer::Create();
1137     root_layer->SetBounds(gfx::Size(10, 10));
1138
1139     Layer* root_scroll_layer =
1140         CreateScrollLayer(root_layer.get(), &root_scroll_layer_client_);
1141     CreateScrollLayer(root_layer.get(), &sibling_scroll_layer_client_);
1142     CreateScrollLayer(root_scroll_layer, &child_scroll_layer_client_);
1143
1144     layer_tree_host()->SetRootLayer(root_layer);
1145     LayerTreeHostScrollTest::SetupTree();
1146   }
1147
1148   virtual void BeginTest() OVERRIDE {
1149     PostSetNeedsCommitToMainThread();
1150   }
1151
1152   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
1153     LayerImpl* root = impl->active_tree()->root_layer();
1154     switch (impl->active_tree()->source_frame_number()) {
1155       case 0:
1156         root->child_at(0)->SetScrollDelta(gfx::Vector2dF(5, 5));
1157         root->child_at(0)->child_at(0)->SetScrollDelta(gfx::Vector2dF(5, 5));
1158         root->child_at(1)->SetScrollDelta(gfx::Vector2dF(5, 5));
1159         PostSetNeedsCommitToMainThread();
1160         break;
1161       case 1:
1162         EndTest();
1163         break;
1164     }
1165   }
1166
1167   virtual void AfterTest() OVERRIDE {}
1168
1169   virtual void DidScroll(Layer* layer) {
1170     if (scroll_destroy_whole_tree_) {
1171       layer_tree_host()->SetRootLayer(NULL);
1172       EndTest();
1173       return;
1174     }
1175     layer->RemoveFromParent();
1176   }
1177
1178  protected:
1179   class FakeLayerScrollClient {
1180    public:
1181     void DidScroll() {
1182       owner_->DidScroll(layer_);
1183     }
1184     LayerTreeHostScrollTestLayerStructureChange* owner_;
1185     Layer* layer_;
1186   };
1187
1188   Layer* CreateScrollLayer(Layer* parent, FakeLayerScrollClient* client) {
1189     scoped_refptr<PictureLayer> scroll_layer =
1190         PictureLayer::Create(&fake_content_layer_client_);
1191     scroll_layer->SetBounds(gfx::Size(110, 110));
1192     scroll_layer->SetPosition(gfx::Point(0, 0));
1193     scroll_layer->SetIsDrawable(true);
1194     scroll_layer->SetScrollClipLayerId(parent->id());
1195     scroll_layer->SetBounds(gfx::Size(parent->bounds().width() + 100,
1196                                       parent->bounds().height() + 100));
1197     scroll_layer->set_did_scroll_callback(base::Bind(
1198         &FakeLayerScrollClient::DidScroll, base::Unretained(client)));
1199     client->owner_ = this;
1200     client->layer_ = scroll_layer.get();
1201     parent->AddChild(scroll_layer);
1202     return scroll_layer.get();
1203   }
1204
1205   FakeLayerScrollClient root_scroll_layer_client_;
1206   FakeLayerScrollClient sibling_scroll_layer_client_;
1207   FakeLayerScrollClient child_scroll_layer_client_;
1208
1209   FakeContentLayerClient fake_content_layer_client_;
1210
1211   bool scroll_destroy_whole_tree_;
1212 };
1213
1214 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyLayer) {
1215   RunTest(true, false, true);
1216 }
1217
1218 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyWholeTree) {
1219   scroll_destroy_whole_tree_ = true;
1220   RunTest(true, false, true);
1221 }
1222
1223 }  // namespace
1224 }  // namespace cc