Update from https://crrev.com/314320

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 61 matching lines @@
     return make_scoped_ptr(new ThreadProxyForTest(
         test_hooks,
         host,
         main_task_runner,
         impl_task_runner,
         external_begin_frame_source.Pass()));
   }
 
   ~ThreadProxyForTest() override {}
 
-  void test() {
-    test_hooks_->Layout();
-  }
-
  private:
   TestHooks* test_hooks_;
 
+  void WillBeginImplFrame(const BeginFrameArgs& args) override {
+    ThreadProxy::WillBeginImplFrame(args);
+    test_hooks_->WillBeginImplFrame(args);
+  }
+
   void ScheduledActionSendBeginMainFrame() override {
     test_hooks_->ScheduledActionWillSendBeginMainFrame();
     ThreadProxy::ScheduledActionSendBeginMainFrame();
     test_hooks_->ScheduledActionSendBeginMainFrame();
   }
 
   DrawResult ScheduledActionDrawAndSwapIfPossible() override {
     DrawResult result = ThreadProxy::ScheduledActionDrawAndSwapIfPossible();
     test_hooks_->ScheduledActionDrawAndSwapIfPossible();
     return result;
@@ skipping 24 matching lines @@
       LayerTreeHost* host,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
       scoped_ptr<BeginFrameSource> external_begin_frame_source)
       : ThreadProxy(host, main_task_runner,
                     impl_task_runner,
                     external_begin_frame_source.Pass()),
         test_hooks_(test_hooks) {}
 };
 
+// Adapts ThreadProxy for test. Injects test hooks for testing.
+class SingleThreadProxyForTest : public SingleThreadProxy {
+ public:
+  static scoped_ptr<Proxy> Create(
+      TestHooks* test_hooks,
+      LayerTreeHost* host,
+      LayerTreeHostSingleThreadClient* client,
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+      scoped_ptr<BeginFrameSource> external_begin_frame_source) {
+    return make_scoped_ptr(new SingleThreadProxyForTest(
+        test_hooks, host, client, main_task_runner,
+        external_begin_frame_source.Pass()));
+  }
+
+  ~SingleThreadProxyForTest() override {}
+
+ private:
+  TestHooks* test_hooks_;
+
+  void WillBeginImplFrame(const BeginFrameArgs& args) override {
+    SingleThreadProxy::WillBeginImplFrame(args);
+    test_hooks_->WillBeginImplFrame(args);
+  }
+
+  void ScheduledActionSendBeginMainFrame() override {
+    test_hooks_->ScheduledActionWillSendBeginMainFrame();
+    SingleThreadProxy::ScheduledActionSendBeginMainFrame();
+    test_hooks_->ScheduledActionSendBeginMainFrame();
+  }
+
+  DrawResult ScheduledActionDrawAndSwapIfPossible() override {
+    DrawResult result =
+        SingleThreadProxy::ScheduledActionDrawAndSwapIfPossible();
+    test_hooks_->ScheduledActionDrawAndSwapIfPossible();
+    return result;
+  }
+
+  void ScheduledActionAnimate() override {
+    SingleThreadProxy::ScheduledActionAnimate();
+    test_hooks_->ScheduledActionAnimate();
+  }
+
+  void ScheduledActionCommit() override {
+    SingleThreadProxy::ScheduledActionCommit();
+    test_hooks_->ScheduledActionCommit();
+  }
+
+  void ScheduledActionBeginOutputSurfaceCreation() override {
+    SingleThreadProxy::ScheduledActionBeginOutputSurfaceCreation();
+    test_hooks_->ScheduledActionBeginOutputSurfaceCreation();
+  }
+
+  void ScheduledActionPrepareTiles() override {
+    SingleThreadProxy::ScheduledActionPrepareTiles();
+    test_hooks_->ScheduledActionPrepareTiles();
+  }
+
+  SingleThreadProxyForTest(
+      TestHooks* test_hooks,
+      LayerTreeHost* host,
+      LayerTreeHostSingleThreadClient* client,
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+      scoped_ptr<BeginFrameSource> external_begin_frame_source)
+      : SingleThreadProxy(host, client, main_task_runner,
+                          external_begin_frame_source.Pass()),
+        test_hooks_(test_hooks) {}
+};
+
 // Adapts LayerTreeHostImpl for test. Runs real code, then invokes test hooks.
 class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
  public:
   static scoped_ptr<LayerTreeHostImplForTesting> Create(
       TestHooks* test_hooks,
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* host_impl_client,
       Proxy* proxy,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
@@ skipping 252 matching lines @@
     scoped_ptr<LayerTreeHostForTesting> layer_tree_host(
         new LayerTreeHostForTesting(test_hooks, client, settings));
     if (impl_task_runner.get()) {
       layer_tree_host->InitializeForTesting(
           ThreadProxyForTest::Create(test_hooks,
                                      layer_tree_host.get(),
                                      main_task_runner,
                                      impl_task_runner,
                                      external_begin_frame_source.Pass()));
     } else {
-      layer_tree_host->InitializeForTesting(SingleThreadProxy::Create(
-          layer_tree_host.get(),
-          client,
-          main_task_runner,
-          external_begin_frame_source.Pass()));
+      layer_tree_host->InitializeForTesting(
+          SingleThreadProxyForTest::Create(
+              test_hooks,
+              layer_tree_host.get(),
+              client,
+              main_task_runner,
+              external_begin_frame_source.Pass()));
     }
     return layer_tree_host.Pass();
   }
 
   scoped_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* host_impl_client) override {
     return LayerTreeHostImplForTesting::Create(
         test_hooks_,
         settings(),
         host_impl_client,
         proxy(),
         shared_bitmap_manager_.get(),
         gpu_memory_buffer_manager_.get(),
         rendering_stats_instrumentation());
   }
 
   void SetNeedsCommit() override {
     if (!test_started_)
       return;
     LayerTreeHost::SetNeedsCommit();
   }
 
   void set_test_started(bool started) { test_started_ = started; }
 
