blimp: Set up the CompositorDependencies for blimp in Chrome.

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"
@@ 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(
+  GetEmbedderDeps()->GetContextProviders(
       base::Bind(&BlimpCompositor::OnContextProviderCreated,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BlimpCompositor::DidInitializeOutputSurface() {
   output_surface_request_pending_ = false;
 }
 
 void BlimpCompositor::DidCommitAndDrawFrame() {
   BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
@@ skipping 34 matching lines @@
       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) {
+    const blimp::client::CompositorDependencies::ContextProviders&
+        context_providers) {
   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 (!context_providers.compositor_context_provider) {
+    GetEmbedderDeps()->GetContextProviders(
+        base::Bind(&BlimpCompositor::OnContextProviderCreated,
+                   weak_ptr_factory_.GetWeakPtr()));

[David Trainor- moved to gerrit, 2016/08/31 00:28:58]

Return after this?

[Khushal, 2016/08/31 21:22:50]

Good catch. Done.

+  }
+
   std::unique_ptr<DelegatedOutputSurface> delegated_output_surface =
       base::MakeUnique<DelegatedOutputSurface>(
-          provider, nullptr, base::ThreadTaskRunnerHandle::Get(),
-          weak_ptr_factory_.GetWeakPtr());
+          std::move(context_providers.compositor_context_provider),
+          std::move(context_providers.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 122 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