cc:: Add remote mode to the compositor

cc/trees/layer_tree_host.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/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 71 matching lines @@
     InitParams* params) {
   DCHECK(params->settings);
   scoped_ptr<LayerTreeHost> layer_tree_host(
       new LayerTreeHost(params, CompositorMode::SingleThreaded));
   layer_tree_host->InitializeSingleThreaded(
       single_thread_client, params->main_task_runner,
       std::move(params->external_begin_frame_source));
   return layer_tree_host;
 }
 
+scoped_ptr<LayerTreeHost> LayerTreeHost::CreateRemote(
+    RemoteProtoChannel* remote_proto_channel,
+    InitParams* params) {
+  DCHECK(params->main_task_runner.get());
+  DCHECK(params->settings);
+  DCHECK(remote_proto_channel);
+
+  // Using an external begin frame source is not supported in remote mode.
+  DCHECK(!params->settings->use_external_begin_frame_source);
+  DCHECK(!params->external_begin_frame_source);
+
+  scoped_ptr<LayerTreeHost> layer_tree_host(
+      new LayerTreeHost(params, CompositorMode::Remote));
+  layer_tree_host->InitializeRemote(remote_proto_channel,
+                                    params->main_task_runner);
+  return layer_tree_host;
+}
+
+scoped_ptr<LayerTreeHost> LayerTreeHost::CreateDeserializable(
+    scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
+    InitParams* params) {
+  DCHECK(params->settings);
+
+  scoped_ptr<LayerTreeHost> layer_tree_host(
+      new LayerTreeHost(params, CompositorMode::Deserializable));
+  layer_tree_host->InitializeDeserializable(params->main_task_runner,
+                                            impl_task_runner);
+  return layer_tree_host;
+}
+
 LayerTreeHost::LayerTreeHost(InitParams* params, CompositorMode mode)
     : micro_benchmark_controller_(this),
       next_ui_resource_id_(1),
       compositor_mode_(mode),
       needs_full_tree_sync_(true),
       needs_meta_info_recomputation_(true),
       client_(params->client),
       source_frame_number_(0),
       meta_information_sequence_number_(1),
       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
