Clean LayerImpl's scroll offset callers in unit tests.

cc/trees/layer_tree_host_unittest_scroll.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host.h"
 
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 55 matching lines @@
     gfx::Size scroll_layer_bounds(root_layer->bounds().width() + 100,
                                   root_layer->bounds().height() + 100);
 
     CreateVirtualViewportLayers(root_layer,
                                 root_layer->bounds(),
                                 root_layer->bounds(),
                                 scroll_layer_bounds,
                                 layer_tree_host(),
                                 layer_settings());
   }
+
+ public:
+  ScrollTree* scroll_tree(LayerImpl* layer_impl) {

[ajuma, 2016/03/07 19:10:19]

This is probably better off as a helper function defined outside this class.
Also, it should be named something like GetScrollTree or ScrollTreeForLayer
(since naming it ScrollTree collides with the class name).

[sunxd, 2016/03/09 01:51:21]

Done.

+    return &layer_impl->layer_tree_impl()->property_trees()->scroll_tree;
+  }
 };
 
 class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollSimple()
       : initial_scroll_(10, 20),
         second_scroll_(40, 5),
         scroll_amount_(2, -1),
         num_scrolls_(0) {}
 
@@ skipping 22 matching lines @@
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
     EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());
 
     scroll_layer->SetScrollClipLayer(root->children()[0]->id());
     scroll_layer->SetBounds(
         gfx::Size(root->bounds().width() + 100, root->bounds().height() + 100));
     scroll_layer->ScrollBy(scroll_amount_);
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->BaseScrollOffset());
+        EXPECT_VECTOR_EQ(initial_scroll_, scroll_tree(scroll_layer)
+                                              ->GetScrollOffsetBaseForTesting(
+                                                  scroll_layer->id()));
         EXPECT_VECTOR_EQ(scroll_amount_, scroll_layer->ScrollDelta());
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
-        EXPECT_VECTOR_EQ(second_scroll_, scroll_layer->BaseScrollOffset());
+        EXPECT_VECTOR_EQ(second_scroll_, scroll_tree(scroll_layer)
+                                             ->GetScrollOffsetBaseForTesting(
+                                                 scroll_layer->id()));
         EXPECT_VECTOR_EQ(scroll_amount_, scroll_layer->ScrollDelta());
         EndTest();
         break;
     }
   }
 
   void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
                            const gfx::Vector2dF& outer_delta,
                            const gfx::Vector2dF& elastic_overscroll_delta,
                            float scale,
@@ skipping 46 matching lines @@
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* scroll_layer =
         impl->active_tree()->LayerById(scroll_layer_->id());
     if (impl->active_tree()->source_frame_number() == 0 &&
         impl->SourceAnimationFrameNumberForTesting() == 1) {
       // First draw after first commit.
       EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());
       scroll_layer->ScrollBy(scroll_amount_);
       EXPECT_VECTOR_EQ(scroll_amount_, scroll_layer->ScrollDelta());
 
-      EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->BaseScrollOffset());
+      EXPECT_VECTOR_EQ(initial_scroll_,
+                       scroll_tree(scroll_layer)
+                           ->GetScrollOffsetBaseForTesting(scroll_layer->id()));
       PostSetNeedsRedrawToMainThread();
     } else if (impl->active_tree()->source_frame_number() == 0 &&
                impl->SourceAnimationFrameNumberForTesting() == 2) {
       // Second draw after first commit.
       EXPECT_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
       scroll_layer->ScrollBy(scroll_amount_);
       EXPECT_VECTOR_EQ(scroll_amount_ + scroll_amount_,
                        scroll_layer->ScrollDelta());
 
       EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer_->scroll_offset());
