GLInProcessContext: support async flushes and dedicated GPU thread

android_webview/browser/in_process_view_renderer.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 "android_webview/browser/in_process_view_renderer.h"
 
 #include <android/bitmap.h>
 
 #include "android_webview/browser/scoped_app_gl_state_restore.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "android_webview/public/browser/draw_sw.h"
 #include "base/android/jni_android.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
+#include "base/threading/thread_local.h"
 #include "content/public/browser/android/synchronous_compositor.h"
 #include "content/public/browser/web_contents.h"
+#include "gpu/command_buffer/service/in_process_command_buffer.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/vector2d_conversions.h"
 #include "ui/gfx/vector2d_f.h"
@@ skipping 88 matching lines @@
 
 // Tells if the Skia library versions in Android and Chromium are compatible.
 // If they are then it's possible to pass Skia objects like SkPictures to the
 // Android glue layer via the SW rendering functions.
 // If they are not, then additional copies and rasterizations are required
 // as a fallback mechanism, which will have an important performance impact.
 bool g_is_skia_version_compatible = false;
 
 const int64 kFallbackTickTimeoutInMilliseconds = 500;
 
+base::LazyInstance<ThreadLocalBoolean>::Leaky tls_gl_allowed =

[joth, 2013/07/27 02:24:32]

 does this need to be TLS? there's (currently) a limited number of TLS slots
available ~60.

Seems we could just do:-

// Only touched on UI thread.
bool g_currently_in_draw_gl = false;

void ScheduleGpuWork() {
  if (BrowserThread::CurrentlyOn(BrowserThread::UI) && g_currently_in_draw_gl)
    ...
  else
    .. TODO


...
void DrawGL() {
  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  base::AutoReset in_draw_gl_reset(g_currently_in_draw_gl, true);  // don't even
need the ScopedAllow class :-)
  ...

[no sievers, 2013/07/30 00:55:34]

Done.

+    LAZY_INSTANCE_INITIALIZER;
+
+class ScopedAllowGL {
+ public:
+  ScopedAllowGL();
+  ~ScopedAllowGL();
+};
+
+ScopedAllowGL::ScopedAllowGL() {
+  DCHECK(!tls_gl_allowed.Get().Get());
+  tls_gl_allowed.Get().Set(true);
+}
+
+ScopedAllowGL::~ScopedAllowGL() {
+  tls_gl_allowed.Get().Set(false);
+}
+
 }  // namespace
 
+// Called from different threads!
+static void ScheduleGpuWork() {
+  if (tls_gl_allowed.Get().Get()) {
+    gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
+  } else {
+    // TODO: We need to request a callback with a GL context current here.

[joth, 2013/07/27 02:24:32]

this is pretty important right - is there a bug for it? (I can open if there
isn't)

[no sievers, 2013/07/30 00:55:34]

I think Bo might already be working on a patch for this.

+  }
+}
+
 // static
 void BrowserViewRenderer::SetAwDrawSWFunctionTable(
     AwDrawSWFunctionTable* table) {
   g_sw_draw_functions = table;
   g_is_skia_version_compatible =
       g_sw_draw_functions->is_skia_version_compatible(&SkGraphics::GetVersion);
   LOG_IF(WARNING, !g_is_skia_version_compatible)
       << "Skia versions are not compatible, rendering performance will suffer.";
+
+  gpu::InProcessCommandBuffer::SetScheduleCallback(
+      base::Bind(&ScheduleGpuWork));
 }
 
 // static
 AwDrawSWFunctionTable* BrowserViewRenderer::GetAwDrawSWFunctionTable() {
   return g_sw_draw_functions;
 }
 
 // static
 bool BrowserViewRenderer::IsSkiaVersionCompatible() {
   DCHECK(g_sw_draw_functions);
@@ skipping 73 matching lines @@
   // We need to watch if the current Android context has changed and enforce
   // a clean-up in the compositor.
   EGLContext current_context = eglGetCurrentContext();
   if (!current_context) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_NullEGLContext", TRACE_EVENT_SCOPE_THREAD);
     return;
   }
 
   ScopedAppGLStateRestore state_restore(ScopedAppGLStateRestore::MODE_DRAW);
+  gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
+  ScopedAllowGL allow_gl;
 
   if (attached_to_window_ && compositor_ && !hardware_initialized_) {
     TRACE_EVENT0("android_webview", "InitializeHwDraw");
     hardware_failed_ = !compositor_->InitializeHwDraw();
     hardware_initialized_ = true;
     last_egl_context_ = current_context;
 
     if (hardware_failed_)
       return;
   }
@@ skipping 210 matching lines @@
 
 void InProcessViewRenderer::OnDetachedFromWindow() {
   TRACE_EVENT0("android_webview",
                "InProcessViewRenderer::OnDetachedFromWindow");
 
   if (hardware_initialized_) {
     DCHECK(compositor_);
 
     ScopedAppGLStateRestore state_restore(
         ScopedAppGLStateRestore::MODE_DETACH_FROM_WINDOW);
+    gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
+    ScopedAllowGL allow_gl;
     compositor_->ReleaseHwDraw();
     hardware_initialized_ = false;
   }
 
   attached_to_window_ = false;
 }
 
 bool InProcessViewRenderer::IsAttachedToWindow() {
   return attached_to_window_;
 }
@@ skipping 195 matching lines @@
     base::StringAppendF(&str,
                         "surface width height: [%d %d] ",
                         draw_info->width,
                         draw_info->height);
     base::StringAppendF(&str, "is_layer: %d ", draw_info->is_layer);
   }
   return str;
 }
 
 }  // namespace android_webview