@@ skipping 16 matching lines @@
       has_transparent_background_(false),
       did_complete_scale_animation_(false),
       in_paint_layer_contents_(false),
       id_(s_layer_tree_host_sequence_number.GetNext() + 1),
       next_commit_forces_redraw_(false),
       shared_bitmap_manager_(params->shared_bitmap_manager),
       gpu_memory_buffer_manager_(params->gpu_memory_buffer_manager),
       task_graph_runner_(params->task_graph_runner),
       surface_id_namespace_(0u),
       next_surface_sequence_(1u) {
-  DCHECK(task_graph_runner_);
+  if (compositor_mode_ != CompositorMode::Remote)
+    DCHECK(task_graph_runner_);
 
   if (settings_.accelerated_animation_enabled) {
     if (settings_.use_compositor_animation_timelines) {
       animation_host_ = AnimationHost::Create(ThreadInstance::MAIN);
       animation_host_->SetMutatorHostClient(this);
     } else {
       animation_registrar_ = AnimationRegistrar::Create();
     }
   }
 
@@ skipping 16 matching lines @@
 void LayerTreeHost::InitializeSingleThreaded(
     LayerTreeHostSingleThreadClient* single_thread_client,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
   task_runner_provider_ = TaskRunnerProvider::Create(main_task_runner, nullptr);
   InitializeProxy(SingleThreadProxy::Create(this, single_thread_client,
                                             task_runner_provider_.get()),
                   std::move(external_begin_frame_source));
 }
 
+void LayerTreeHost::InitializeRemote(
+    RemoteProtoChannel* remote_proto_channel,
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner) {
+  task_runner_provider_ = TaskRunnerProvider::Create(main_task_runner, nullptr);
+  InitializeProxy(ProxyMain::CreateRemote(remote_proto_channel, this,
+                                          task_runner_provider_.get()),
+                  nullptr);
+}
+
+void LayerTreeHost::InitializeDeserializable(

[vmpstr, 2016/01/07 19:08:12]

I think the rest of the review kind of depends on me not liking the
deserializable concept... Can we still run it in a remote mode but have a
different channel? Like a threaded channel? Or something similar?

My understanding is that blimp/ code will control the lifetime of this layer
tree host, and call FromProtobuf on it. After that's called, we might as well
treat that layer tree host as a threaded one, no?

[Khushal, 2016/01/08 21:17:19]

Updated this to use the remote mode and the RemoteChannelImpl.
Its basically treated as the the threaded one but we can't use the threaded case
directly. The LayerTreeHostImpl has 2 dependencies, the content which it gets
from the LayerTreeHost on the server, and the output surface and visibility
status, which it needs from the LayerTreeHost on the client.
In the threaded case, both these come from the same LayerTreeHost, via the
LTH->Proxy->ThreadedChannel path. For the remote case, that logic is now
restricted to RemoteChannelImpl. For output surface and visibility, it will send
those requests to the client LayerTreeHost. For commits, it will send them to
the server LayerTreeHost.

+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
+  task_runner_provider_ =
+      TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
+}
+
 void LayerTreeHost::InitializeForTesting(
     scoped_ptr<TaskRunnerProvider> task_runner_provider,
     scoped_ptr<Proxy> proxy_for_testing,
     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
   task_runner_provider_ = std::move(task_runner_provider);
   InitializeProxy(std::move(proxy_for_testing),
                   std::move(external_begin_frame_source));
 }
 
 void LayerTreeHost::SetTaskRunnerProviderForTesting(
     scoped_ptr<TaskRunnerProvider> task_runner_provider) {
   DCHECK(!task_runner_provider_);
   task_runner_provider_ = std::move(task_runner_provider);
 }
 
 void LayerTreeHost::InitializeProxy(
     scoped_ptr<Proxy> proxy,
     scoped_ptr<BeginFrameSource> external_begin_frame_source) {
   TRACE_EVENT0("cc", "LayerTreeHost::InitializeForReal");
+  DCHECK(task_runner_provider_);
 
   proxy_ = std::move(proxy);
   proxy_->Start(std::move(external_begin_frame_source));
   if (settings_.accelerated_animation_enabled) {
     if (animation_host_)
       animation_host_->SetSupportsScrollAnimations(
           proxy_->SupportsImplScrolling());
     else
       animation_registrar_->set_supports_scroll_animations(
           proxy_->SupportsImplScrolling());
@@ skipping 25 matching lines @@
   RegisterViewportLayers(NULL, NULL, NULL, NULL);
 
   if (root_layer_.get()) {
     // The layer tree must be destroyed before the layer tree host. We've
     // made a contract with our animation controllers that the registrar
     // will outlive them, and we must make good.
     root_layer_ = NULL;
   }
 }
 
+void LayerTreeHost::ToProtobuf() {
+  DCHECK(task_runner_provider_->IsMainThread());
+  DCHECK(IsRemote());
+
+  // TODO(khushalsagar, nyquist): Serialize LayerTreeHost state to proto.
+}
+
+void LayerTreeHost::FromProtobuf() {
+  DCHECK(task_runner_provider_->IsMainThread());
+  DCHECK(IsDeserializable());
+
+  // TODO(khushalsagar, nyquist): Deserialize LayerTreeHost state from proto.
+}
+
 void LayerTreeHost::WillBeginMainFrame() {
   devtools_instrumentation::WillBeginMainThreadFrame(id(),
                                                      source_frame_number());
   client_->WillBeginMainFrame();
 }
 
 void LayerTreeHost::DidBeginMainFrame() {
   client_->DidBeginMainFrame();
 }
 
@@ skipping 12 matching lines @@
 void LayerTreeHost::RequestMainFrameUpdate() {
   client_->UpdateLayerTreeHost();
 }
 
 // This function commits the LayerTreeHost to an impl tree. When modifying
 // this function, keep in mind that the function *runs* on the impl thread! Any
 // code that is logically a main thread operation, e.g. deletion of a Layer,
 // should be delayed until the LayerTreeHost::CommitComplete, which will run
 // after the commit, but on the main thread.
 void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
+  DCHECK(!IsRemote());
   DCHECK(task_runner_provider_->IsImplThread());
 
   bool is_new_trace;
   TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
   if (is_new_trace &&
       frame_viewer_instrumentation::IsTracingLayerTreeSnapshots() &&
       root_layer()) {
     LayerTreeHostCommon::CallFunctionForSubtree(
         root_layer(), [](Layer* layer) { layer->DidBeginTracing(); });
   }
@@ skipping 165 matching lines @@
   // Note: It is safe to drop all output surface references here as
   // LayerTreeHostImpl will not keep a pointer to either the old or
   // new output surface after failing to initialize the new one.
   current_output_surface_ = nullptr;
   new_output_surface_ = nullptr;
   client_->DidFailToInitializeOutputSurface();
 }
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHost::CreateLayerTreeHostImpl(
     LayerTreeHostImplClient* client) {
+  DCHECK(!IsRemote());
   DCHECK(task_runner_provider_->IsImplThread());
   scoped_ptr<LayerTreeHostImpl> host_impl = LayerTreeHostImpl::Create(
       settings_, client, task_runner_provider_.get(),
       rendering_stats_instrumentation_.get(), shared_bitmap_manager_,
       gpu_memory_buffer_manager_, task_graph_runner_, id_);
   host_impl->SetHasGpuRasterizationTrigger(has_gpu_rasterization_trigger_);
   host_impl->SetContentIsSuitableForGpuRasterization(
       content_is_suitable_for_gpu_rasterization_);
   shared_bitmap_manager_ = NULL;
   gpu_memory_buffer_manager_ = NULL;
@@ skipping 449 matching lines @@
   if (painted_device_scale_factor == painted_device_scale_factor_)
     return;
   painted_device_scale_factor_ = painted_device_scale_factor;
 
   SetNeedsCommit();
 }
 
 void LayerTreeHost::UpdateTopControlsState(TopControlsState constraints,
                                            TopControlsState current,
                                            bool animate) {
-  // Top controls are only used in threaded mode.
-  DCHECK(IsThreaded());
+  // Top controls are only used in threaded or remote mode.
+  DCHECK(IsThreaded() || IsRemote());
   proxy_->UpdateTopControlsState(constraints, current, animate);
 }
 
 void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
   if (!settings_.accelerated_animation_enabled)
     return;
 
   AnimationEventsVector events;
   if (animation_host_) {
     if (animation_host_->AnimateLayers(monotonic_time))
@@ skipping 342 matching lines @@
          !task_runner_provider_->HasImplThread());
   return compositor_mode_ == CompositorMode::SingleThreaded;
 }
 
 bool LayerTreeHost::IsThreaded() const {
   DCHECK(compositor_mode_ != CompositorMode::Threaded ||
          task_runner_provider_->HasImplThread());
   return compositor_mode_ == CompositorMode::Threaded;
 }
 
+bool LayerTreeHost::IsRemote() const {
+  DCHECK(compositor_mode_ != CompositorMode::Remote ||
+         !task_runner_provider_->HasImplThread());
+  return compositor_mode_ == CompositorMode::Remote;
+}
+
+bool LayerTreeHost::IsDeserializable() const {
+  DCHECK(compositor_mode_ != CompositorMode::Deserializable ||
+         task_runner_provider_->HasImplThread());
+  return compositor_mode_ == CompositorMode::Deserializable;
+}
+
 }  // namespace cc