Support multiple service instances with GLInProcessContext

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/aw_gl_surface.h"
 #include "android_webview/browser/scoped_app_gl_state_restore.h"
 #include "android_webview/common/aw_switches.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/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
-#include "gpu/command_buffer/service/in_process_command_buffer.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkBitmapDevice.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/utils/SkCanvasStateUtils.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 149 matching lines @@
   InProcessViewRenderer* renderer = static_cast<InProcessViewRenderer*>(
       g_view_renderer_manager.Get().GetMostRecentlyDrawn());
   if (!renderer || !renderer->RequestProcessGL()) {
     LOG(ERROR) << "Failed to request GL process. Deadlock likely: "
                << !!renderer;
   }
 }
 
 }  // namespace
 
+DeferredGpuCommandService::DeferredGpuCommandService() {}
+
+DeferredGpuCommandService::~DeferredGpuCommandService() {
+  base::AutoLock lock(tasks_lock_);
+  DCHECK(tasks_.empty());
+}
+
 // Called from different threads!
-static void ScheduleGpuWork() {
+void DeferredGpuCommandService::ScheduleTask(const base::Closure& task) {
   if (ScopedAllowGL::IsAllowed()) {
-    gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
+    task.Run();
   } else {
+    base::AutoLock lock(tasks_lock_);
+    tasks_.push(task);
     RequestProcessGLOnUIThread();
   }
 }
 
+void DeferredGpuCommandService::ScheduleIdleWork(const base::Closure& callback) {
+  // TODO(sievers): Should this do anything?

[boliu, 2014/02/08 18:55:54]

We can make this work, if it's needed.

+}
+
+void DeferredGpuCommandService::RunTasks() {
+  size_t num_tasks;

[boliu, 2014/02/08 18:55:54]

bool has_more_tasks?

[no sievers, 2014/02/12 03:09:15]

Done.

+  {
+    base::AutoLock lock(tasks_lock_);

[boliu, 2014/02/08 18:55:54]

Do we need a lock? We are single threaded here :)

[no sievers, 2014/02/12 03:09:15]

Yes, because of the video context which queues tasks from the blink thread.

+    num_tasks = tasks_.size();
+  }
+
+  while (num_tasks) {
+    base::Closure task;
+    {
+      base::AutoLock lock(tasks_lock_);
+      task = tasks_.front();
+      tasks_.pop();
+    }
+    task.Run();
+    {
+      base::AutoLock lock(tasks_lock_);
+      num_tasks = tasks_.size();
+    }
+
+  }
+}
+
 // static
 void BrowserViewRenderer::SetAwDrawSWFunctionTable(
     AwDrawSWFunctionTable* table) {
   g_sw_draw_functions = table;
-  gpu::InProcessCommandBuffer::SetScheduleCallback(
-      base::Bind(&ScheduleGpuWork));
 }
 
 // static
 AwDrawSWFunctionTable* BrowserViewRenderer::GetAwDrawSWFunctionTable() {
   return g_sw_draw_functions;
 }
 
 InProcessViewRenderer::InProcessViewRenderer(
     BrowserViewRenderer::Client* client,
     JavaHelper* java_helper,
@@ skipping 124 matching lines @@
   // normal levels in the next DrawGL call.
   content::SynchronousCompositorMemoryPolicy policy;
   policy.bytes_limit = 0;
   policy.num_resources_limit = 0;
   if (memory_policy_ == policy)
     return;
 
   TRACE_EVENT0("android_webview", "InProcessViewRenderer::TrimMemory");
   ScopedAppGLStateRestore state_restore(
       ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
-  gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
+  gl_queue_->RunTasks();
   ScopedAllowGL allow_gl;
 
   SetMemoryPolicy(policy);
   ForceFakeCompositeSW();
 }
 
 void InProcessViewRenderer::SetMemoryPolicy(
     content::SynchronousCompositorMemoryPolicy& new_policy) {
   if (memory_policy_ == new_policy)
     return;
@@ skipping 20 matching lines @@
     return compositor_ && client_->RequestDrawGL(java_canvas);
   }
   // Perform a software draw
   return DrawSWInternal(java_canvas, clip);
 }
 
 bool InProcessViewRenderer::InitializeHwDraw() {
   TRACE_EVENT0("android_webview", "InitializeHwDraw");
   DCHECK(!gl_surface_);
   gl_surface_  = new AwGLSurface;
-  hardware_failed_ = !compositor_->InitializeHwDraw(gl_surface_);
+  gl_queue_ = new DeferredGpuCommandQueue;
+  hardware_failed_ = !compositor_->InitializeHwDraw(gl_surface_, gl_queue_);
   hardware_initialized_ = true;
 
-  if (hardware_failed_)
+  if (hardware_failed_) {
     gl_surface_ = NULL;
+    gl_queue_ = NULL;
+  } 
 
   return !hardware_failed_;
 }
 
 void InProcessViewRenderer::DrawGL(AwDrawGLInfo* draw_info) {
   TRACE_EVENT0("android_webview", "InProcessViewRenderer::DrawGL");
 
   manager_key_ = g_view_renderer_manager.Get().DidDrawGL(manager_key_, this);
 
   // 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();
+  gl_queue_->RunTasks();
   ScopedAllowGL allow_gl;
 
   if (!attached_to_window_) {
     TRACE_EVENT_INSTANT0(
         "android_webview", "EarlyOut_NotAttached", TRACE_EVENT_SCOPE_THREAD);
     return;
   }
 
   if (draw_info->mode == AwDrawGLInfo::kModeProcess) {
     TRACE_EVENT_INSTANT0(
@@ skipping 268 matching lines @@
 void InProcessViewRenderer::OnDetachedFromWindow() {
   TRACE_EVENT0("android_webview",
                "InProcessViewRenderer::OnDetachedFromWindow");
 
   NoLongerExpectsDrawGL();
   if (hardware_initialized_) {
     DCHECK(compositor_);
 
     ScopedAppGLStateRestore state_restore(
         ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
-    gpu::InProcessCommandBuffer::ProcessGpuWorkOnCurrentThread();
+    gl_queue->RunTasks();
     ScopedAllowGL allow_gl;
     compositor_->ReleaseHwDraw();
     hardware_initialized_ = false;
   }
 
   gl_surface_ = NULL;
+  gl_queue_ = NULL;
   attached_to_window_ = false;
 }
 
 bool InProcessViewRenderer::IsAttachedToWindow() {
   return attached_to_window_;
 }
 
 bool InProcessViewRenderer::IsVisible() {
   // Ignore |window_visible_| if |attached_to_window_| is false.
   return view_visible_ && (!attached_to_window_ || window_visible_);
@@ skipping 291 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