[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_compositor_(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 ||
+        (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_);

[no sievers, 2013/09/04 22:27:09]

Does this also need to check if we actually have a shared context, i.e.
num_hardware_compositors > 0?
Or should it at least DCHECK()?

[boliu, 2013/09/04 23:05:57]

Aha, yes, I did give this some thought. cc should never ask for the unless
hardware is initialized (ie has gl_renderer), by that time, we must already have
a compositor context, so it's fine.

I would have added DCHECK except we also call this from InitializeHwDraw, where
we need to call this before knowing if initialization is going to be successful,
so for the first initialization, num_hardware_compositor will be 0. Didn't want
to change things too much for merging to m30...

     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_);
     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_;
+  unsigned int num_hardware_compositor_;

[no sievers, 2013/09/04 22:27:09]

nit: num_hardware_compositors

[boliu, 2013/09/04 23:05:57]

Done.

 };
 
+void SynchronousCompositorFactoryImpl::CompositorInitializedHardwareDraw(
+    SynchronousCompositorImpl* compositor) {
+  base::AutoLock lock(num_hardware_compositor_lock_);
+  num_hardware_compositor_++;
+}
+
+void SynchronousCompositorFactoryImpl::CompositorReleasedHardwareDraw(
+    SynchronousCompositorImpl* compositor) {
+  bool should_release_resources = false;
+  {
+    base::AutoLock lock(num_hardware_compositor_lock_);
+    DCHECK_GT(num_hardware_compositor_, 0u);
+    num_hardware_compositor_--;
+    should_release_resources = num_hardware_compositor_ == 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_compositor_ > 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 surface_size,
       const gfx::Transform& transform,
       gfx::Rect viewport,
       gfx::Rect clip,
       bool stencil_enabled) {
   DCHECK(CalledOnValidThread());
   DCHECK(output_surface_);
@@ skipping 120 matching lines @@
     g_factory.Get();  // Ensure it's initialized.
     SynchronousCompositorImpl::CreateForWebContents(contents);
   }
   if (SynchronousCompositorImpl* instance =
       SynchronousCompositorImpl::FromWebContents(contents)) {
     instance->SetClient(client);
   }
 }
 
 }  // namespace content