aw: Track UI request GL separately from other threads

android_webview/browser/deferred_gpu_command_service.cc

 // Copyright 2014 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 "android_webview/browser/deferred_gpu_command_service.h"
 
 #include "android_webview/browser/gl_view_renderer_manager.h"
 #include "android_webview/browser/shared_renderer_state.h"
 #include "base/synchronization/lock.h"
 #include "content/public/browser/android/synchronous_compositor.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 
 namespace android_webview {
 
 namespace {
 
 // TODO(boliu): Consider using base/atomicops.h.
 class ThreadSafeBool {
  public:
   ThreadSafeBool();
   void Set(bool boolean);
   bool Get();
+  bool GetAndSet();
 
  private:
   base::Lock lock_;
   bool boolean_;
   DISALLOW_COPY_AND_ASSIGN(ThreadSafeBool);
 };
 
 ThreadSafeBool::ThreadSafeBool() : boolean_(false) {
 }
 
 void ThreadSafeBool::Set(bool boolean) {
   base::AutoLock lock(lock_);
   boolean_ = boolean;
 }
 
+bool ThreadSafeBool::GetAndSet() {
+  base::AutoLock lock(lock_);
+  bool rv = boolean_;
+  boolean_ = true;
+  return rv;
+}
+
 bool ThreadSafeBool::Get() {
   base::AutoLock lock(lock_);
   return boolean_;
 }
 
 base::LazyInstance<ThreadSafeBool> g_request_pending =
     LAZY_INSTANCE_INITIALIZER;
 
+// Because request is posted to UI thread, have to treat requests on UI thread
+// specifically because UI can immediately block waiting for the request.
+base::LazyInstance<ThreadSafeBool> g_request_pending_on_ui =
+    LAZY_INSTANCE_INITIALIZER;
+
 base::LazyInstance<scoped_refptr<DeferredGpuCommandService> >
     g_service = LAZY_INSTANCE_INITIALIZER;
 }  // namespace
 
 base::LazyInstance<base::ThreadLocalBoolean> ScopedAllowGL::allow_gl;
 
 // static
 bool ScopedAllowGL::IsAllowed() {
   return allow_gl.Get().Get();
 }
 
 ScopedAllowGL::ScopedAllowGL() {
   DCHECK(!allow_gl.Get().Get());
   allow_gl.Get().Set(true);
 
   if (g_service.Get())
     g_service.Get()->RunTasks();
 }
 
 ScopedAllowGL::~ScopedAllowGL() {
   allow_gl.Get().Set(false);
   g_request_pending.Get().Set(false);
+  g_request_pending_on_ui.Get().Set(false);
 
   DeferredGpuCommandService* service = g_service.Get();
   if (service) {
     service->RunTasks();
     if (service->HasIdleWork()) {
       service->RequestProcessGL();
     }
   }
 }
 
 // static
 void DeferredGpuCommandService::SetInstance() {
   if (!g_service.Get()) {
     g_service.Get() = new DeferredGpuCommandService;
     content::SynchronousCompositor::SetGpuService(g_service.Get());
 
     // Initialize global booleans.
     g_request_pending.Get().Set(false);
+    g_request_pending_on_ui.Get().Set(false);
   }
 }
 
 // static
 DeferredGpuCommandService* DeferredGpuCommandService::GetInstance() {
   DCHECK(g_service.Get().get());
   return g_service.Get().get();
 }
 
 DeferredGpuCommandService::DeferredGpuCommandService() {}
 
 DeferredGpuCommandService::~DeferredGpuCommandService() {
   base::AutoLock lock(tasks_lock_);
   DCHECK(tasks_.empty());
 }
 
 // This method can be called on any thread.
 // static
 void DeferredGpuCommandService::RequestProcessGL() {
   SharedRendererState* renderer_state =
       GLViewRendererManager::GetInstance()->GetMostRecentlyDrawn();
   if (!renderer_state) {
     LOG(ERROR) << "No hardware renderer. Deadlock likely";
     return;
   }
 
-  if (!g_request_pending.Get().Get()) {
-    g_request_pending.Get().Set(true);
+  bool on_ui_thread = renderer_state->CurrentlyOnUIThread();

[hush (inactive), 2014/08/05 23:04:39]

on_ui_thread only means render state was running on UI thread during that point
of time. But it does not mean renderer state won't switch threads, nor does it
mean UI is blocked on a request to RT.

DeferredGpuCommandService::RequestProcessGL can be running on any thread (blink
main thread, UI thread, and render thread)
Suppose DeferredGpuCommandService::RequestProcessGL is running on blink main
thread now, and right after this line, render state hops from UI thread to
Render Thread. 

Will this be a problem?

[boliu, 2014/08/05 23:07:55]

That's how things work today, before or after this CL. What problem are you
talking about?

+  bool need_request = on_ui_thread ? !g_request_pending_on_ui.Get().GetAndSet()
+                                   : !g_request_pending.Get().GetAndSet();
+  if (need_request) {
+    if (on_ui_thread) {
+      g_request_pending.Get().Set(true);
+    }

[hush (inactive), 2014/08/05 23:04:39]

if g_request_pending_on_ui is true, g_request_pending is definitely true.
Right?
If so, we can just set g_request_pending regardless, and treat
g_request_pending_on_ui separately

[boliu, 2014/08/05 23:07:55]

Yep, that's what I wanted to do here.
You mean remove if (on_ui_thread)? Yeah that should work.

[hush (inactive), 2014/08/05 23:55:15]

yes. if on_ui_thread is false, you will set g_request_pending in line 129. If it
is true, you will do that line 132.
On 2014/08/05 23:07:55, boliu wrote:

[boliu, 2014/08/06 00:05:46]

Done.

     renderer_state->ClientRequestDrawGL();
   }
 }
 
 // Called from different threads!
 void DeferredGpuCommandService::ScheduleTask(const base::Closure& task) {
   {
     base::AutoLock lock(tasks_lock_);
     tasks_.push(task);
   }
@@ skipping 74 matching lines @@
 
 void DeferredGpuCommandService::AddRef() const {
   base::RefCountedThreadSafe<DeferredGpuCommandService>::AddRef();
 }
 
 void DeferredGpuCommandService::Release() const {
   base::RefCountedThreadSafe<DeferredGpuCommandService>::Release();
 }
 
 }  // namespace android_webview