cc: Remove all blimp code from cc.

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/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/switches.h"
-#include "cc/blimp/remote_compositor_bridge.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/output/buffer_to_texture_target_map.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/begin_frame_args_test.h"
-#include "cc/test/fake_image_serialization_processor.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
-#include "cc/test/layer_tree_host_remote_for_testing.h"
 #include "cc/test/test_compositor_frame_sink.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_host_single_thread_client.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/proxy_impl.h"
 #include "cc/trees/proxy_main.h"
 #include "cc/trees/single_thread_proxy.h"
@@ skipping 323 matching lines @@
       case CompositorMode::SINGLE_THREADED:
         proxy = SingleThreadProxy::Create(layer_tree_host.get(),
                                           single_thread_client,
                                           task_runner_provider.get());
         break;
       case CompositorMode::THREADED:
         DCHECK(impl_task_runner.get());
         proxy = base::MakeUnique<ProxyMain>(layer_tree_host.get(),
                                             task_runner_provider.get());
         break;
-      case CompositorMode::REMOTE:
-        NOTREACHED();
     }
     layer_tree_host->InitializeForTesting(std::move(task_runner_provider),
                                           std::move(proxy));
     return layer_tree_host;
   }
 
   std::unique_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* host_impl_client) override {
     std::unique_ptr<LayerTreeHostImpl> host_impl =
         LayerTreeHostImplForTesting::Create(
@@ skipping 23 matching lines @@
                           LayerTreeHostInProcess::InitParams* params,
                           CompositorMode mode)
       : LayerTreeHostInProcess(params, mode),
         test_hooks_(test_hooks),
         test_started_(false) {}
 
   TestHooks* test_hooks_;
   bool test_started_;
 };
 
