cc: Split Proxy and TaskRunnerProvider for the LayerTreeHost

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 "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 100 matching lines @@
   host_impl->LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
       tile_task_worker_pool, resource_pool);
 }
 
 // Adapts ThreadProxy for test. Injects test hooks for testing.
 class ThreadProxyForTest : public ThreadProxy {
  public:
   static scoped_ptr<Proxy> Create(
       TestHooks* test_hooks,
       LayerTreeHost* host,
-      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
+      TaskRunnerProvider* task_runner_provider,
       scoped_ptr<BeginFrameSource> external_begin_frame_source) {
-    return make_scoped_ptr(new ThreadProxyForTest(
-        test_hooks,
-        host,
-        main_task_runner,
-        impl_task_runner,
-        external_begin_frame_source.Pass()));
+    return make_scoped_ptr(
+        new ThreadProxyForTest(test_hooks, host, task_runner_provider,
+                               external_begin_frame_source.Pass()));
   }
 
   ~ThreadProxyForTest() override {}
 
  private:
   TestHooks* test_hooks_;
 
   void SetNeedsUpdateLayers() override {
     ThreadProxy::SetNeedsUpdateLayers();
     test_hooks_->DidSetNeedsUpdateLayers();
@@ skipping 188 matching lines @@
     ThreadProxy::PostFrameTimingEventsOnMain(composite_events.Pass(),
                                              main_frame_events.Pass());
   }
 
   void BeginMainFrame(scoped_ptr<BeginMainFrameAndCommitState>
                           begin_main_frame_state) override {
     test_hooks_->ReceivedBeginMainFrame();
     ThreadProxy::BeginMainFrame(begin_main_frame_state.Pass());
   };
 
-  ThreadProxyForTest(
-      TestHooks* test_hooks,
-      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,
+  ThreadProxyForTest(TestHooks* test_hooks,
+                     LayerTreeHost* host,
+                     TaskRunnerProvider* task_runner_provider,
+                     scoped_ptr<BeginFrameSource> external_begin_frame_source)
+      : ThreadProxy(host,
+                    task_runner_provider,
                     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,
+      TaskRunnerProvider* task_runner_provider,
       scoped_ptr<BeginFrameSource> external_begin_frame_source) {
     return make_scoped_ptr(new SingleThreadProxyForTest(
-        test_hooks, host, client, main_task_runner,
+        test_hooks, host, client, task_runner_provider,
         external_begin_frame_source.Pass()));
   }
 
   ~SingleThreadProxyForTest() override {}
 
  private:
   TestHooks* test_hooks_;
 
   void ScheduledActionSendBeginMainFrame() override {
     test_hooks_->ScheduledActionWillSendBeginMainFrame();
@@ skipping 35 matching lines @@
 
   void SendBeginMainFrameNotExpectedSoon() override {
     SingleThreadProxy::SendBeginMainFrameNotExpectedSoon();
     test_hooks_->SendBeginMainFrameNotExpectedSoon();
   }
 
   SingleThreadProxyForTest(
       TestHooks* test_hooks,
       LayerTreeHost* host,
       LayerTreeHostSingleThreadClient* client,
-      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+      TaskRunnerProvider* task_runner_provider,
       scoped_ptr<BeginFrameSource> external_begin_frame_source)
-      : SingleThreadProxy(host, client, main_task_runner,
+      : SingleThreadProxy(host,
+                          client,
+                          task_runner_provider,
                           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,
+      TaskRunnerProvider* task_runner_provider,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       RenderingStatsInstrumentation* stats_instrumentation) {
     return make_scoped_ptr(new LayerTreeHostImplForTesting(
-        test_hooks, settings, host_impl_client, proxy, shared_bitmap_manager,
-        gpu_memory_buffer_manager, task_graph_runner, stats_instrumentation));
+        test_hooks, settings, host_impl_client, task_runner_provider,
+        shared_bitmap_manager, gpu_memory_buffer_manager, task_graph_runner,
+        stats_instrumentation));
   }
 
  protected:
   LayerTreeHostImplForTesting(
       TestHooks* test_hooks,
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* host_impl_client,
-      Proxy* proxy,
+      TaskRunnerProvider* task_runner_provider,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       RenderingStatsInstrumentation* stats_instrumentation)
       : LayerTreeHostImpl(settings,
                           host_impl_client,
-                          proxy,
+                          task_runner_provider,
                           stats_instrumentation,
                           shared_bitmap_manager,
                           gpu_memory_buffer_manager,
                           task_graph_runner,
                           0),
         test_hooks_(test_hooks),
         block_notify_ready_to_activate_for_testing_(false),
         notify_ready_to_activate_was_blocked_(false) {}
 
   void CreateResourceAndTileTaskWorkerPool(
@@ skipping 234 matching lines @@
       scoped_ptr<BeginFrameSource> external_begin_frame_source) {
     LayerTreeHost::InitParams params;
     params.client = client;
     params.shared_bitmap_manager = shared_bitmap_manager;
     params.gpu_memory_buffer_manager = gpu_memory_buffer_manager;
     params.task_graph_runner = task_graph_runner;
     params.settings = &settings;
     scoped_ptr<LayerTreeHostForTesting> layer_tree_host(
         new LayerTreeHostForTesting(test_hooks, &params));
     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()));
+      scoped_ptr<TaskRunnerProvider> task_runner_provider =
+          TaskRunnerProvider::Create(main_task_runner, impl_task_runner);

[vmpstr, 2015/11/10 21:59:34]

Can you rework this a bit to highlight the differences?

something like:

scoped_ptr<TaskRunnerProvider> task_runner_provider = ...
scoped_ptr<Proxy> proxy;
if (impl_task_runner.get()) {
  proxy = ...
} else {
  proxy = ...
}
layer_tree_host->InitializeForTesting(...);

[Khushal, 2015/11/10 23:34:03]

Done.

+      scoped_ptr<Proxy> proxy = ThreadProxyForTest::Create(
+          test_hooks, layer_tree_host.get(), task_runner_provider.get(),
+          external_begin_frame_source.Pass());
+      layer_tree_host->InitializeForTesting(task_runner_provider.Pass(),
+                                            proxy.Pass());
     } else {
-      layer_tree_host->InitializeForTesting(
-          SingleThreadProxyForTest::Create(
-              test_hooks,
-              layer_tree_host.get(),
-              client,
-              main_task_runner,
-              external_begin_frame_source.Pass()));
+      scoped_ptr<TaskRunnerProvider> task_runner_provider =
+          TaskRunnerProvider::Create(main_task_runner, nullptr);
+      scoped_ptr<Proxy> proxy = SingleThreadProxyForTest::Create(
+          test_hooks, layer_tree_host.get(), client, task_runner_provider.get(),
+          external_begin_frame_source.Pass());
+      layer_tree_host->InitializeForTesting(task_runner_provider.Pass(),
+                                            proxy.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(),
+        test_hooks_, settings(), host_impl_client, task_runner_provider(),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
         task_graph_runner(), rendering_stats_instrumentation());
   }
 
   void SetNeedsCommit() override {
     if (!test_started_)
       return;
     LayerTreeHost::SetNeedsCommit();
   }
 
