[Android WebView] Clean up global GL resource pt.1

content/browser/android/in_process/synchronous_compositor_impl.cc

 // Copyright 2013 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/android/in_process/synchronous_compositor_impl.h"
 
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "cc/input/input_handler.h"
@@ skipping 58 matching lines @@
 
   scoped_refptr<cc::ContextProvider> context_provider_;
   gpu::GLInProcessContext* gl_in_process_context_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoContextProvider);
 };
 
 class SynchronousCompositorFactoryImpl : public SynchronousCompositorFactory {
  public:
   SynchronousCompositorFactoryImpl()
-      : wrapped_gl_context_for_main_thread_(NULL) {
+      : wrapped_gl_context_for_main_thread_(NULL),
+        num_hardware_compositors_(0) {
     SynchronousCompositorFactory::SetInstance(this);
   }
 
   // SynchronousCompositorFactory
   virtual scoped_refptr<base::MessageLoopProxy>
       GetCompositorMessageLoop() OVERRIDE {
     return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI);
   }
 
   virtual scoped_ptr<cc::OutputSurface> CreateOutputSurface(
@@ skipping 40 matching lines @@
     if (!context.get())
       return scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>();
 
     return scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>(
         WebGraphicsContext3DInProcessCommandBufferImpl::WrapContext(
             context.Pass(), attributes));
   }
 
   virtual scoped_refptr<cc::ContextProvider>
   GetOffscreenContextProviderForMainThread() OVERRIDE {
-    if (!offscreen_context_for_main_thread_.get() ||
-        offscreen_context_for_main_thread_->DestroyedOnMainThread()) {
+    bool can_create_context = CanCreateMainThreadContext();
+    if (can_create_context &&
+        (!offscreen_context_for_main_thread_.get() ||
+         offscreen_context_for_main_thread_->DestroyedOnMainThread())) {
       offscreen_context_for_main_thread_ =
           webkit::gpu::ContextProviderInProcess::Create(
               CreateOffscreenContext());
-      if (offscreen_context_for_main_thread_.get() &&
-          !offscreen_context_for_main_thread_->BindToCurrentThread()) {
-        offscreen_context_for_main_thread_ = NULL;
-        wrapped_gl_context_for_main_thread_ = NULL;
-      }
+    }
+
+    if (!can_create_context ||

[joth, 2013/09/05 20:47:12]

splicing the can_create_context into both expressions makes it hard to follow
the possible different paths here.

what you really want is a goto. (or moreover, extract a function).

As it is, maybe

bool fail = !CanCreateMainThreadContext();
if (!fail) {
  if (!offscreen_context_for_main_thread_.get() ||
offscreen_context_for_main_thread_->DestroyedOnMainThread()) {
  offscreen_context_for_main_thread_ = create...
  fail = !offscreen_context_for_main_thread_.get() ||
!offscreen_context_for_main_thread_->BindToCurrentThread();
}
}

if (fail) {
  offscreen_context_for_main_thread_ = NULL;
  wrapped_gl_context_for_main_thread_ = NULL;
}

[boliu, 2013/09/05 23:21:25]

Done.

+        (offscreen_context_for_main_thread_.get() &&
+         !offscreen_context_for_main_thread_->BindToCurrentThread())) {
+      offscreen_context_for_main_thread_ = NULL;
+      wrapped_gl_context_for_main_thread_ = NULL;
     }
     return offscreen_context_for_main_thread_;
   }
 
   // This is called on both renderer main thread (offscreen context creation
   // path shared between cross-process and in-process platforms) and renderer
   // compositor impl thread (InitializeHwDraw) in order to support Android
   // WebView synchronously enable and disable hardware mode multiple times in
   // the same task. This is ok because in-process WGC3D creation may happen on
   // any thread and is lightweight.
   virtual scoped_refptr<cc::ContextProvider>
       GetOffscreenContextProviderForCompositorThread() OVERRIDE {
-    base::AutoLock lock(offscreen_context_for_compositor_thread_creation_lock_);
+    base::AutoLock lock(offscreen_context_for_compositor_thread_lock_);
     if (!offscreen_context_for_compositor_thread_.get() ||
         offscreen_context_for_compositor_thread_->DestroyedOnMainThread()) {
       offscreen_context_for_compositor_thread_ =
           webkit::gpu::ContextProviderInProcess::CreateOffscreen();
     }
     return offscreen_context_for_compositor_thread_;
   }
 
   virtual scoped_ptr<StreamTextureFactory> CreateStreamTextureFactory(
       int view_id) OVERRIDE {
-    scoped_refptr<VideoContextProvider> context_provider =
-        new VideoContextProvider(offscreen_context_for_main_thread_,
-                                 wrapped_gl_context_for_main_thread_);
+    scoped_refptr<VideoContextProvider> context_provider;
+    if (CanCreateMainThreadContext()) {
+      context_provider =
+          new VideoContextProvider(offscreen_context_for_main_thread_,
+                                   wrapped_gl_context_for_main_thread_);
+    }
     return make_scoped_ptr(new StreamTextureFactorySynchronousImpl(
                                context_provider.get(), view_id))
         .PassAs<StreamTextureFactory>();
   }
 
+  void CompositorInitializedHardwareDraw(SynchronousCompositorImpl* compositor);
+  void CompositorReleasedHardwareDraw(SynchronousCompositorImpl* compositor);
+
  private:
+  void ReleaseGlobalHardwareResources();
+  bool CanCreateMainThreadContext();
+
   SynchronousInputEventFilter synchronous_input_event_filter_;
 
-  // Only guards construction of |offscreen_context_for_compositor_thread_|,
-  // not usage.
-  base::Lock offscreen_context_for_compositor_thread_creation_lock_;
+  // Only guards construction and destruction of
+  // |offscreen_context_for_compositor_thread_|, not usage.
+  base::Lock offscreen_context_for_compositor_thread_lock_;
   scoped_refptr<cc::ContextProvider> offscreen_context_for_main_thread_;
   // This is a pointer to the context owned by
   // |offscreen_context_for_main_thread_|.
   gpu::GLInProcessContext* wrapped_gl_context_for_main_thread_;
   scoped_refptr<cc::ContextProvider> offscreen_context_for_compositor_thread_;
+
+  base::Lock num_hardware_compositor_lock_;

[joth, 2013/09/05 20:47:12]

comment that num_hardware_compositors_ is always updated on the UI thread, but
maybe read on another thread.

(also should have a comment here or in the release function to acknowledge
possible race in reading this while the last compositor is closing)

[boliu, 2013/09/05 23:21:25]

Both done

+  unsigned int num_hardware_compositors_;
 };
 
+void SynchronousCompositorFactoryImpl::CompositorInitializedHardwareDraw(
+    SynchronousCompositorImpl* compositor) {
+  base::AutoLock lock(num_hardware_compositor_lock_);
+  num_hardware_compositors_++;
+}
+
+void SynchronousCompositorFactoryImpl::CompositorReleasedHardwareDraw(
+    SynchronousCompositorImpl* compositor) {
+  bool should_release_resources = false;
+  {
+    base::AutoLock lock(num_hardware_compositor_lock_);
+    DCHECK_GT(num_hardware_compositors_, 0u);
+    num_hardware_compositors_--;
+    should_release_resources = num_hardware_compositors_ == 0u;
+  }
+  if (should_release_resources)
+    ReleaseGlobalHardwareResources();
+}
+
+void SynchronousCompositorFactoryImpl::ReleaseGlobalHardwareResources() {
+  {
+    base::AutoLock lock(offscreen_context_for_compositor_thread_lock_);
+    offscreen_context_for_compositor_thread_ = NULL;
+  }
+
+  // TODO(boliu): Properly clean up command buffer server of main thread
+  // context here.
+}
+
+bool SynchronousCompositorFactoryImpl::CanCreateMainThreadContext() {
+  base::AutoLock lock(num_hardware_compositor_lock_);
+  return num_hardware_compositors_ > 0;
+}
+
 base::LazyInstance<SynchronousCompositorFactoryImpl>::Leaky g_factory =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(SynchronousCompositorImpl);
 
 // static
 SynchronousCompositorImpl* SynchronousCompositorImpl::FromID(int process_id,
                                                              int routing_id) {
@@ skipping 30 matching lines @@
 void SynchronousCompositorImpl::SetClient(
     SynchronousCompositorClient* compositor_client) {
   DCHECK(CalledOnValidThread());
   compositor_client_ = compositor_client;
 }
 
 bool SynchronousCompositorImpl::InitializeHwDraw(
     scoped_refptr<gfx::GLSurface> surface) {
   DCHECK(CalledOnValidThread());
   DCHECK(output_surface_);
-  return output_surface_->InitializeHwDraw(
+  bool success = output_surface_->InitializeHwDraw(
       surface,
       g_factory.Get().GetOffscreenContextProviderForCompositorThread());
+  if (success)
+    g_factory.Get().CompositorInitializedHardwareDraw(this);
+  return success;
 }
 
 void SynchronousCompositorImpl::ReleaseHwDraw() {
   DCHECK(CalledOnValidThread());
   DCHECK(output_surface_);
-  return output_surface_->ReleaseHwDraw();
+  output_surface_->ReleaseHwDraw();
+  g_factory.Get().CompositorReleasedHardwareDraw(this);
 }
 
 bool SynchronousCompositorImpl::DemandDrawHw(
       gfx::Size view_size,
       const gfx::Transform& transform,
       gfx::Rect damage_area,
       bool stencil_enabled) {
   DCHECK(CalledOnValidThread());
   DCHECK(output_surface_);
 
@@ skipping 111 matching lines @@
     g_factory.Get();  // Ensure it's initialized.
     SynchronousCompositorImpl::CreateForWebContents(contents);
   }
   if (SynchronousCompositorImpl* instance =
       SynchronousCompositorImpl::FromWebContents(contents)) {
     instance->SetClient(client);
   }
 }
 
 }  // namespace content