Expose Blimp dependencies to the embedder

blimp/client/feature/compositor/blimp_compositor.cc

 // Copyright 2015 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 "blimp/client/feature/compositor/blimp_compositor.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "blimp/client/core/compositor/blimp_compositor_dependencies.h"
 #include "blimp/client/core/compositor/delegated_output_surface.h"
-#include "blimp/client/feature/compositor/blimp_context_provider.h"
+#include "blimp/client/public/compositor/compositor_dependencies.h"
 #include "blimp/net/blimp_stats.h"
 #include "cc/animation/animation_host.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/surface_layer.h"
 #include "cc/output/output_surface.h"
 #include "cc/proto/compositor_message.pb.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_host.h"
+#include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "net/base/net_errors.h"
 #include "ui/gl/gl_surface.h"
 
 namespace blimp {
 namespace client {
 
 namespace {
 
 void SatisfyCallback(cc::SurfaceManager* manager,
                      const cc::SurfaceSequence& sequence) {
   std::vector<uint32_t> sequences;
   sequences.push_back(sequence.sequence);
   manager->DidSatisfySequences(sequence.client_id, &sequences);
 }
 
 void RequireCallback(cc::SurfaceManager* manager,
                      const cc::SurfaceId& id,
                      const cc::SurfaceSequence& sequence) {
   cc::Surface* surface = manager->GetSurfaceForId(id);
   if (!surface) {
     LOG(ERROR) << "Attempting to require callback on nonexistent surface";
     return;
   }
   surface->AddDestructionDependency(sequence);
 }
 
 }  // namespace
 
-BlimpCompositor::BlimpCompositor(int render_widget_id,
-                                 cc::SurfaceManager* surface_manager,
-                                 uint32_t surface_client_id,
-                                 BlimpCompositorClient* client)
+BlimpCompositor::BlimpCompositor(
+    int render_widget_id,
+    BlimpCompositorDependencies* compositor_dependencies,
+    BlimpCompositorClient* client)
     : render_widget_id_(render_widget_id),
       client_(client),
+      compositor_dependencies_(compositor_dependencies),
       host_should_be_visible_(false),
-      surface_manager_(surface_manager),
-      surface_id_allocator_(
-          base::MakeUnique<cc::SurfaceIdAllocator>(surface_client_id)),
       layer_(cc::Layer::Create()),
       remote_proto_channel_receiver_(nullptr),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  surface_manager_->RegisterSurfaceClientId(surface_id_allocator_->client_id());
+
+  surface_id_allocator_ = base::MakeUnique<cc::SurfaceIdAllocator>(
+      GetEmbedderDeps()->AllocateSurfaceId());
+  GetEmbedderDeps()->GetSurfaceManager()->RegisterSurfaceClientId(
+      surface_id_allocator_->client_id());
 }
 
 BlimpCompositor::~BlimpCompositor() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (host_)
     DestroyLayerTreeHost();
-  surface_manager_->InvalidateSurfaceClientId(
+
+  GetEmbedderDeps()->GetSurfaceManager()->InvalidateSurfaceClientId(
       surface_id_allocator_->client_id());
 }
 
 void BlimpCompositor::SetVisible(bool visible) {
   host_should_be_visible_ = visible;
   if (host_)
     host_->SetVisible(host_should_be_visible_);
 }
 
 bool BlimpCompositor::OnTouchEvent(const ui::MotionEvent& motion_event) {
   if (input_manager_)
     return input_manager_->OnTouchEvent(motion_event);
   return false;
 }
 
 void BlimpCompositor::RequestNewOutputSurface() {
-  DCHECK(!surface_factory_)

[Khushal, 2016/08/24 23:22:46]

Can we keep the DCHECK here itself. The compositor should detach the old
OutputSurface before asking for a new one, which means we should have destroyed
the surface factory. Better to fail in the cc client callback if they are
breaking the contract.

[David Trainor- moved to gerrit, 2016/08/26 17:15:54]

Done.

-      << "Any connection to the old output surface should have been destroyed";
-
-  scoped_refptr<BlimpContextProvider> compositor_context_provider =
-      BlimpContextProvider::Create(gfx::kNullAcceleratedWidget,
-                                   client_->GetGpuMemoryBufferManager());
-
-  // TODO(khushalsagar): Make a worker context and bind it to the current
-  // thread:
-  // Worker context is bound to the main thread in RenderThreadImpl. One day
-  // that will change and then this will have to be removed.
-  // worker_context_provider->BindToCurrentThread();
-
-  std::unique_ptr<DelegatedOutputSurface> delegated_output_surface =
-      base::MakeUnique<DelegatedOutputSurface>(
-          std::move(compositor_context_provider), nullptr,
-          base::ThreadTaskRunnerHandle::Get(), weak_ptr_factory_.GetWeakPtr());
-
-  host_->SetOutputSurface(std::move(delegated_output_surface));
+  GetEmbedderDeps()->GetContextProvider(
+      base::Bind(&BlimpCompositor::OnContextProviderCreated,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BlimpCompositor::DidCommitAndDrawFrame() {
   BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
 }
 
 void BlimpCompositor::SetProtoReceiver(ProtoReceiver* receiver) {
   remote_proto_channel_receiver_ = receiver;
 }
 
@@ skipping 27 matching lines @@
       DestroyLayerTreeHost();
       break;
     default:
       // We should have a receiver if we're getting compositor messages that
       // are not INITIALIZE_IMPL or CLOSE_IMPL.
       DCHECK(remote_proto_channel_receiver_);
       remote_proto_channel_receiver_->OnProtoReceived(std::move(message));
   }
 }
 
+void BlimpCompositor::OnContextProviderCreated(
+    scoped_refptr<cc::ContextProvider> provider) {
+  DCHECK(!surface_factory_)
+      << "Any connection to the old output surface should have been destroyed";
+
+  // Make sure we still have a host.  If not, bail out.
+  if (!host_)

[Khushal, 2016/08/24 23:22:45]

I was thinking about the case where the host goes away, we recreate a new one,
and then get the callback for the old one. We'll assume this host asked for it
and then it will fail. So we could add back the bool to track a pending output
surface request, reset it on destroying the host, and just bail out if that is
false. If its true, the host should most definitely be there.

[David Trainor- moved to gerrit, 2016/08/26 17:15:54]

Done.

+    return;
+
+  // TODO(khushalsagar): Make a worker context and bind it to the current
+  // thread:
+  // Worker context is bound to the main thread in RenderThreadImpl. One day
+  // that will change and then this will have to be removed.
+  // worker_context_provider->BindToCurrentThread();
+  std::unique_ptr<DelegatedOutputSurface> delegated_output_surface =
+      base::MakeUnique<DelegatedOutputSurface>(
+          provider, nullptr, base::ThreadTaskRunnerHandle::Get(),
+          weak_ptr_factory_.GetWeakPtr());
+
+  host_->SetOutputSurface(std::move(delegated_output_surface));
+}
+
 void BlimpCompositor::SendWebGestureEvent(
     const blink::WebGestureEvent& gesture_event) {
   client_->SendWebGestureEvent(render_widget_id_, gesture_event);
 }
 
 void BlimpCompositor::BindToClient(
     base::WeakPtr<OutputSurfaceProxyClient> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!surface_factory_);
 
   output_surface_proxy_client_ = client;
-  surface_factory_ =
-      base::MakeUnique<cc::SurfaceFactory>(surface_manager_, this);
+  surface_factory_ = base::MakeUnique<cc::SurfaceFactory>(
+      GetEmbedderDeps()->GetSurfaceManager(), this);
 }
 
 void BlimpCompositor::SwapCompositorFrame(cc::CompositorFrame frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(surface_factory_);
 
   cc::RenderPass* root_pass =
       frame.delegated_frame_data->render_pass_list.back().get();
   gfx::Size surface_size = root_pass->output_rect.size();
 
   if (surface_id_.is_null() || current_surface_size_ != surface_size) {
     DestroyDelegatedContent();
     DCHECK(layer_->children().empty());
 
     surface_id_ = surface_id_allocator_->GenerateId();
     surface_factory_->Create(surface_id_);
     current_surface_size_ = surface_size;
 
     // manager must outlive compositors using it.
+    cc::SurfaceManager* surface_manager =
+        GetEmbedderDeps()->GetSurfaceManager();
     scoped_refptr<cc::SurfaceLayer> content_layer = cc::SurfaceLayer::Create(
-        base::Bind(&SatisfyCallback, base::Unretained(surface_manager_)),
-        base::Bind(&RequireCallback, base::Unretained(surface_manager_)));
+        base::Bind(&SatisfyCallback, base::Unretained(surface_manager)),
+        base::Bind(&RequireCallback, base::Unretained(surface_manager)));
     content_layer->SetSurfaceId(surface_id_, 1.f, surface_size);
     content_layer->SetBounds(current_surface_size_);
     content_layer->SetIsDrawable(true);
     content_layer->SetContentsOpaque(true);
 
     layer_->AddChild(content_layer);
   }
 
   surface_factory_->SubmitCompositorFrame(surface_id_, std::move(frame),
                                           base::Closure());
 }
 
 void BlimpCompositor::DetachFromClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(surface_factory_);
 
   DestroyDelegatedContent();
   surface_factory_.reset();
   output_surface_proxy_client_ = nullptr;
 }
 
 void BlimpCompositor::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
   DCHECK(surface_factory_);
