aw: Refactor hardware init

android_webview/native/aw_contents.cc

Index: android_webview/native/aw_contents.cc
diff --git a/android_webview/native/aw_contents.cc b/android_webview/native/aw_contents.cc
index 6ca3ac5fe524bd1eb41f5468078cf113c4faa9af..2cfdcd580b0d7697a3de6a1a5b6ee7a4f17a4702 100644
--- a/android_webview/native/aw_contents.cc
+++ b/android_webview/native/aw_contents.cc
@@ -10,10 +10,12 @@
 #include "android_webview/browser/aw_browser_main_parts.h"
 #include "android_webview/browser/aw_resource_context.h"
 #include "android_webview/browser/browser_view_renderer.h"
+#include "android_webview/browser/deferred_gpu_command_service.h"
 #include "android_webview/browser/gpu_memory_buffer_factory_impl.h"
 #include "android_webview/browser/hardware_renderer.h"
 #include "android_webview/browser/net_disk_cache_remover.h"
 #include "android_webview/browser/renderer_host/aw_resource_dispatcher_host_delegate.h"
+#include "android_webview/browser/scoped_app_gl_state_restore.h"
 #include "android_webview/common/aw_hit_test_data.h"
 #include "android_webview/common/devtools_instrumentation.h"
 #include "android_webview/native/aw_autofill_manager_delegate.h"
@@ -159,7 +161,8 @@ AwContents::AwContents(scoped_ptr<WebContents> web_contents)
           this,
           &shared_renderer_state_,
           web_contents_.get(),
-          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)) {
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)),
+      renderer_manager_key_(GLViewRendererManager::GetInstance()->NullKey()) {
   base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, 1);
   icon_helper_.reset(new IconHelper(web_contents_.get()));
   icon_helper_->SetListener(this);
@@ -324,14 +327,28 @@ jlong AwContents::GetAwDrawGLViewContext(JNIEnv* env, jobject obj) {
 }
 
 void AwContents::DrawGL(AwDrawGLInfo* draw_info) {
+  GLViewRendererManager::GetInstance()->DidDrawGL(renderer_manager_key_);
+
+  ScopedAppGLStateRestore state_restore(
+      draw_info->mode == AwDrawGLInfo::kModeDraw
+          ? ScopedAppGLStateRestore::MODE_DRAW
+          : ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
+  ScopedAllowGL allow_gl;
+
   for (base::Closure c = shared_renderer_state_.PopFrontClosure(); !c.is_null();
        c = shared_renderer_state_.PopFrontClosure()) {
     c.Run();
   }
 
+  if (!hardware_renderer_)
+    return;
+
   // TODO(boliu): Make this a task as well.
   DrawGLResult result;
-  if (hardware_renderer_ && hardware_renderer_->DrawGL(draw_info, &result)) {
+  if (hardware_renderer_->DrawGL(state_restore.stencil_enabled(),
+                                 state_restore.framebuffer_binding_ext(),
+                                 draw_info,
+                                 &result)) {
     content::BrowserThread::PostTask(
         content::BrowserThread::UI,
         FROM_HERE,
@@ -759,14 +776,22 @@ void AwContents::SetIsPaused(JNIEnv* env, jobject obj, bool paused) {
 
 void AwContents::OnAttachedToWindow(JNIEnv* env, jobject obj, int w, int h) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  // Add task but don't schedule it. It will run when DrawGL is called for
-  // the first time.
-  shared_renderer_state_.AppendClosure(
-      base::Bind(&AwContents::InitializeHardwareDrawOnRenderThread,
-                 base::Unretained(this)));
   browser_view_renderer_.OnAttachedToWindow(w, h);
 }
 
+void AwContents::InitializeHardwareDrawIfNeeded() {
+  GLViewRendererManager* manager = GLViewRendererManager::GetInstance();
+  if (renderer_manager_key_ == manager->NullKey()) {
+    // Add task but don't schedule it. It will run when DrawGL is called for
+    // the first time.
+    shared_renderer_state_.AppendClosure(
+        base::Bind(&AwContents::InitializeHardwareDrawOnRenderThread,
+                   base::Unretained(this)));
+    renderer_manager_key_ = manager->PushBack(&shared_renderer_state_);
+    DeferredGpuCommandService::SetInstance();
+  }
+}
+
 void AwContents::InitializeHardwareDrawOnRenderThread() {
   DCHECK(!hardware_renderer_);
   DCHECK(!shared_renderer_state_.IsHardwareInitialized());
@@ -783,14 +808,22 @@ void AwContents::OnDetachedFromWindow(JNIEnv* env, jobject obj) {
   bool draw_functor_succeeded = RequestDrawGL(NULL, true);
   if (!draw_functor_succeeded &&
       shared_renderer_state_.IsHardwareInitialized()) {
-    LOG(ERROR) << "Unable to free GL resources. Has the Window leaked";
+    LOG(ERROR) << "Unable to free GL resources. Has the Window leaked?";
     // Calling release on wrong thread intentionally.
-    ReleaseHardwareDrawOnRenderThread();
+    AwDrawGLInfo info;
+    info.mode = AwDrawGLInfo::kModeProcess;
+    DrawGL(&info);
   } else {
     shared_renderer_state_.ClearClosureQueue();
   }
 
   browser_view_renderer_.OnDetachedFromWindow();
+
+  GLViewRendererManager* manager = GLViewRendererManager::GetInstance();
+  if (renderer_manager_key_ != manager->NullKey()) {
+    manager->Remove(renderer_manager_key_);
+    renderer_manager_key_ = manager->NullKey();
+  }
 }
 
 void AwContents::ReleaseHardwareDrawOnRenderThread() {
@@ -850,6 +883,8 @@ bool AwContents::OnDraw(JNIEnv* env,
                         jint clip_right,
                         jint clip_bottom) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (is_hardware_accelerated)

[sgurun-gerrit only, 2014/05/08 22:55:12]

why is moving the initialization to here a better way?

[boliu, 2014/05/08 23:03:47]

It didn't really move, it's just preparation for ubercomp. I'll explain a bit.
So hardware life time is somethign like this:

1. Attach (to hardware tree)
2. OnDraw (with hardware canvas)
3. Functor (on render thread)
4. Detach

Of course 2 and 3 can repeat as many times as necessary.

Previously, before this patch, we initialized hardware lazily in 3. We don't
need to do anything in 2 because there was nothing to do.

But in ubercomp world, we do need to do something in 2. This also precents a
natural point to initialize hardware on UI thread, so moved the bit in 1 to 2 as
well.

Ehh...makes sense...?

+    InitializeHardwareDrawIfNeeded();
   return browser_view_renderer_.OnDraw(
       canvas,
       is_hardware_accelerated,