@@ skipping 239 matching lines @@
         FROM_HERE,
         base::Bind(&LayerTreeTest::RealEndTest, main_thread_weak_ptr_));
     return;
   }
 
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
 void LayerTreeTest::DispatchAddAnimation(Layer* layer_to_receive_animation,
                                          double animation_duration) {
-  DCHECK(!proxy() || proxy()->IsMainThread());
+  DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread());
 
   if (layer_to_receive_animation) {
     AddOpacityTransitionToLayer(
         layer_to_receive_animation, animation_duration, 0, 0.5, true);
   }
 }
 
 void LayerTreeTest::DispatchAddAnimationToPlayer(
     AnimationPlayer* player_to_receive_animation,
     double animation_duration) {
-  DCHECK(!proxy() || proxy()->IsMainThread());
+  DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread());
 
   if (player_to_receive_animation) {
     AddOpacityTransitionToPlayer(player_to_receive_animation,
                                  animation_duration, 0, 0.5, true);
   }
 }
 
 void LayerTreeTest::DispatchSetDeferCommits(bool defer_commits) {
-  DCHECK(!proxy() || proxy()->IsMainThread());
+  DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread());
 
   if (layer_tree_host_)
     layer_tree_host_->SetDeferCommits(defer_commits);
 }
 
 void LayerTreeTest::DispatchSetNeedsCommit() {
-  DCHECK(!proxy() || proxy()->IsMainThread());
+  DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread());
 
   if (layer_tree_host_)
     layer_tree_host_->SetNeedsCommit();
 }
 
 void LayerTreeTest::DispatchSetNeedsUpdateLayers() {
-  DCHECK(!proxy() || proxy()->IsMainThread());
+  DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread());
 
   if (layer_tree_host_)
     layer_tree_host_->SetNeedsUpdateLayers();
 }
 
 void LayerTreeTest::DispatchSetNeedsRedraw() {
-  DCHECK(!proxy() || proxy()->IsMainThread());
+  DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread());
 
   if (layer_tree_host_)
     layer_tree_host_->SetNeedsRedraw();
 }
 
 void LayerTreeTest::DispatchSetNeedsRedrawRect(const gfx::Rect& damage_rect) {
-  DCHECK(!proxy() || proxy()->IsMainThread());
+  DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread());
 
   if (layer_tree_host_)
     layer_tree_host_->SetNeedsRedrawRect(damage_rect);
 }
 
 void LayerTreeTest::DispatchSetVisible(bool visible) {
-  DCHECK(!proxy() || proxy()->IsMainThread());
+  DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread());
   if (layer_tree_host_)
     layer_tree_host_->SetVisible(visible);
 }
 
 void LayerTreeTest::DispatchSetNextCommitForcesRedraw() {
-  DCHECK(!proxy() || proxy()->IsMainThread());
+  DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread());
 
   if (layer_tree_host_)
     layer_tree_host_->SetNextCommitForcesRedraw();
 }
 
 void LayerTreeTest::DispatchCompositeImmediately() {
-  DCHECK(!proxy() || proxy()->IsMainThread());
+  DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread());
   if (layer_tree_host_)
     layer_tree_host_->Composite(base::TimeTicks::Now());
 }
 
 void LayerTreeTest::RunTest(bool threaded, bool delegating_renderer) {
   if (threaded) {
     impl_thread_.reset(new base::Thread("Compositor"));
     ASSERT_TRUE(impl_thread_->Start());
   }
 
@@ skipping 78 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;
 }
 
 LayerTreeHost* LayerTreeTest::layer_tree_host() {
-  // We check for a null proxy here as we sometimes ask for the layer tree host
-  // when the proxy does not exist, often for checking settings after a test has
-  // completed. For example, LTHPixelResourceTest::RunPixelResourceTest. See
-  // elsewhere in this file for other examples.
-  DCHECK(!proxy() || proxy()->IsMainThread() || proxy()->IsMainThreadBlocked());
+  // We check for a null task_runner_provider here as we sometimes ask for the
+  // layer tree host when the task_runner_provider does not exist, often for
+  // checking settings after a test has completed. For example,
+  // LTHPixelResourceTest::RunPixelResourceTest. See elsewhere in this file for
+  // other examples.
+  DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread() ||
+         task_runner_provider()->IsMainThreadBlocked());
   return layer_tree_host_.get();
 }
 
 }  // namespace cc