Android: Avoid blocking UI thread for GPU channel creation

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 
 #include "base/android/jni_android.h"
@@ skipping 229 matching lines @@
       window_(NULL),
       surface_id_(0),
       client_(client),
       root_window_(root_window),
       did_post_swapbuffers_(false),
       ignore_schedule_composite_(false),
       needs_composite_(false),
       needs_animate_(false),
       will_composite_immediately_(false),
       composite_on_vsync_trigger_(DO_NOT_COMPOSITE),
-      pending_swapbuffers_(0U) {
+      pending_swapbuffers_(0U),
+      weak_factory_(this) {
   DCHECK(client);
   DCHECK(root_window);
   ImageTransportFactoryAndroid::AddObserver(this);
   root_window->AttachCompositor(this);
 }
 
 CompositorImpl::~CompositorImpl() {
   root_window_->DetachCompositor();
   ImageTransportFactoryAndroid::RemoveObserver(this);
   // Clean-up any surface references.
@@ skipping 54 matching lines @@
     current_composite_task_->Cancel();
 
   // Unretained because we cancel the task on shutdown.
   current_composite_task_.reset(new base::CancelableClosure(
       base::Bind(&CompositorImpl::Composite, base::Unretained(this), trigger)));
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, current_composite_task_->callback(), delay);
 }
 
 void CompositorImpl::Composite(CompositingTrigger trigger) {
+  BrowserGpuChannelHostFactory* factory =
+      BrowserGpuChannelHostFactory::instance();
+  if (!factory->GetGpuChannel() || factory->GetGpuChannel()->IsLost()) {
+    CauseForGpuLaunch cause =
+        CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
+    factory->EstablishGpuChannel(
+        cause,
+        base::Bind(&CompositorImpl::OnGpuChannelEstablished,
+                   weak_factory_.GetWeakPtr()));
+    return;
+  }
+
   DCHECK(host_);
   DCHECK(trigger == COMPOSITE_IMMEDIATELY || trigger == COMPOSITE_EVENTUALLY);
   DCHECK(needs_composite_);
   DCHECK(!DidCompositeThisFrame());
 
   if (trigger == COMPOSITE_IMMEDIATELY)
     will_composite_immediately_ = false;
 
   DCHECK_LE(pending_swapbuffers_, kMaxSwapBuffers);
   if (pending_swapbuffers_ == kMaxSwapBuffers) {
@@ skipping 24 matching lines @@
 
   did_post_swapbuffers_ = false;
   host_->Composite(frame_time);
   if (did_post_swapbuffers_)
     pending_swapbuffers_++;
 
   // Need to track vsync to avoid compositing more than once per frame.
   root_window_->RequestVSyncUpdate();
 }
 
+void CompositorImpl::OnGpuChannelEstablished() {
+  ScheduleComposite();
+}
+
 void CompositorImpl::SetRootLayer(scoped_refptr<cc::Layer> root_layer) {
   root_layer_->RemoveAllChildren();
   if (root_layer)
     root_layer_->AddChild(root_layer);
 }
 
 void CompositorImpl::SetWindowSurface(ANativeWindow* window) {
   GpuSurfaceTracker* tracker = GpuSurfaceTracker::Get();
 
   if (window_) {
@@ skipping 163 matching lines @@
 }
 
 void CompositorImpl::DeleteUIResource(cc::UIResourceId resource_id) {
   UIResourceMap::iterator it = ui_resource_map_.find(resource_id);
   if (it != ui_resource_map_.end())
     ui_resource_map_.erase(it);
 }
 
 static scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 CreateGpuProcessViewContext(
+    const scoped_refptr<GpuChannelHost>& gpu_channel_host,
     const blink::WebGraphicsContext3D::Attributes attributes,
     int surface_id) {
-  BrowserGpuChannelHostFactory* factory =
-      BrowserGpuChannelHostFactory::instance();
-  CauseForGpuLaunch cause =
-      CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
-  scoped_refptr<GpuChannelHost> gpu_channel_host(
-      factory->EstablishGpuChannelSync(cause));
-  if (!gpu_channel_host)
-    return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
+  DCHECK(gpu_channel_host);
 
   GURL url("chrome://gpu/Compositor::createContext3D");
   static const size_t kBytesPerPixel = 4;
   gfx::DeviceDisplayInfo display_info;
   size_t full_screen_texture_size_in_bytes =
       display_info.GetDisplayHeight() *
       display_info.GetDisplayWidth() *
       kBytesPerPixel;
   WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits limits;
   limits.command_buffer_size = 64 * 1024;
@@ skipping 18 matching lines @@
   // to stop calling it ourselves in CompositorImpl::Composite().
   NOTREACHED();
   client_->Layout();
 }
 
 scoped_ptr<cc::OutputSurface> CompositorImpl::CreateOutputSurface(
     bool fallback) {
   blink::WebGraphicsContext3D::Attributes attrs;
   attrs.shareResources = true;
   attrs.noAutomaticFlushes = true;
+  pending_swapbuffers_ = 0;
 
   DCHECK(window_);
   DCHECK(surface_id_);
 
-  scoped_refptr<ContextProviderCommandBuffer> context_provider =
-      ContextProviderCommandBuffer::Create(
-          CreateGpuProcessViewContext(attrs, surface_id_), "BrowserCompositor");
+  scoped_refptr<ContextProviderCommandBuffer> context_provider;
+  BrowserGpuChannelHostFactory* factory =
+      BrowserGpuChannelHostFactory::instance();
+  scoped_refptr<GpuChannelHost> gpu_channel_host = factory->GetGpuChannel();
+  if (gpu_channel_host && !gpu_channel_host->IsLost()) {
+    context_provider = ContextProviderCommandBuffer::Create(
+        CreateGpuProcessViewContext(gpu_channel_host, attrs, surface_id_),
+        "BrowserCompositor");
+  }
   if (!context_provider.get()) {
     LOG(ERROR) << "Failed to create 3D context for compositor.";
     return scoped_ptr<cc::OutputSurface>();
   }
 
   return scoped_ptr<cc::OutputSurface>(
       new OutputSurfaceWithoutParent(context_provider));
 }
 
 void CompositorImpl::OnLostResources() {
@@ skipping 33 matching lines @@
 void CompositorImpl::DidCompleteSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidCompleteSwapBuffers");
   DCHECK_GT(pending_swapbuffers_, 0U);
   if (pending_swapbuffers_-- == kMaxSwapBuffers && needs_composite_)
     PostComposite(COMPOSITE_IMMEDIATELY);
   client_->OnSwapBuffersCompleted(pending_swapbuffers_);
 }
 
 void CompositorImpl::DidAbortSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidAbortSwapBuffers");
-  DCHECK_GT(pending_swapbuffers_, 0U);
-  if (pending_swapbuffers_-- == kMaxSwapBuffers && needs_composite_)
-    PostComposite(COMPOSITE_IMMEDIATELY);
-  client_->OnSwapBuffersCompleted(pending_swapbuffers_);
+  // This really gets called only once from
+  // SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() when the
+  // context was lost.
+  client_->OnSwapBuffersCompleted(0);
 }
 
 void CompositorImpl::DidCommit() {
   root_window_->OnCompositingDidCommit();
 }
 
 void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) {
   root_layer_->AddChild(layer);
 }
 
@@ skipping 24 matching lines @@
 }
 
 void CompositorImpl::SetNeedsAnimate() {
   if (!host_)
     return;
 
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content