-// Adapts the LayerTreeHostRemoteForTesting to inject the
-// LayerTreeHostInProcess.
-class LayerTreeHostRemoteForLayerTreeTest
-    : public LayerTreeHostRemoteForTesting {
- public:
-  static std::unique_ptr<LayerTreeHostRemoteForLayerTreeTest> Create(
-      TestHooks* test_hooks,
-      LayerTreeHostClient* client,
-      LayerTreeSettings const* settings,
-      TaskGraphRunner* task_graph_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
-      MutatorHost* mutator_host) {
-    std::unique_ptr<FakeImageSerializationProcessor>
-        image_serialization_processor =
-            base::MakeUnique<FakeImageSerializationProcessor>();
-
-    LayerTreeHostRemote::InitParams params;
-    params.client = client;
-    params.main_task_runner = main_task_runner;
-    params.mutator_host = mutator_host;
-    params.remote_compositor_bridge =
-        CreateRemoteCompositorBridge(main_task_runner);
-    params.engine_picture_cache =
-        image_serialization_processor->CreateEnginePictureCache();
-    params.settings = settings;
-
-    std::unique_ptr<LayerTreeHostRemoteForLayerTreeTest> layer_tree_host =
-        base::WrapUnique(
-            new LayerTreeHostRemoteForLayerTreeTest(&params, test_hooks));
-    layer_tree_host->Initialize(task_graph_runner, main_task_runner,
-                                impl_task_runner,
-                                std::move(image_serialization_processor));
-    return layer_tree_host;
-  }
-
-  ~LayerTreeHostRemoteForLayerTreeTest() override = default;
-
-  std::unique_ptr<LayerTreeHostInProcess> CreateLayerTreeHostInProcess(
-      LayerTreeHostClient* client,
-      TaskGraphRunner* task_graph_runner,
-      const LayerTreeSettings& settings,
-      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
-      MutatorHost* mutator_host) override {
-    return LayerTreeHostForTesting::Create(
-        test_hooks_, CompositorMode::THREADED, client, nullptr,
-        task_graph_runner, settings, main_task_runner, impl_task_runner,
-        mutator_host);
-  }
-
- private:
-  LayerTreeHostRemoteForLayerTreeTest(InitParams* params, TestHooks* test_hooks)
-      : LayerTreeHostRemoteForTesting(params), test_hooks_(test_hooks) {}
-
-  TestHooks* test_hooks_;
-};
-
 class LayerTreeTestCompositorFrameSinkClient
     : public TestCompositorFrameSinkClient {
  public:
   explicit LayerTreeTestCompositorFrameSinkClient(TestHooks* hooks)
       : hooks_(hooks) {}
 
   // TestCompositorFrameSinkClient implementation.
   std::unique_ptr<OutputSurface> CreateDisplayOutputSurface(
       scoped_refptr<ContextProvider> compositor_context_provider) override {
     return hooks_->CreateDisplayOutputSurfaceOnThread(
@@ skipping 27 matching lines @@
     timeout_seconds_ = 5;
   if (command_line->HasSwitch(switches::kCCLayerTreeTestLongTimeout))
     timeout_seconds_ = 5 * 60;
 }
 
 LayerTreeTest::~LayerTreeTest() {
   if (animation_host_)
     animation_host_->SetMutatorHostClient(nullptr);
 }
 
-bool LayerTreeTest::IsRemoteTest() const {
-  return mode_ == CompositorMode::REMOTE;
-}
-
 gfx::Vector2dF LayerTreeTest::ScrollDelta(LayerImpl* layer_impl) {
   gfx::ScrollOffset delta =
       layer_impl->layer_tree_impl()
           ->property_trees()
           ->scroll_tree.GetScrollOffsetDeltaForTesting(layer_impl->id());
   return gfx::Vector2dF(delta.x(), delta.y());
 }
 
 void LayerTreeTest::EndTest() {
   if (ended_)
@@ skipping 118 matching lines @@
 
   DCHECK(!impl_thread_ || impl_thread_->task_runner().get());
 
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner =
       base::ThreadTaskRunnerHandle::Get();
   scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner =
       impl_thread_ ? impl_thread_->task_runner() : nullptr;
 
   animation_host_ = AnimationHost::CreateForTesting(ThreadInstance::MAIN);
 
-  if (IsRemoteTest()) {
-    std::unique_ptr<LayerTreeHostRemoteForLayerTreeTest>
-        layer_tree_host_remote = LayerTreeHostRemoteForLayerTreeTest::Create(
-            this, client_.get(), &settings_, task_graph_runner_.get(),
-            main_task_runner, impl_task_runner, animation_host_.get());
-    layer_tree_host_in_process_ =
-        layer_tree_host_remote->layer_tree_host_in_process();
-    layer_tree_host_ = std::move(layer_tree_host_remote);
-  } else {
-    std::unique_ptr<LayerTreeHostForTesting> layer_tree_host_for_testing =
-        LayerTreeHostForTesting::Create(
-            this, mode_, client_.get(), client_.get(), task_graph_runner_.get(),
-            settings_, main_task_runner, impl_task_runner,
-            animation_host_.get());
-    layer_tree_host_in_process_ = layer_tree_host_for_testing.get();
-    layer_tree_host_ = std::move(layer_tree_host_for_testing);
-  }
+  std::unique_ptr<LayerTreeHostForTesting> layer_tree_host_for_testing =
+      LayerTreeHostForTesting::Create(
+          this, mode_, client_.get(), client_.get(), task_graph_runner_.get(),
+          settings_, main_task_runner, impl_task_runner, animation_host_.get());
+  layer_tree_host_in_process_ = layer_tree_host_for_testing.get();
+  layer_tree_host_ = std::move(layer_tree_host_for_testing);
 
   ASSERT_TRUE(layer_tree_host_);
 
   main_task_runner_ =
       layer_tree_host_->GetTaskRunnerProvider()->MainThreadTaskRunner();
   impl_task_runner_ =
       layer_tree_host_->GetTaskRunnerProvider()->ImplThreadTaskRunner();
   if (!impl_task_runner_) {
     // For tests, if there's no impl thread, make things easier by just giving
     // the main thread task runner.
@@ skipping 121 matching lines @@
 }
 
 void LayerTreeTest::DispatchNextCommitWaitsForActivation() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (layer_tree_host_)
     layer_tree_host_->SetNextCommitWaitsForActivation();
 }
 
 void LayerTreeTest::RunTest(CompositorMode mode) {
   mode_ = mode;
-  if (mode_ == CompositorMode::THREADED || mode_ == CompositorMode::REMOTE) {
+  if (mode_ == CompositorMode::THREADED) {
     impl_thread_.reset(new base::Thread("Compositor"));
     ASSERT_TRUE(impl_thread_->Start());
   }
 
   shared_bitmap_manager_.reset(new TestSharedBitmapManager);
   gpu_memory_buffer_manager_.reset(new TestGpuMemoryBufferManager);
   task_graph_runner_.reset(new TestTaskGraphRunner);
 
   // Spend less time waiting for BeginFrame because the output is
   // mocked out.
@@ skipping 80 matching lines @@
 
 LayerTreeHost* LayerTreeTest::layer_tree_host() {
   DCHECK(task_runner_provider()->IsMainThread() ||
          task_runner_provider()->IsMainThreadBlocked());
   return layer_tree_host_.get();
 }
 
 LayerTreeHostInProcess* LayerTreeTest::layer_tree_host_in_process() {
   DCHECK(task_runner_provider()->IsMainThread() ||
          task_runner_provider()->IsMainThreadBlocked());
-  DCHECK(!IsRemoteTest());
   return layer_tree_host_in_process_;
 }
 
 Proxy* LayerTreeTest::proxy() {
   return layer_tree_host_in_process() ? layer_tree_host_in_process()->proxy()
                                       : NULL;
 }
 
 }  // namespace cc