Update from https://crrev.com/304418

cc/test/layer_tree_test.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/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 51 matching lines @@
       : milliseconds_per_frame_(1000.0 / refresh_rate),
         is_ready_(false),
         weak_ptr_factory_(this) {
     DetachFromThread();
   }
 
   virtual ~ExternalBeginFrameSourceForTest() {
     DCHECK(CalledOnValidThread());
   }
 
-  virtual void OnNeedsBeginFramesChange(bool needs_begin_frames) override {
+  void OnNeedsBeginFramesChange(bool needs_begin_frames) override {
     DCHECK(CalledOnValidThread());
     if (needs_begin_frames) {
       base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ExternalBeginFrameSourceForTest::TestOnBeginFrame,
                    weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(milliseconds_per_frame_));
     }
   }
 
-  virtual void SetClientReady() override {
+  void SetClientReady() override {
     DCHECK(CalledOnValidThread());
     is_ready_ = true;
   }
 
   bool is_ready() const {
     return is_ready_;
   }
 
   void TestOnBeginFrame() {
     DCHECK(CalledOnValidThread());
@@ skipping 158 matching lines @@
 
   void DidSwapBuffersComplete() override {
     LayerTreeHostImpl::DidSwapBuffersComplete();
     test_hooks_->SwapBuffersCompleteOnThread(this);
   }
 
   void ReclaimResources(const CompositorFrameAck* ack) override {
     LayerTreeHostImpl::ReclaimResources(ack);
   }
 
-  void UpdateVisibleTiles() override {
-    LayerTreeHostImpl::UpdateVisibleTiles();
-    test_hooks_->UpdateVisibleTilesOnThread(this);
-  }
-
   void NotifyReadyToActivate() override {
     if (block_notify_ready_to_activate_for_testing_) {
       notify_ready_to_activate_was_blocked_ = true;
     } else {
-      client_->NotifyReadyToActivate();
+      LayerTreeHostImpl::NotifyReadyToActivate();
       test_hooks_->NotifyReadyToActivateOnThread(this);
     }
   }
 
   void NotifyReadyToDraw() override {
-    client_->NotifyReadyToDraw();
+    LayerTreeHostImpl::NotifyReadyToDraw();
     test_hooks_->NotifyReadyToDrawOnThread(this);
   }
 
   void BlockNotifyReadyToActivateForTesting(bool block) override {
     CHECK(settings().impl_side_painting);
     CHECK(proxy()->ImplThreadTaskRunner())
         << "Not supported for single-threaded mode.";
     block_notify_ready_to_activate_for_testing_ = block;
     if (!block && notify_ready_to_activate_was_blocked_) {
       NotifyReadyToActivate();
@@ skipping 32 matching lines @@
         active_animation_controllers().begin();
     for (; iter != active_animation_controllers().end(); ++iter) {
       if (iter->second->HasActiveAnimation()) {
         has_unfinished_animation = true;
         break;
       }
     }
     test_hooks_->UpdateAnimationState(this, has_unfinished_animation);
   }
 
+  void NotifyTileStateChanged(const Tile* tile) override {
+    LayerTreeHostImpl::NotifyTileStateChanged(tile);
+    test_hooks_->NotifyTileStateChangedOnThread(this, tile);
+  }
+
  private:
   TestHooks* test_hooks_;
   bool block_notify_ready_to_activate_for_testing_;
   bool notify_ready_to_activate_was_blocked_;
 };
 
 // Implementation of LayerTreeHost callback interface.
 class LayerTreeHostClientForTesting : public LayerTreeHostClient,
                                       public LayerTreeHostSingleThreadClient {
  public:
@@ skipping 166 matching lines @@
   // that the test should end the second BeginTest regains control.
   if (beginning_) {
     end_when_begin_returns_ = true;
   } else {
     main_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeTest::RealEndTest, main_thread_weak_ptr_));
   }
 }
 
-void LayerTreeTest::EndTestAfterDelay(int delay_milliseconds) {
+void LayerTreeTest::EndTestAfterDelayMs(int delay_milliseconds) {
   main_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&LayerTreeTest::EndTest, main_thread_weak_ptr_),
       base::TimeDelta::FromMilliseconds(delay_milliseconds));
 }
 
 void LayerTreeTest::PostAddAnimationToMainThread(
     Layer* layer_to_receive_animation) {
   main_task_runner_->PostTask(
       FROM_HERE,
@@ skipping 295 matching lines @@
   return -1;
 }
 
 void LayerTreeTest::DestroyLayerTreeHost() {
   if (layer_tree_host_ && layer_tree_host_->root_layer())
     layer_tree_host_->root_layer()->SetLayerTreeHost(NULL);
   layer_tree_host_ = nullptr;
 }
 
 }  // namespace cc