cc/blimp: Set up the framework for LayerTreeTests in remote mode.

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/element_animations.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/switches.h"
-#include "cc/blimp/image_serialization_processor.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/proto/compositor_message_to_impl.pb.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 298 matching lines @@
 
   TestHooks* test_hooks_;
 };
 
 // Adapts LayerTreeHost for test. Injects LayerTreeHostImplForTesting.
 class LayerTreeHostForTesting : public LayerTreeHostInProcess {
  public:
   static std::unique_ptr<LayerTreeHostForTesting> Create(
       TestHooks* test_hooks,
       CompositorMode mode,
-      LayerTreeHostClientForTesting* client,
+      LayerTreeHostClient* client,
+      LayerTreeHostSingleThreadClient* single_thread_client,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       TaskGraphRunner* task_graph_runner,
       const LayerTreeSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
     LayerTreeHostInProcess::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;
 
     params.animation_host =
         AnimationHost::CreateForTesting(ThreadInstance::MAIN);
     std::unique_ptr<LayerTreeHostForTesting> layer_tree_host(
         new LayerTreeHostForTesting(test_hooks, &params, mode));
     std::unique_ptr<TaskRunnerProvider> task_runner_provider =
         TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
     std::unique_ptr<Proxy> proxy;
     switch (mode) {
       case CompositorMode::SINGLE_THREADED:
-        proxy = SingleThreadProxy::Create(layer_tree_host.get(), client,
+        proxy = SingleThreadProxy::Create(layer_tree_host.get(),
+                                          single_thread_client,
                                           task_runner_provider.get());
         break;
       case CompositorMode::THREADED:
         DCHECK(impl_task_runner.get());
         proxy = ProxyMain::CreateThreaded(layer_tree_host.get(),
                                           task_runner_provider.get());
         break;
       case CompositorMode::REMOTE:
         NOTREACHED();
     }
@@ skipping 33 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,
+      SharedBitmapManager* shared_bitmap_manager,
+      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+      TaskGraphRunner* task_graph_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
+    std::unique_ptr<FakeImageSerializationProcessor>
+        image_serialization_processor =
+            base::MakeUnique<FakeImageSerializationProcessor>();
+
+    LayerTreeHostRemote::InitParams params;
+    params.client = client;
+    params.main_task_runner = main_task_runner;
+    params.animation_host =
+        AnimationHost::CreateForTesting(ThreadInstance::MAIN);
+    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(shared_bitmap_manager,
+                                gpu_memory_buffer_manager, 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,
+      SharedBitmapManager* shared_bitmap_manager,
+      gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+      TaskGraphRunner* task_graph_runner,
+      const LayerTreeSettings& settings,
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) override {
+    return LayerTreeHostForTesting::Create(
+        test_hooks_, CompositorMode::THREADED, client, nullptr,
+        shared_bitmap_manager, gpu_memory_buffer_manager, task_graph_runner,
+        settings, main_task_runner, impl_task_runner);
+  }
+
+ 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.
   void DisplayReceivedCompositorFrame(const CompositorFrame& frame) override {
     hooks_->DisplayReceivedCompositorFrameOnThread(frame);
   }
@@ skipping 153 matching lines @@
 }
 
 void LayerTreeTest::WillBeginTest() {
   SetVisibleOnLayerTreeHost(true);
 }
 
 void LayerTreeTest::DoBeginTest() {
   client_ = LayerTreeHostClientForTesting::Create(this);
 
   DCHECK(!impl_thread_ || impl_thread_->task_runner().get());
-  layer_tree_host_ = LayerTreeHostForTesting::Create(
-      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() : nullptr);
+
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner =
+      base::ThreadTaskRunnerHandle::Get();
+  scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner =
+      impl_thread_ ? impl_thread_->task_runner() : nullptr;
+  if (IsRemoteTest()) {
+    std::unique_ptr<LayerTreeHostRemoteForLayerTreeTest>
+        layer_tree_host_remote = LayerTreeHostRemoteForLayerTreeTest::Create(
+            this, client_.get(), &settings_, shared_bitmap_manager_.get(),
+            gpu_memory_buffer_manager_.get(), task_graph_runner_.get(),
+            main_task_runner, impl_task_runner);
+    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(),
+            shared_bitmap_manager_.get(), gpu_memory_buffer_manager_.get(),
+            task_graph_runner_.get(), settings_, main_task_runner,
+            impl_task_runner);
+    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 11 matching lines @@
   beginning_ = true;
   SetupTree();
   WillBeginTest();
   BeginTest();
   beginning_ = false;
   if (end_when_begin_returns_)
     RealEndTest();
 
   // Allow commits to happen once BeginTest() has had a chance to post tasks
   // so that those tasks will happen before the first commit.
-  if (layer_tree_host_) {
-    static_cast<LayerTreeHostForTesting*>(layer_tree_host_.get())
+  if (layer_tree_host_in_process_) {
+    static_cast<LayerTreeHostForTesting*>(layer_tree_host_in_process_)
         ->set_test_started(true);
   }
 }
 
 void LayerTreeTest::SetupTree() {
   if (!layer_tree()->root_layer()) {
     scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetBounds(gfx::Size(1, 1));
     layer_tree()->SetRootLayer(root_layer);
   }
 
   gfx::Size root_bounds = layer_tree()->root_layer()->bounds();
   gfx::Size device_root_bounds =
       gfx::ScaleToCeiledSize(root_bounds, layer_tree()->device_scale_factor());
   layer_tree()->SetViewportSize(device_root_bounds);
   layer_tree()->root_layer()->SetIsDrawable(true);
 }
 
 void LayerTreeTest::Timeout() {
   timed_out_ = true;
   EndTest();
 }
 
 void LayerTreeTest::RealEndTest() {
   // TODO(mithro): Make this method only end when not inside an impl frame.
-  bool main_frame_will_happen;
-    main_frame_will_happen =
-        layer_tree_host_ ? proxy()->MainFrameWillHappenForTesting() : false;
+  bool main_frame_will_happen = layer_tree_host_in_process_
+                                    ? layer_tree_host_in_process_->proxy()
+                                          ->MainFrameWillHappenForTesting()
+                                    : false;
 
   if (main_frame_will_happen && !timed_out_) {
     main_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&LayerTreeTest::RealEndTest, main_thread_weak_ptr_));
     return;
   }
 
   base::MessageLoop::current()->QuitWhenIdle();
 }
@@ skipping 140 matching lines @@
 std::unique_ptr<OutputSurface> LayerTreeTest::CreateDisplayOutputSurface(
     scoped_refptr<ContextProvider> compositor_context_provider) {
   // By default the Display shares a context with the LayerTreeHostImpl.
   return FakeOutputSurface::Create3d(std::move(compositor_context_provider));
 }
 
 void LayerTreeTest::DestroyLayerTreeHost() {
   if (layer_tree_host_ && layer_tree_host_->GetLayerTree()->root_layer())
     layer_tree_host_->GetLayerTree()->root_layer()->SetLayerTreeHost(NULL);
   layer_tree_host_ = nullptr;
+  layer_tree_host_in_process_ = nullptr;
 }
 
 TaskRunnerProvider* LayerTreeTest::task_runner_provider() const {
   LayerTreeHost* host = layer_tree_host_.get();
 
   // If this fails, the test has ended and there is no task runners to find
   // anymore.
   DCHECK(host);
 
   return host->GetTaskRunnerProvider();
 }
 
 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_.get();
+  return layer_tree_host_in_process_;
 }
+
+Proxy* LayerTreeTest::proxy() {
+  return layer_tree_host_in_process() ? layer_tree_host_in_process()->proxy()
+                                      : NULL;
+}
+
 }  // namespace cc