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;
 
+LazyInstance<ThreadLocalBoolean>::Leaky tls_gl_allowed =
+    LAZY_INSTANCE_INITIALIZER;
+
+// Called from different threads!
+static void ScheduleGpuWork() {
+  if (tls_gl_allowed.Get().Get())
+    gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();

[piman, 2013/07/23 01:57:14]

Should this DCHECK if GL is allowed? I'm worried that otherwise we'll just spin.

[no sievers, 2013/07/25 00:41:23]

I put a TODO. I'll have to figure this out with Bo as the very next thing.

It currently somewhat works because when we only have GL from the compositor
context we cannot accumulate too much GL without eventually drawing. Also, we
eventually flush all GL if we detach the view (see OnDetachedFromWindow() below)
where we also tear down the compositor.

I want to use this also for the main webkit thread offscreen context so we can
do simple video resource management through the share group, so it definitely
cannot stay without guaranteeing a flush to happen soon.

+}
+
+class ScopedAllowGL {
+ public:
+  ScopedAllowGL();
+  ~ScopedAllowGL();
+

[piman, 2013/07/23 01:57:14]

nit: no need for blank line.

[no sievers, 2013/07/25 00:41:23]

Done.

+};
+
+ScopedAllowGL::ScopedAllowGL() {
+  DCHECK(!tls_gl_allowed.Get().Get());
+  tls_gl_allowed.Get().Set(true);
+}
+
+ScopedAllowGL::~ScopedAllowGL() {
+  tls_gl_allowed.Get().Set(false);
+}
+
 }  // namespace
 
 // 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.";
+
+  // TODO: There is probably a better place to do this.
+  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