cc: Introduce CompositorMode enum.

The compositor can currently be run in single threaded or threaded mode.
The LayerTreeHost needs to be aware of the mode it is running in for 2
reasons:
1) To safely cast Proxy to SingleThreadProxy to make calls which
are supported only in single threaded mode.
2) To make decisions which require excluding browser compositors which
run only in single threaded mode.

The LayerTreeHost checks if it has the impl task runner to know the
mode of operation. Using the enum will make the purpose of this check
explicit at the call sites and allow the addition of the remote mode to
the compositor which will be run in the renderer but will not have an
impl task runner since all impl thread operations will be run on the
client compositor.

BUG=550687
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1464313007

Cr-Commit-Position: refs/heads/master@{#363708}

2 files changed, 13 insertions, 6 deletions

diff --git a/cc/test/fake_layer_tree_host.cc b/cc/test/fake_layer_tree_host.cc
index 741a1b4..b2b6a3f 100644
--- a/cc/test/fake_layer_tree_host.cc
+++ b/cc/test/fake_layer_tree_host.cc
@@ -10,7 +10,7 @@
 namespace cc {
 FakeLayerTreeHost::FakeLayerTreeHost(FakeLayerTreeHostClient* client,
                                      LayerTreeHost::InitParams* params)
-    : LayerTreeHost(params),
+    : LayerTreeHost(params, CompositorMode::SingleThreaded),
       client_(client),
       host_impl_(*params->settings,
                  &task_runner_provider_,
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index a8241ae..d7f7024 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -678,6 +678,7 @@ class LayerTreeHostForTesting : public LayerTreeHost {
  public:
   static scoped_ptr<LayerTreeHostForTesting> Create(
       TestHooks* test_hooks,
+      CompositorMode mode,
       LayerTreeHostClientForTesting* client,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
@@ -693,11 +694,12 @@ class LayerTreeHostForTesting : public LayerTreeHost {
     params.task_graph_runner = task_graph_runner;
     params.settings = &settings;
     scoped_ptr<LayerTreeHostForTesting> layer_tree_host(
-        new LayerTreeHostForTesting(test_hooks, &params));
+        new LayerTreeHostForTesting(test_hooks, &params, mode));
     scoped_ptr<TaskRunnerProvider> task_runner_provider =
         TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
     scoped_ptr<Proxy> proxy;
-    if (impl_task_runner.get()) {
+    if (mode == CompositorMode::Threaded) {
+      DCHECK(impl_task_runner.get());
       proxy = ThreadProxyForTest::Create(
           test_hooks, layer_tree_host.get(), task_runner_provider.get(),
           std::move(external_begin_frame_source));
@@ -735,8 +737,11 @@ class LayerTreeHostForTesting : public LayerTreeHost {
 
  private:
   LayerTreeHostForTesting(TestHooks* test_hooks,
-                          LayerTreeHost::InitParams* params)
-      : LayerTreeHost(params), test_hooks_(test_hooks), test_started_(false) {}
+                          LayerTreeHost::InitParams* params,
+                          CompositorMode mode)
+      : LayerTreeHost(params, mode),
+        test_hooks_(test_hooks),
+        test_started_(false) {}
 
   TestHooks* test_hooks_;
   bool test_started_;
@@ -915,8 +920,10 @@ void LayerTreeTest::DoBeginTest() {
   }
 
   DCHECK(!impl_thread_ || impl_thread_->task_runner().get());
+  CompositorMode mode =
+      impl_thread_ ? CompositorMode::Threaded : CompositorMode::SingleThreaded;
   layer_tree_host_ = LayerTreeHostForTesting::Create(
-      this, client_.get(), shared_bitmap_manager_.get(),
+      this, mode, client_.get(), shared_bitmap_manager_.get(),
       gpu_memory_buffer_manager_.get(), task_graph_runner_.get(), settings_,
       base::ThreadTaskRunnerHandle::Get(),
       impl_thread_ ? impl_thread_->task_runner() : NULL,