Revert of cc: Control defer_commits logic by Scheduler

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(
-          SingleThreadProxyForTest::Create(
-              test_hooks,
-              layer_tree_host.get(),
-              client,
-              main_task_runner,
-              external_begin_frame_source.Pass()));
+      layer_tree_host->InitializeForTesting(SingleThreadProxy::Create(
+          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