@@ skipping 123 matching lines @@
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root_scroll_layer = impl->OuterViewportScrollLayer();
 
     if (impl->active_tree()->source_frame_number() == 0 &&
         impl->SourceAnimationFrameNumberForTesting() == 1) {
       // First draw
       EXPECT_VECTOR_EQ(gfx::Vector2d(), root_scroll_layer->ScrollDelta());
       root_scroll_layer->ScrollBy(impl_scroll_);
       EXPECT_VECTOR_EQ(impl_scroll_, root_scroll_layer->ScrollDelta());
-      EXPECT_VECTOR_EQ(initial_scroll_, root_scroll_layer->BaseScrollOffset());
+      EXPECT_VECTOR_EQ(initial_scroll_, scroll_tree(root_scroll_layer)
+                                            ->GetScrollOffsetBaseForTesting(
+                                                root_scroll_layer->id()));
 
       EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
       EXPECT_EQ(1.f, impl->active_tree()->current_page_scale_factor());
       impl->active_tree()->SetPageScaleOnActiveTree(impl_scale_);
       EXPECT_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
       EXPECT_EQ(impl_scale_, impl->active_tree()->current_page_scale_factor());
 
       // To simplify the testing flow, don't redraw here, just commit.
       impl->SetNeedsCommit();
     } else if (impl->active_tree()->source_frame_number() == 0 &&
                impl->SourceAnimationFrameNumberForTesting() == 2) {
       // Test a second draw after an aborted commit.
       // The scroll/scale values should be baked into the offset/scale factor
       // since the main thread consumed but aborted the begin frame.
       EXPECT_VECTOR_EQ(gfx::Vector2d(), root_scroll_layer->ScrollDelta());
       root_scroll_layer->ScrollBy(impl_scroll_);
       EXPECT_VECTOR_EQ(impl_scroll_, root_scroll_layer->ScrollDelta());
       EXPECT_VECTOR_EQ(
           gfx::ScrollOffsetWithDelta(initial_scroll_, impl_scroll_),
-          root_scroll_layer->BaseScrollOffset());
+          scroll_tree(root_scroll_layer)
+              ->GetScrollOffsetBaseForTesting(root_scroll_layer->id()));
 
       EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
       EXPECT_EQ(impl_scale_, impl->active_tree()->current_page_scale_factor());
       impl->active_tree()->SetPageScaleOnActiveTree(impl_scale_ * impl_scale_);
       EXPECT_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
       EXPECT_EQ(impl_scale_ * impl_scale_,
                 impl->active_tree()->current_page_scale_factor());
 
       impl->SetNeedsCommit();
     } else if (impl->active_tree()->source_frame_number() == 1) {
       // Commit for source frame 1 is aborted.
       NOTREACHED();
     } else if (impl->active_tree()->source_frame_number() == 2 &&
                impl->SourceAnimationFrameNumberForTesting() == 3) {
       // Third draw after the second full commit.
       EXPECT_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());
       root_scroll_layer->ScrollBy(impl_scroll_);
       impl->SetNeedsCommit();
       EXPECT_VECTOR_EQ(impl_scroll_, root_scroll_layer->ScrollDelta());
       gfx::Vector2dF delta = impl_scroll_ + impl_scroll_ + second_main_scroll_;
-      EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(initial_scroll_, delta),
-                       root_scroll_layer->BaseScrollOffset());
+      EXPECT_VECTOR_EQ(
+          gfx::ScrollOffsetWithDelta(initial_scroll_, delta),
+          scroll_tree(root_scroll_layer)
+              ->GetScrollOffsetBaseForTesting(root_scroll_layer->id()));
     } else if (impl->active_tree()->source_frame_number() == 2 &&
                impl->SourceAnimationFrameNumberForTesting() == 4) {
       // Final draw after the second aborted commit.
       EXPECT_VECTOR_EQ(gfx::Vector2d(), root_scroll_layer->ScrollDelta());
       gfx::Vector2dF delta =
           impl_scroll_ + impl_scroll_ + impl_scroll_ + second_main_scroll_;
-      EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(initial_scroll_, delta),
-                       root_scroll_layer->BaseScrollOffset());
+      EXPECT_VECTOR_EQ(
+          gfx::ScrollOffsetWithDelta(initial_scroll_, delta),
+          scroll_tree(root_scroll_layer)
+              ->GetScrollOffsetBaseForTesting(root_scroll_layer->id()));
       EndTest();
     } else {
       // Commit for source frame 3 is aborted.
       NOTREACHED();
     }
   }
 
   void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
                            const gfx::Vector2dF& outer_delta,
                            const gfx::Vector2dF& elastic_overscroll_delta,
