Part 1: Refactor Android WebView graphics code

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"
@@ skipping 142 matching lines @@
 // static
 AwBrowserPermissionRequestDelegate* AwBrowserPermissionRequestDelegate::FromID(
     int render_process_id, int render_view_id) {
   AwContents* aw_contents = AwContents::FromID(render_process_id,
                                                render_view_id);
   return implicit_cast<AwBrowserPermissionRequestDelegate*>(aw_contents);
 }
 
 AwContents::AwContents(scoped_ptr<WebContents> web_contents)
     : web_contents_(web_contents.Pass()),
-      shared_renderer_state_(
+      compositor_proxy_(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
           this),
       browser_view_renderer_(
-          this,
-          &shared_renderer_state_,
+          this /* AwGLMethods */,
+          this /* BrowserViewRendererClient */,
+          &compositor_proxy_,
           web_contents_.get(),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)),
       renderer_manager_key_(GLViewRendererManager::GetInstance()->NullKey()) {
   base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, 1);
+  compositor_proxy_.SetBrowserViewRenderer(&browser_view_renderer_);

[boliu, 2014/10/23 16:40:05]

need to set it to null in the destructor, and in theory null check every single
use of the pointer in the proxy

Maybe we can find a better way to structure it to avoid this.

[hush (inactive), 2014/10/24 21:31:33]

yeah. We changed the object ownership model as discussed. So no need to do this
anymore

   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, web_contents_.get()));
 
@@ skipping 185 matching lines @@
     LOG(ERROR) << "Received unexpected kModeProcessNoContext";
   }
 
   // kModeProcessNoContext should never happen because we tear down hardware
   // in onTrimMemory. However that guarantee is maintained outside of chromium
   // code. Not notifying shared state in kModeProcessNoContext can lead to
   // immediate deadlock, which is slightly more catastrophic than leaks or
   // corruption.
   if (draw_info->mode == AwDrawGLInfo::kModeProcess ||
       draw_info->mode == AwDrawGLInfo::kModeProcessNoContext) {
-    shared_renderer_state_.DidDrawGLProcess();
+    compositor_proxy_.DidDrawGLProcess();
   }
 
-  if (shared_renderer_state_.IsInsideHardwareRelease()) {
+  if (compositor_proxy_.IsInsideHardwareRelease()) {
     hardware_renderer_.reset();
     // Flush the idle queue in tear down.
     DeferredGpuCommandService::GetInstance()->PerformAllIdleWork();
     return;
   }
 
   if (draw_info->mode != AwDrawGLInfo::kModeDraw) {
     if (draw_info->mode == AwDrawGLInfo::kModeProcess) {
       DeferredGpuCommandService::GetInstance()->PerformIdleWork(true);
     }
     return;
   }
 
   if (!hardware_renderer_) {
-    hardware_renderer_.reset(new HardwareRenderer(&shared_renderer_state_));
+    hardware_renderer_.reset(new HardwareRenderer(&compositor_proxy_));
     hardware_renderer_->CommitFrame();
   }
 
   hardware_renderer_->DrawGL(state_restore.stencil_enabled(),
                              state_restore.framebuffer_binding_ext(),
                              draw_info);
   DeferredGpuCommandService::GetInstance()->PerformIdleWork(false);
 }
 
 namespace {
@@ skipping 355 matching lines @@
 }
 
 void AwContents::PostInvalidate() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null())
     Java_AwContents_postInvalidateOnAnimation(env, obj.obj());
 }
 
-void AwContents::UpdateParentDrawConstraints() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_.UpdateParentDrawConstraints();
-}
-
-void AwContents::DidSkipCommitFrame() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  browser_view_renderer_.DidSkipCommitFrame();
-}
-
 void AwContents::OnNewPicture() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null()) {
     devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
         "onNewPicture");
     Java_AwContents_onNewPicture(env, obj.obj());
   }
 }
@@ skipping 89 matching lines @@
 void AwContents::OnAttachedToWindow(JNIEnv* env, jobject obj, int w, int h) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   browser_view_renderer_.OnAttachedToWindow(w, h);
 }
 
 void AwContents::InitializeHardwareDrawIfNeeded() {
   GLViewRendererManager* manager = GLViewRendererManager::GetInstance();
 
   base::AutoLock lock(render_thread_lock_);
   if (renderer_manager_key_ == manager->NullKey()) {
-    renderer_manager_key_ = manager->PushBack(&shared_renderer_state_);
+    renderer_manager_key_ = manager->PushBack(&compositor_proxy_);
     DeferredGpuCommandService::SetInstance();
   }
 }
 
 void AwContents::OnDetachedFromWindow(JNIEnv* env, jobject obj) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ReleaseHardwareDrawIfNeeded();
   browser_view_renderer_.OnDetachedFromWindow();
 }
 
 void AwContents::ReleaseHardwareDrawIfNeeded() {
-  InsideHardwareReleaseReset inside_reset(&shared_renderer_state_);
+  InsideHardwareReleaseReset inside_reset(&compositor_proxy_);
 
-  JNIEnv* env = AttachCurrentThread();
-  ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
-  if (!obj.is_null())
-    Java_AwContents_invalidateOnFunctorDestroy(env, obj.obj());
+  InvalidateOnFunctorDestroy();
 
   bool hardware_initialized = browser_view_renderer_.hardware_enabled();
   if (hardware_initialized) {
     bool draw_functor_succeeded = RequestDrawGL(NULL, true);
     if (!draw_functor_succeeded) {
       LOG(ERROR) << "Unable to free GL resources. Has the Window leaked?";
       // Calling release on wrong thread intentionally.
       AwDrawGLInfo info;
       info.mode = AwDrawGLInfo::kModeProcess;
       DrawGL(&info);
@@ skipping 11 matching lines @@
       renderer_manager_key_ = manager->NullKey();
     }
   }
 
   if (hardware_initialized) {
     // Flush any invoke functors that's caused by OnDetachedFromWindow.
     RequestDrawGL(NULL, true);
   }
 }
 
+void AwContents::InvalidateOnFunctorDestroy() {
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
+  if (!obj.is_null())
+    Java_AwContents_invalidateOnFunctorDestroy(env, obj.obj());
+}
+
 base::android::ScopedJavaLocalRef<jbyteArray>
 AwContents::GetOpaqueState(JNIEnv* env, jobject obj) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Required optimization in WebViewClassic to not save any state if
   // there has been no navigations.
   if (!web_contents_->GetController().GetEntryCount())
     return ScopedJavaLocalRef<jbyteArray>();
 
   Pickle pickle;
   if (!WriteToPickle(*web_contents_, &pickle)) {
@@ skipping 223 matching lines @@
   }
 
   browser_view_renderer_.TrimMemory(level, visible);
 }
 
 void SetShouldDownloadFavicons(JNIEnv* env, jclass jclazz) {
   g_should_download_favicons = true;
 }
 
 }  // namespace android_webview