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