@@ skipping 39 matching lines @@
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
 
     // Check that a fractional scroll delta is correctly accumulated over
     // multiple commits.
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(gfx::Vector2d(0, 0), scroll_layer->BaseScrollOffset());
+        EXPECT_VECTOR_EQ(
+            gfx::Vector2d(0, 0),
+            scroll_tree(scroll_layer)
+                ->GetScrollOffsetBaseForTesting(scroll_layer->id()));
         EXPECT_VECTOR_EQ(gfx::Vector2d(0, 0), scroll_layer->ScrollDelta());
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
-        EXPECT_VECTOR_EQ(gfx::ToFlooredVector2d(scroll_amount_),
-                         scroll_layer->BaseScrollOffset());
+        EXPECT_VECTOR_EQ(
+            gfx::ToFlooredVector2d(scroll_amount_),
+            scroll_tree(scroll_layer)
+                ->GetScrollOffsetBaseForTesting(scroll_layer->id()));
         EXPECT_VECTOR_EQ(gfx::Vector2dF(fmod(scroll_amount_.x(), 1.0f), 0.0f),
                          scroll_layer->ScrollDelta());
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         EXPECT_VECTOR_EQ(
             gfx::ToFlooredVector2d(scroll_amount_ + scroll_amount_),
-            scroll_layer->BaseScrollOffset());
+            scroll_tree(scroll_layer)
+                ->GetScrollOffsetBaseForTesting(scroll_layer->id()));
         EXPECT_VECTOR_EQ(
             gfx::Vector2dF(fmod(2.0f * scroll_amount_.x(), 1.0f), 0.0f),
             scroll_layer->ScrollDelta());
         EndTest();
         break;
     }
     scroll_layer->ScrollBy(scroll_amount_);
   }
 
   void AfterTest() override {}
