Update from https://crrev.com/307664

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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 <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 5478 matching lines @@
     PostSetNeedsCommitToMainThread();
   }
 
   void BeginMainFrame(const BeginFrameArgs& args) override {
     EXPECT_EQ(nullptr, layer_tree_host()->root_layer());
 
     layer_tree_host()->ApplyScrollAndScale(&info_);
     EndTest();
   }
 
-  void ApplyViewportDeltas(
-      const gfx::Vector2d& inner,
-      const gfx::Vector2d& outer,
-      float scale_delta,
-      float top_controls_delta) override {
+  void ApplyViewportDeltas(const gfx::Vector2d& inner,
+                           const gfx::Vector2d& outer,
+                           const gfx::Vector2dF& elastic_overscroll_delta,
+                           float scale_delta,
+                           float top_controls_delta) override {
     EXPECT_EQ(info_.page_scale_delta, scale_delta);
     EXPECT_EQ(info_.top_controls_delta, top_controls_delta);
     deltas_sent_to_client_ = true;
   }
 
   void ApplyViewportDeltas(
       const gfx::Vector2d& scroll,
       float scale_delta,
       float top_controls_delta) override {
     EXPECT_EQ(info_.page_scale_delta, scale_delta);
@@ skipping 389 matching lines @@
   void AfterTest() override { EXPECT_GT(continuous_draws_, 5); }
 
   FakeContentLayerClient client_;
   int step_;
   int continuous_draws_;
   base::WaitableEvent playback_allowed_event_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousDrawWhenCreatingVisibleTiles);
 
-class LayerTreeHostTestOneActivatePerManageTiles : public LayerTreeHostTest {
+class LayerTreeHostTestOneActivatePerPrepareTiles : public LayerTreeHostTest {
  public:
-  LayerTreeHostTestOneActivatePerManageTiles()
-      : notify_ready_to_activate_count_(0u), scheduled_manage_tiles_count_(0) {}
+  LayerTreeHostTestOneActivatePerPrepareTiles()
+      : notify_ready_to_activate_count_(0u),
+        scheduled_prepare_tiles_count_(0) {}
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
     scoped_refptr<FakePictureLayer> root_layer =
         FakePictureLayer::Create(&client_);
     root_layer->SetBounds(gfx::Size(1500, 1500));
     root_layer->SetIsDrawable(true);
 
     layer_tree_host()->SetRootLayer(root_layer);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(16, 16));
     PostSetNeedsCommitToMainThread();
   }
 
   void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
                                    bool success) override {
     ASSERT_TRUE(success);
     host_impl->tile_manager()->SetScheduledRasterTaskLimitForTesting(1);
   }
 
   void NotifyReadyToActivateOnThread(LayerTreeHostImpl* impl) override {
     ++notify_ready_to_activate_count_;
     EndTestAfterDelayMs(100);
   }
 
-  void ScheduledActionManageTiles() override {
-    ++scheduled_manage_tiles_count_;
+  void ScheduledActionPrepareTiles() override {
+    ++scheduled_prepare_tiles_count_;
   }
 
   void AfterTest() override {
-    // Expect at most a notification for each scheduled manage tiles, plus one
+    // Expect at most a notification for each scheduled prepare tiles, plus one
     // for the initial commit (which doesn't go through scheduled actions).
     // The reason this is not an equality is because depending on timing, we
-    // might get a manage tiles but not yet get a notification that we're
+    // might get a prepare tiles but not yet get a notification that we're
     // ready to activate. The intent of a test is to ensure that we don't
-    // get more than one notification per manage tiles, so this is OK.
+    // get more than one notification per prepare tiles, so this is OK.
     EXPECT_LE(notify_ready_to_activate_count_,
-              1u + scheduled_manage_tiles_count_);
+              1u + scheduled_prepare_tiles_count_);
   }
 
  protected:
   FakeContentLayerClient client_;
   size_t notify_ready_to_activate_count_;
-  size_t scheduled_manage_tiles_count_;
+  size_t scheduled_prepare_tiles_count_;
 };
 
-MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestOneActivatePerManageTiles);
+MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestOneActivatePerPrepareTiles);
 
 }  // namespace cc