blimp: Set up the CompositorDependencies for blimp in Chrome.

blimp/client/core/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/core/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"
@@ skipping 54 matching lines @@
       compositor_dependencies_(compositor_dependencies),
       host_should_be_visible_(false),
       output_surface_(nullptr),
       output_surface_request_pending_(false),
       layer_(cc::Layer::Create()),
       remote_proto_channel_receiver_(nullptr),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   surface_id_allocator_ = base::MakeUnique<cc::SurfaceIdAllocator>(
-      GetEmbedderDeps()->AllocateSurfaceId());
+      GetEmbedderDeps()->AllocateSurfaceClientId());
   GetEmbedderDeps()->GetSurfaceManager()->RegisterSurfaceClientId(
       surface_id_allocator_->client_id());
 }
 
 BlimpCompositor::~BlimpCompositor() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (host_)
     DestroyLayerTreeHost();
 
@@ skipping 11 matching lines @@
   if (input_manager_)
     return input_manager_->OnTouchEvent(motion_event);
   return false;
 }
 
 void BlimpCompositor::RequestNewOutputSurface() {
   DCHECK(!surface_factory_);
   DCHECK(!output_surface_request_pending_);
 
   output_surface_request_pending_ = true;
-  GetEmbedderDeps()->GetContextProvider(
-      base::Bind(&BlimpCompositor::OnContextProviderCreated,
+  GetEmbedderDeps()->GetContextProviders(
+      base::Bind(&BlimpCompositor::OnContextProvidersCreated,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BlimpCompositor::DidInitializeOutputSurface() {
   output_surface_request_pending_ = false;
 }
 
 void BlimpCompositor::DidCommitAndDrawFrame() {
   BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
 }
@@ skipping 31 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(
-    const scoped_refptr<cc::ContextProvider>& provider) {
+void BlimpCompositor::OnContextProvidersCreated(
+    const scoped_refptr<cc::ContextProvider>& compositor_context_provider,
+    const scoped_refptr<cc::ContextProvider>& worker_context_provider) {
   DCHECK(!surface_factory_)
       << "Any connection to the old output surface should have been destroyed";
 
   // Make sure we still have a host and we're still expecting an output surface.
   // This can happen if the host dies while the request is outstanding and we
   // build a new one that hasn't asked for a surface yet.
   if (!output_surface_request_pending_)
     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();
+  // Try again if the context creation failed.
+  if (!compositor_context_provider) {
+    GetEmbedderDeps()->GetContextProviders(
+        base::Bind(&BlimpCompositor::OnContextProvidersCreated,
+                   weak_ptr_factory_.GetWeakPtr()));
+    return;
+  }
+
   std::unique_ptr<DelegatedOutputSurface> delegated_output_surface =
       base::MakeUnique<DelegatedOutputSurface>(
-          provider, nullptr, base::ThreadTaskRunnerHandle::Get(),
-          weak_ptr_factory_.GetWeakPtr());
+          std::move(compositor_context_provider),
+          std::move(worker_context_provider),
+          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::BindToOutputSurface(
@@ skipping 78 matching lines @@
 
   // Create the LayerTreeHost
   cc::LayerTreeHost::InitParams params;
   params.client = this;
   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 =
       compositor_dependencies_->GetImageSerializationProcessor();
-  params.settings = GetEmbedderDeps()->GetLayerTreeSettings();
+
+  cc::LayerTreeSettings* settings =
+      compositor_dependencies_->GetLayerTreeSettings();
+  // TODO(khushalsagar): This is a hack. Remove when we move the split point
+  // out. For details on why this is needed, see crbug.com/586210.
+  settings->abort_commit_before_output_surface_creation = false;
+  params.settings = settings;
+
   params.animation_host = cc::AnimationHost::CreateMainInstance();
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner =
       compositor_dependencies_->GetCompositorTaskRunner();
 
   host_ = cc::LayerTreeHost::CreateRemoteClient(
       this /* remote_proto_channel */, compositor_task_runner, &params);
   host_->SetVisible(host_should_be_visible_);
 
   DCHECK(!input_manager_);
@@ skipping 23 matching lines @@
   // Cancel any outstanding OutputSurface requests.  That way if we get an async
   // callback related to the old request we know to drop it.
   output_surface_request_pending_ = false;
 
   // Make sure we don't have a receiver at this point.
   DCHECK(!remote_proto_channel_receiver_);
 }
 
 }  // namespace client
 }  // namespace blimp