@@ skipping 155 matching lines @@
         impl->ScrollBy(UpdateState(gfx::Point(), scroll_amount_).get());
         LayerImpl* scrolling_layer = impl->CurrentlyScrollingLayer();
         CHECK(scrolling_layer);
         impl->ScrollEnd(EndState().get());
         CHECK(!impl->CurrentlyScrollingLayer());
         EXPECT_EQ(scrolling_layer->id(),
                   impl->active_tree()->LastScrolledLayerId());
 
         // Check the scroll is applied as a delta.
         EXPECT_VECTOR_EQ(initial_offset_,
-                         expected_scroll_layer_impl->BaseScrollOffset());
+                         scroll_tree(expected_scroll_layer_impl)
+                             ->GetScrollOffsetBaseForTesting(
+                                 expected_scroll_layer_impl->id()));
         EXPECT_VECTOR_EQ(scroll_amount_,
                          expected_scroll_layer_impl->ScrollDelta());
         break;
       }
       case 1: {
         // WHEEL scroll on impl thread.
         gfx::Point scroll_point =
             gfx::ToCeiledPoint(expected_scroll_layer_impl->position() +
                                gfx::Vector2dF(0.5f, 0.5f));
         InputHandler::ScrollStatus status = impl->ScrollBegin(
             BeginState(scroll_point).get(), InputHandler::WHEEL);
         EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread);
         impl->ScrollBy(UpdateState(gfx::Point(), scroll_amount_).get());
         impl->ScrollEnd(EndState().get());
 
         // Check the scroll is applied as a delta.
         EXPECT_VECTOR_EQ(javascript_scroll_,
-                         expected_scroll_layer_impl->BaseScrollOffset());
+                         scroll_tree(expected_scroll_layer_impl)
+                             ->GetScrollOffsetBaseForTesting(
+                                 expected_scroll_layer_impl->id()));
         EXPECT_VECTOR_EQ(scroll_amount_,
                          expected_scroll_layer_impl->ScrollDelta());
         break;
       }
       case 2:
 
         EXPECT_VECTOR_EQ(
             gfx::ScrollOffsetWithDelta(javascript_scroll_, scroll_amount_),
-            expected_scroll_layer_impl->BaseScrollOffset());
+            scroll_tree(expected_scroll_layer_impl)
+                ->GetScrollOffsetBaseForTesting(
+                    expected_scroll_layer_impl->id()));
         EXPECT_VECTOR_EQ(gfx::Vector2d(),
                          expected_scroll_layer_impl->ScrollDelta());
 
         EndTest();
         break;
     }
   }
 
   void AfterTest() override {
     if (scroll_child_layer_) {
@@ skipping 162 matching lines @@
     LayerImpl* pending_root =
         impl->active_tree()->FindPendingTreeLayerById(root->id());
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         if (!impl->pending_tree()) {
           impl->BlockNotifyReadyToActivateForTesting(true);
           EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());
           scroll_layer->ScrollBy(impl_thread_scroll1_);
 
-          EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->BaseScrollOffset());
+          EXPECT_VECTOR_EQ(initial_scroll_, scroll_tree(scroll_layer)
+                                                ->GetScrollOffsetBaseForTesting(
+                                                    scroll_layer->id()));
           EXPECT_VECTOR_EQ(impl_thread_scroll1_, scroll_layer->ScrollDelta());
           PostSetNeedsCommitToMainThread();
 
           // CommitCompleteOnThread will trigger this function again
           // and cause us to take the else clause.
         } else {
           impl->BlockNotifyReadyToActivateForTesting(false);
           ASSERT_TRUE(pending_root);
           EXPECT_EQ(impl->pending_tree()->source_frame_number(), 1);
 
           scroll_layer->ScrollBy(impl_thread_scroll2_);
-          EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->BaseScrollOffset());
+          EXPECT_VECTOR_EQ(initial_scroll_, scroll_tree(scroll_layer)
+                                                ->GetScrollOffsetBaseForTesting(
+                                                    scroll_layer->id()));
           EXPECT_VECTOR_EQ(impl_thread_scroll1_ + impl_thread_scroll2_,
                            scroll_layer->ScrollDelta());
 
           LayerImpl* pending_scroll_layer =
               impl->pending_tree()->OuterViewportScrollLayer();
           EXPECT_VECTOR_EQ(
               gfx::ScrollOffsetWithDelta(
                   initial_scroll_, main_thread_scroll_ + impl_thread_scroll1_),
-              pending_scroll_layer->BaseScrollOffset());
+              scroll_tree(pending_scroll_layer)
+                  ->GetScrollOffsetBaseForTesting(pending_scroll_layer->id()));
           EXPECT_VECTOR_EQ(impl_thread_scroll2_,
                            pending_scroll_layer->ScrollDelta());
         }
         break;
       case 1:
         EXPECT_FALSE(impl->pending_tree());
         EXPECT_VECTOR_EQ(
             gfx::ScrollOffsetWithDelta(
                 initial_scroll_, main_thread_scroll_ + impl_thread_scroll1_),
-            scroll_layer->BaseScrollOffset());
+            scroll_tree(scroll_layer)
+                ->GetScrollOffsetBaseForTesting(scroll_layer->id()));
         EXPECT_VECTOR_EQ(impl_thread_scroll2_, scroll_layer->ScrollDelta());
         EndTest();
         break;
     }
   }
 
   void ApplyViewportDeltas(const gfx::Vector2dF& inner_delta,
                            const gfx::Vector2dF& outer_delta,
                            const gfx::Vector2dF& elastic_overscroll_delta,
                            float scale,
@@ skipping 68 matching lines @@
     LayerImpl* active_scroll_layer =
         active_root ? impl->OuterViewportScrollLayer() : NULL;
     LayerImpl* pending_root = impl->pending_tree()->root_layer();
     LayerImpl* pending_scroll_layer =
         impl->pending_tree()->OuterViewportScrollLayer();
 
     ASSERT_TRUE(pending_root);
     ASSERT_TRUE(pending_scroll_layer);
     switch (impl->pending_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(initial_scroll_,
-                         pending_scroll_layer->BaseScrollOffset());
+        EXPECT_VECTOR_EQ(initial_scroll_, scroll_tree(pending_scroll_layer)
+                                              ->GetScrollOffsetBaseForTesting(
+                                                  pending_scroll_layer->id()));
         EXPECT_VECTOR_EQ(gfx::Vector2d(), pending_scroll_layer->ScrollDelta());
         EXPECT_FALSE(active_root);
         break;
       case 1:
         // Even though the scroll happened during the commit, both layers
         // should have the appropriate scroll delta.
-        EXPECT_VECTOR_EQ(initial_scroll_,
-                         pending_scroll_layer->BaseScrollOffset());
+        EXPECT_VECTOR_EQ(initial_scroll_, scroll_tree(pending_scroll_layer)
+                                              ->GetScrollOffsetBaseForTesting(
+                                                  pending_scroll_layer->id()));
         EXPECT_VECTOR_EQ(impl_thread_scroll_,
                          pending_scroll_layer->ScrollDelta());
         ASSERT_TRUE(active_root);
-        EXPECT_VECTOR_EQ(initial_scroll_,
-                         active_scroll_layer->BaseScrollOffset());
+        EXPECT_VECTOR_EQ(initial_scroll_, scroll_tree(active_scroll_layer)
+                                              ->GetScrollOffsetBaseForTesting(
+                                                  active_scroll_layer->id()));
         EXPECT_VECTOR_EQ(impl_thread_scroll_,
                          active_scroll_layer->ScrollDelta());
         break;
       case 2:
         // On the next commit, this delta should have been sent and applied.
         EXPECT_VECTOR_EQ(
             gfx::ScrollOffsetWithDelta(initial_scroll_, impl_thread_scroll_),
-            pending_scroll_layer->BaseScrollOffset());
+            scroll_tree(pending_scroll_layer)
+                ->GetScrollOffsetBaseForTesting(pending_scroll_layer->id()));
         EXPECT_VECTOR_EQ(gfx::Vector2d(), pending_scroll_layer->ScrollDelta());
         break;
     }
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     if (impl->pending_tree())
       impl->SetNeedsRedraw();
 
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->BaseScrollOffset());
+        EXPECT_VECTOR_EQ(initial_scroll_, scroll_tree(scroll_layer)
+                                              ->GetScrollOffsetBaseForTesting(
+                                                  scroll_layer->id()));
         EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());
         EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
         EXPECT_EQ(1.f, impl->active_tree()->current_page_scale_factor());
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
-        EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->BaseScrollOffset());
+        EXPECT_VECTOR_EQ(initial_scroll_, scroll_tree(scroll_layer)
+                                              ->GetScrollOffsetBaseForTesting(
+                                                  scroll_layer->id()));
         EXPECT_VECTOR_EQ(impl_thread_scroll_, scroll_layer->ScrollDelta());
         EXPECT_EQ(impl_scale_, impl->active_tree()->page_scale_delta());
         EXPECT_EQ(impl_scale_,
                   impl->active_tree()->current_page_scale_factor());
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
         EXPECT_EQ(impl_scale_,
                   impl->active_tree()->current_page_scale_factor());