-  void DidDeferCommit() override { test_hooks_->DidDeferCommit(); }
-
  private:
   LayerTreeHostForTesting(TestHooks* test_hooks,
                           LayerTreeHostClient* client,
                           const LayerTreeSettings& settings)
       : LayerTreeHost(client, NULL, NULL, settings),
         shared_bitmap_manager_(new TestSharedBitmapManager),
         gpu_memory_buffer_manager_(new TestGpuMemoryBufferManager),
         test_hooks_(test_hooks),
         test_started_(false) {}
 
@@ skipping 71 matching lines @@
 void LayerTreeTest::PostAddLongAnimationToMainThread(
     Layer* layer_to_receive_animation) {
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchAddAnimation,
                  main_thread_weak_ptr_,
                  base::Unretained(layer_to_receive_animation),
                  1.0));
 }
 
+void LayerTreeTest::PostSetDeferCommitsToMainThread(bool defer_commits) {
+  main_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&LayerTreeTest::DispatchSetDeferCommits,
+                 main_thread_weak_ptr_, defer_commits));
+}
+
 void LayerTreeTest::PostSetNeedsCommitToMainThread() {
   main_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&LayerTreeTest::DispatchSetNeedsCommit,
                                          main_thread_weak_ptr_));
 }
 
 void LayerTreeTest::PostSetNeedsUpdateLayersToMainThread() {
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchSetNeedsUpdateLayers,
@@ skipping 111 matching lines @@
 void LayerTreeTest::DispatchAddAnimation(Layer* layer_to_receive_animation,
                                          double animation_duration) {
   DCHECK(!proxy() || proxy()->IsMainThread());
 
   if (layer_to_receive_animation) {
     AddOpacityTransitionToLayer(
         layer_to_receive_animation, animation_duration, 0, 0.5, true);
   }
 }
 
+void LayerTreeTest::DispatchSetDeferCommits(bool defer_commits) {
+  DCHECK(!proxy() || proxy()->IsMainThread());
+
+  if (layer_tree_host_)
+    layer_tree_host_->SetDeferCommits(defer_commits);
+}
+
 void LayerTreeTest::DispatchSetNeedsCommit() {
   DCHECK(!proxy() || proxy()->IsMainThread());
 
   if (layer_tree_host_)
     layer_tree_host_->SetNeedsCommit();
 }
 
 void LayerTreeTest::DispatchSetNeedsUpdateLayers() {
   DCHECK(!proxy() || proxy()->IsMainThread());
 
@@ skipping 123 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