-  compositor_task_runner_->PostTask(
+  compositor_dependencies_->GetCompositorTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&OutputSurfaceProxyClient::ReclaimCompositorResources,
                  output_surface_proxy_client_, resources));
 }
 
+CompositorDependencies* BlimpCompositor::GetEmbedderDeps() {
+  return compositor_dependencies_->GetEmbedderDependencies();
+}
+
 void BlimpCompositor::DestroyDelegatedContent() {
   if (surface_id_.is_null())
     return;
 
   // Remove any references for the surface layer that uses this |surface_id_|.
   layer_->RemoveAllChildren();
   surface_factory_->Destroy(surface_id_);
   surface_id_ = cc::SurfaceId();
 }
 
 void BlimpCompositor::CreateLayerTreeHost(
     const cc::proto::InitializeImpl& initialize_message) {
   DCHECK(!host_);
   VLOG(1) << "Creating LayerTreeHost for render widget: " << render_widget_id_;
 
+  if (!settings_)
+    settings_ = GetEmbedderDeps()->GetLayerTreeSettings();
+
   // Create the LayerTreeHost
   cc::LayerTreeHost::InitParams params;
   params.client = this;
-  params.task_graph_runner = client_->GetTaskGraphRunner();
-  params.gpu_memory_buffer_manager = client_->GetGpuMemoryBufferManager();
+  params.task_graph_runner = compositor_dependencies_->GetTaskGraphRunner();
+  params.gpu_memory_buffer_manager =
+      GetEmbedderDeps()->GetGpuMemoryBufferManager();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.image_serialization_processor =
-      client_->GetImageSerializationProcessor();
-  params.settings = client_->GetLayerTreeSettings();
+      compositor_dependencies_->GetImageSerializationProcessor();
+  params.settings = settings_.get();
   params.animation_host = cc::AnimationHost::CreateMainInstance();
 
-  compositor_task_runner_ = client_->GetCompositorTaskRunner();
+  scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner =
+      compositor_dependencies_->GetCompositorTaskRunner();
 
   host_ = cc::LayerTreeHost::CreateRemoteClient(
-      this /* remote_proto_channel */, compositor_task_runner_, &params);
+      this /* remote_proto_channel */, compositor_task_runner, &params);
   host_->SetVisible(host_should_be_visible_);
 
   DCHECK(!input_manager_);
   input_manager_ = BlimpInputManager::Create(
-      this, base::ThreadTaskRunnerHandle::Get(), compositor_task_runner_,
+      this, base::ThreadTaskRunnerHandle::Get(), compositor_task_runner,
       host_->GetInputHandler());
 }
 
 void BlimpCompositor::DestroyLayerTreeHost() {
   DCHECK(host_);
   VLOG(1) << "Destroying LayerTreeHost for render widget: "
           << render_widget_id_;
   // Tear down the output surface connection with the old LayerTreeHost
   // instance.
   DestroyDelegatedContent();
   surface_factory_.reset();
 
   // Destroy the old LayerTreeHost state.
   host_.reset();
 
   // Destroy the old input manager state.
   // It is important to destroy the LayerTreeHost before destroying the input
   // manager as it has a reference to the cc::InputHandlerClient owned by the
   // BlimpInputManager.
   input_manager_.reset();
 
+  // Destroy the LayerTreeHostSettings after the LayerTreeHost is gone, as it
+  // holds a reference to the settings.
+  settings_.reset();

[Khushal, 2016/08/24 23:22:46]

I think they keep a copy, so you can cache this value forever, but then may be
the deps provider can cache it for all compositors itself.

[David Trainor- moved to gerrit, 2016/08/26 17:15:54]

Done.

+
   // Make sure we don't have a receiver at this point.
   DCHECK(!remote_proto_channel_receiver_);
 }
 
 }  // namespace client
 }  // namespace blimp