@@ skipping 288 matching lines @@
     CreateScrollLayer(root_scroll_layer, &child_scroll_layer_client_);
     fake_content_layer_client_.set_bounds(root_layer->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->OuterViewportScrollLayer();
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        root->child_at(0)->SetScrollDelta(gfx::Vector2dF(5, 5));
-        root->child_at(0)->child_at(0)->SetScrollDelta(gfx::Vector2dF(5, 5));
-        root->child_at(1)->SetScrollDelta(gfx::Vector2dF(5, 5));
+        SetScrollOffsetDelta(root->child_at(0), gfx::Vector2dF(5, 5));
+        SetScrollOffsetDelta(root->child_at(0)->child_at(0),
+                             gfx::Vector2dF(5, 5));
+        SetScrollOffsetDelta(root->child_at(1), gfx::Vector2dF(5, 5));
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
         EndTest();
         break;
     }
   }
 
   void AfterTest() override {}
 
@@ skipping 27 matching lines @@
     scroll_layer->SetBounds(gfx::Size(parent->bounds().width() + 100,
                                       parent->bounds().height() + 100));
     scroll_layer->set_did_scroll_callback(base::Bind(
         &FakeLayerScrollClient::DidScroll, base::Unretained(client)));
     client->owner_ = this;
     client->layer_ = scroll_layer.get();
     parent->AddChild(scroll_layer);
     return scroll_layer.get();
   }
 
+  void SetScrollOffsetDelta(LayerImpl* layer_impl,

[ajuma, 2016/03/07 19:10:19]

static

[sunxd, 2016/03/09 01:51:21]

Done.

+                            const gfx::Vector2dF& delta) {
+    layer_impl->SetCurrentScrollOffset(
+        layer_impl->synced_scroll_offset()->ActiveBase() +
+        gfx::ScrollOffset(delta));
+  }
+
   FakeLayerScrollClient root_scroll_layer_client_;
   FakeLayerScrollClient sibling_scroll_layer_client_;
   FakeLayerScrollClient child_scroll_layer_client_;
 
   FakeContentLayerClient fake_content_layer_client_;
 
   bool scroll_destroy_whole_tree_;
 };
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyLayer) {
   RunTest(CompositorMode::THREADED, false);
 }
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyWholeTree) {
   scroll_destroy_whole_tree_ = true;
   RunTest(CompositorMode::THREADED, false);
 }
 
 }  // namespace
 }  // namespace cc