cc:: Add remote mode to the compositor

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"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/switches.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.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_external_begin_frame_source.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
+#include "cc/test/remote_channel_impl_for_test.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_gpu_memory_buffer_manager.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_task_graph_runner.h"
+#include "cc/test/threaded_channel_for_test.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"
 #include "cc/trees/threaded_channel.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/gfx/geometry/size_conversions.h"
@@ skipping 382 matching lines @@
   TestHooks* test_hooks_;
 };
 
 // Adapts LayerTreeHost for test. Injects LayerTreeHostImplForTesting.
 class LayerTreeHostForTesting : public LayerTreeHost {
  public:
   static scoped_ptr<LayerTreeHostForTesting> Create(
       TestHooks* test_hooks,
       CompositorMode mode,
       LayerTreeHostClientForTesting* client,
+      RemoteProtoChannel* remote_proto_channel,
       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,
       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, mode));
     scoped_ptr<TaskRunnerProvider> task_runner_provider =
         TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
     scoped_ptr<Proxy> proxy;
-    if (mode == CompositorMode::Threaded) {
-      DCHECK(impl_task_runner.get());
-      scoped_ptr<ProxyMain> proxy_main = ProxyMainForTest::CreateThreaded(
-          test_hooks, layer_tree_host.get(), task_runner_provider.get());
-      proxy = std::move(proxy_main);
-    } else {
-      proxy =
-          SingleThreadProxyForTest::Create(test_hooks, layer_tree_host.get(),
-                                           client, task_runner_provider.get());
+    switch (mode) {
+      case CompositorMode::SINGLE_THREADED:
+        proxy = SingleThreadProxyForTest::Create(test_hooks,
+                                                 layer_tree_host.get(), client,
+                                                 task_runner_provider.get());
+        break;
+      case CompositorMode::THREADED:
+        DCHECK(impl_task_runner.get());
+        proxy = ProxyMainForTest::CreateThreaded(
+            test_hooks, layer_tree_host.get(), task_runner_provider.get());
+        break;
+      case CompositorMode::REMOTE:
+        DCHECK(!external_begin_frame_source);
+        if (task_runner_provider->HasImplThread()) {

[ericrk, 2016/01/20 22:32:29]

would it make sense to make IsRemoteClient/IsRemoteServer protected on
LayerTreeHost and just call that here - keeps the somewhat magic HasImplThread
check in one place.

[Khushal, 2016/01/22 01:03:24]

We pass both the task runner provider and the proxy to the layer_tree_host in
InitializeForTesting, so we can't call the IsFoo methods on them here since the
LayerTreeHost would need the taskrunnerprovider for those.
I think this might end up being the only other place where we have to do this
check, since the tests that need to care about the mode are LayerTreeTests. The
other subclasses of the LayerTreeHost used in tests should be agnostic to the
mode the compositor is running in, right?

[ericrk, 2016/01/22 18:36:59]

ok, fair - yeah, as long as we don't have this check all over the place, that
seems fine - and yes, I agree that other parts of the tests would be agnostic to
the mode.

+          // The Remote LayerTreeHost on the client has the impl task runner.
+          proxy = RemoteChannelImplForTest::Create(
+              test_hooks, layer_tree_host.get(), remote_proto_channel,
+              task_runner_provider.get());
+        } else {
+          proxy = ProxyMainForTest::CreateRemote(
+              test_hooks, remote_proto_channel, layer_tree_host.get(),
+              task_runner_provider.get());
+        }
+        break;
+      default:
+        NOTREACHED();
     }
     layer_tree_host->InitializeForTesting(
         std::move(task_runner_provider), std::move(proxy),
         std::move(external_begin_frame_source));
     return layer_tree_host;
   }
 
   scoped_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* host_impl_client) override {
     return LayerTreeHostImplForTesting::Create(
@@ skipping 24 matching lines @@
         test_hooks_(test_hooks),
         test_started_(false) {}
 
   TestHooks* test_hooks_;
   bool test_started_;
 };
 
 LayerTreeTest::LayerTreeTest()
     : output_surface_(nullptr),
       external_begin_frame_source_(nullptr),
+      remote_proto_channel_bridge_(this),
       beginning_(false),
       end_when_begin_returns_(false),
       timed_out_(false),
       scheduled_(false),
       started_(false),
       ended_(false),
       delegating_renderer_(false),
       verify_property_trees_(true),
       timeout_seconds_(0),
       weak_factory_(this) {
   main_thread_weak_ptr_ = weak_factory_.GetWeakPtr();
 
   // Tests should timeout quickly unless --cc-layer-tree-test-no-timeout was
   // specified (for running in a debugger).
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (!command_line->HasSwitch(switches::kCCLayerTreeTestNoTimeout))
     timeout_seconds_ = 5;
 }
 
 LayerTreeTest::~LayerTreeTest() {}
 
+Proxy* LayerTreeTest::remote_client_proxy() const {
+  DCHECK(IsRemoteTest());
+  return remote_client_layer_tree_host_
+             ? remote_client_layer_tree_host_->proxy()
+             : nullptr;
+}
+
+bool LayerTreeTest::IsRemoteTest() const {
+  return mode_ == CompositorMode::REMOTE;
+}
+
 void LayerTreeTest::EndTest() {
   if (ended_)
     return;
   ended_ = true;
 
   // For the case where we EndTest during BeginTest(), set a flag to indicate
   // that the test should end the second BeginTest regains control.
   if (beginning_) {
     end_when_begin_returns_ = true;
   } else {
@@ skipping 123 matching lines @@
 
 void LayerTreeTest::WillBeginTest() {
   layer_tree_host_->SetVisible(true);
 }
 
 void LayerTreeTest::DoBeginTest() {
   client_ = LayerTreeHostClientForTesting::Create(this);
 
   scoped_ptr<FakeExternalBeginFrameSource> external_begin_frame_source;
   if (settings_.use_external_begin_frame_source) {
+    DCHECK(!IsRemoteTest());
     external_begin_frame_source.reset(new FakeExternalBeginFrameSource(
         settings_.renderer_settings.refresh_rate));
     external_begin_frame_source_ = external_begin_frame_source.get();
   }
 
   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() : NULL,
-      std::move(external_begin_frame_source));
+
+  if (IsRemoteTest()) {
+    DCHECK(impl_thread_);
+    layer_tree_host_ = LayerTreeHostForTesting::Create(
+        this, mode_, client_.get(), &remote_proto_channel_bridge_.channel_main,
+        nullptr, nullptr, task_graph_runner_.get(), settings_,
+        base::ThreadTaskRunnerHandle::Get(), nullptr,
+        std::move(external_begin_frame_source));
+    DCHECK(remote_proto_channel_bridge_.channel_main.HasReceiver());
+  } else {
+    layer_tree_host_ = LayerTreeHostForTesting::Create(
+        this, mode_, client_.get(), nullptr, shared_bitmap_manager_.get(),
+        gpu_memory_buffer_manager_.get(), task_graph_runner_.get(), settings_,
+        base::ThreadTaskRunnerHandle::Get(),
+        impl_thread_ ? impl_thread_->task_runner() : NULL,
+        std::move(external_begin_frame_source));
+  }
+
   ASSERT_TRUE(layer_tree_host_);
 
   started_ = true;
   beginning_ = true;
   SetupTree();
   WillBeginTest();
   BeginTest();
   beginning_ = false;
   if (end_when_begin_returns_)
     RealEndTest();
@@ skipping 20 matching lines @@
   layer_tree_host_->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.
-  if (layer_tree_host_ && !timed_out_ &&
-      proxy()->MainFrameWillHappenForTesting()) {
+  bool main_frame_will_happen;
+  if (IsRemoteTest()) {
+    main_frame_will_happen =
+        remote_client_layer_tree_host_
+            ? remote_client_proxy()->MainFrameWillHappenForTesting()
+            : false;
+  } else {
+    main_frame_will_happen =
+        layer_tree_host_ ? 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();
 }
 
 void LayerTreeTest::DispatchAddAnimation(Layer* layer_to_receive_animation,
@@ skipping 66 matching lines @@
 }
 
 void LayerTreeTest::DispatchCompositeImmediately() {
   DCHECK(!task_runner_provider() || task_runner_provider()->IsMainThread());
   if (layer_tree_host_)
     layer_tree_host_->Composite(base::TimeTicks::Now());
 }
 
 void LayerTreeTest::RunTest(CompositorMode mode, bool delegating_renderer) {
   mode_ = mode;
-  if (mode_ == CompositorMode::Threaded) {
+  if (mode_ == CompositorMode::THREADED || mode_ == CompositorMode::REMOTE) {
     impl_thread_.reset(new base::Thread("Compositor"));
     ASSERT_TRUE(impl_thread_->Start());
   }
 
   main_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
   shared_bitmap_manager_.reset(new TestSharedBitmapManager);
   gpu_memory_buffer_manager_.reset(new TestGpuMemoryBufferManager);
   task_graph_runner_.reset(new TestTaskGraphRunner);
 
@@ skipping 69 matching lines @@
   if (impl->active_tree())
     return impl->active_tree()->source_frame_number();
   // Source frames start at 0, so this is invalid.
   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;
+
+  DCHECK(!remote_proto_channel_bridge_.channel_main.HasReceiver());
+
+  // Destroying the LayerTreeHost should destroy the remote client
+  // LayerTreeHost.
+  DCHECK(!remote_client_layer_tree_host_);
+}
+
+void LayerTreeTest::DestroyRemoteClientHost() {
+  DCHECK(IsRemoteTest());
+  DCHECK(remote_client_layer_tree_host_);
+
+  remote_client_layer_tree_host_ = nullptr;
+  DCHECK(!remote_proto_channel_bridge_.channel_impl.HasReceiver());
+}
+
+void LayerTreeTest::CreateRemoteClientHost(
+    const proto::CompositorMessageToImpl& proto) {
+  DCHECK(IsRemoteTest());
+  DCHECK(!remote_client_layer_tree_host_);
+  DCHECK(impl_thread_);
+  DCHECK(proto.message_type() ==
+         proto::CompositorMessageToImpl::INITIALIZE_IMPL);
+
+  proto::InitializeImpl initialize_proto = proto.initialize_impl_message();
+  LayerTreeSettings settings;
+  settings.FromProtobuf(initialize_proto.layer_tree_settings());
+  remote_client_layer_tree_host_ = LayerTreeHostForTesting::Create(
+      this, mode_, client_.get(), &remote_proto_channel_bridge_.channel_impl,
+      nullptr, nullptr, task_graph_runner_.get(), settings,
+      base::ThreadTaskRunnerHandle::Get(), impl_thread_->task_runner(),
+      nullptr);
+
+  DCHECK(remote_proto_channel_bridge_.channel_impl.HasReceiver());
 }
 
 TaskGraphRunner* LayerTreeTest::task_graph_runner() const {
   return task_graph_runner_.get();
 }
 
 LayerTreeHost* LayerTreeTest::layer_tree_host() {
   // 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();
 }
 
 ProxyMainForTest* LayerTreeTest::GetProxyMainForTest() const {
   DCHECK(HasImplThread());
   return static_cast<ProxyMainForTest*>(proxy());
 }
 
 ProxyImplForTest* LayerTreeTest::GetProxyImplForTest() const {
   DCHECK(HasImplThread());
-  ThreadedChannel* threaded_channel =
-      static_cast<ThreadedChannel*>(GetProxyMainForTest()->channel_main());
-  ProxyImpl* proxy_impl = threaded_channel->GetProxyImplForTesting();
+
+  if (IsRemoteTest()) {
+    return GetRemoteChannelImplForTest()->proxy_impl_for_test();
+  }
+
+  ProxyImplForTest* proxy_impl_for_test =
+      GetThreadedChannelForTest()->proxy_impl_for_test();
 
   // We check for null ProxyImpl since ProxyImpl exists in the ThreadedChannel
   // only after it is initialized.
-  DCHECK(proxy_impl);
-  return static_cast<ProxyImplForTest*>(proxy_impl);
+  DCHECK(proxy_impl_for_test);
+  return proxy_impl_for_test;
+}
+
+ThreadedChannelForTest* LayerTreeTest::GetThreadedChannelForTest() const {
+  DCHECK(mode_ == CompositorMode::THREADED);
+
+  return GetProxyMainForTest()->threaded_channel_for_test();
+}
+
+RemoteChannelImplForTest* LayerTreeTest::GetRemoteChannelImplForTest() const {
+  DCHECK(IsRemoteTest());
+  DCHECK(remote_client_layer_tree_host_);
+
+  return static_cast<RemoteChannelImplForTest*>(
+      remote_client_layer_tree_host_->proxy());
 }
 
 }  // namespace cc