aw: Refactor hardware init

android_webview/native/aw_contents.cc

 // Copyright 2012 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/native/aw_contents.h"
 
 #include <limits>
 
 #include "android_webview/browser/aw_browser_context.h"
 #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"
 #include "android_webview/native/aw_browser_dependency_factory.h"
 #include "android_webview/native/aw_contents_client_bridge.h"
 #include "android_webview/native/aw_contents_io_thread_client_impl.h"
 #include "android_webview/native/aw_pdf_exporter.h"
 #include "android_webview/native/aw_picture.h"
 #include "android_webview/native/aw_web_contents_delegate.h"
 #include "android_webview/native/java_browser_view_renderer_helper.h"
@@ skipping 125 matching lines @@
     : weak_factory_on_ui_thread_(this),
       ui_thread_weak_ptr_(weak_factory_on_ui_thread_.GetWeakPtr()),
       web_contents_(web_contents.Pass()),
       shared_renderer_state_(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
           this),
       browser_view_renderer_(
           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);
   web_contents_->SetUserData(kAwContentsUserDataKey,
                              new AwContentsUserData(this));
   render_view_host_ext_.reset(
       new AwRenderViewHostExt(this, web_contents_.get()));
 
   permission_request_handler_.reset(new PermissionRequestHandler(this));
 
@@ skipping 144 matching lines @@
 jint GetNativeInstanceCount(JNIEnv* env, jclass) {
   return base::subtle::NoBarrier_Load(&g_instance_count);
 }
 
 jlong AwContents::GetAwDrawGLViewContext(JNIEnv* env, jobject obj) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return reinterpret_cast<intptr_t>(this);
 }
 
 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,
         base::Bind(&AwContents::DidDrawGL, ui_thread_weak_ptr_, result));
   }
 }
 
 void AwContents::DidDrawGL(const DrawGLResult& result) {
   browser_view_renderer_.DidDrawGL(result);
 }
@@ skipping 407 matching lines @@
   if (cvc) {
     cvc->PauseOrResumeGeolocation(paused);
     if (paused) {
       cvc->PauseVideo();
     }
   }
 }
 
 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());
   hardware_renderer_.reset(new HardwareRenderer(&shared_renderer_state_));
   shared_renderer_state_.SetHardwareInitialized(true);
 }
 
 void AwContents::OnDetachedFromWindow(JNIEnv* env, jobject obj) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   shared_renderer_state_.ClearClosureQueue();
   shared_renderer_state_.AppendClosure(base::Bind(
       &AwContents::ReleaseHardwareDrawOnRenderThread, base::Unretained(this)));
   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() {
   // No point in running any other commands if we released hardware already.
   shared_renderer_state_.ClearClosureQueue();
   if (!shared_renderer_state_.IsHardwareInitialized())
     return;
 
   hardware_renderer_.reset();
   shared_renderer_state_.SetHardwareInitialized(false);
@@ skipping 39 matching lines @@
                         jint scroll_y,
                         jint visible_left,
                         jint visible_top,
                         jint visible_right,
                         jint visible_bottom,
                         jint clip_left,
                         jint clip_top,
                         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,
       gfx::Vector2d(scroll_x, scroll_y),
       gfx::Rect(visible_left,
                 visible_top,
                 visible_right - visible_left,
                 visible_bottom - visible_top),
       gfx::Rect(
           clip_left, clip_top, clip_right - clip_left, clip_bottom - clip_top));
@@ skipping 199 matching lines @@
     return;
 
   browser_view_renderer_.TrimMemory(level, visible);
 }
 
 void SetShouldDownloadFavicons(JNIEnv* env, jclass jclazz) {
   g_should_download_favicons = true;
 }
 
 }  // namespace android_webview