Part 1: Refactor Android WebView graphics code

android_webview/browser/browser_view_renderer.cc

Index: android_webview/browser/browser_view_renderer.cc
diff --git a/android_webview/browser/browser_view_renderer.cc b/android_webview/browser/browser_view_renderer.cc
index cbe31857a4dab1eab93ab4dc6f94858ad165e20d..cab6c9c972894efed723b647caeaaf09d6bae6d5 100644
--- a/android_webview/browser/browser_view_renderer.cc
+++ b/android_webview/browser/browser_view_renderer.cc
@@ -4,8 +4,9 @@
 
 #include "android_webview/browser/browser_view_renderer.h"
 
+#include "android_webview/browser/aw_gl_methods.h"
 #include "android_webview/browser/browser_view_renderer_client.h"
-#include "android_webview/browser/shared_renderer_state.h"
+#include "android_webview/browser/browser_view_renderer_proxy.h"
 #include "android_webview/common/aw_switches.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ -14,6 +15,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "cc/output/compositor_frame.h"
+#include "cc/output/compositor_frame_ack.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
@@ -66,12 +68,14 @@ void BrowserViewRenderer::CalculateTileMemoryPolicy() {
 }
 
 BrowserViewRenderer::BrowserViewRenderer(
+    AwGLMethods* gl_methods,
     BrowserViewRendererClient* client,
-    SharedRendererState* shared_renderer_state,
+    BrowserViewRendererProxy* proxy,
     content::WebContents* web_contents,
     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner)
-    : client_(client),
-      shared_renderer_state_(shared_renderer_state),
+    : gl_methods_(gl_methods),
+      client_(client),
+      proxy_(proxy),
       web_contents_(web_contents),
       ui_task_runner_(ui_task_runner),
       compositor_(NULL),
@@ -211,7 +215,7 @@ bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
   if (!compositor_)
     return false;
 
-  shared_renderer_state_->SetScrollOffset(last_on_draw_scroll_offset_);
+  proxy_->SetScrollOffset(last_on_draw_scroll_offset_);
 
   if (!hardware_enabled_) {
     hardware_enabled_ = compositor_->InitializeHwDraw();
@@ -227,26 +231,26 @@ bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
     TRACE_EVENT_INSTANT0("android_webview",
                          "EarlyOut_EmptyVisibleRect",
                          TRACE_EVENT_SCOPE_THREAD);
-    shared_renderer_state_->SetForceInvalidateOnNextDrawGL(true);
-    return client_->RequestDrawGL(java_canvas, false);
+    proxy_->SetForceInvalidateOnNextDrawGL(true);
+    return gl_methods_->RequestDrawGL(java_canvas, false);
   }
 
   ReturnResourceFromParent();
-  if (shared_renderer_state_->HasCompositorFrame()) {
+  if (proxy_->HasCompositorFrame()) {
     TRACE_EVENT_INSTANT0("android_webview",
                          "EarlyOut_PreviousFrameUnconsumed",
                          TRACE_EVENT_SCOPE_THREAD);
     DidSkipCompositeInDraw();
-    return client_->RequestDrawGL(java_canvas, false);
+    return gl_methods_->RequestDrawGL(java_canvas, false);
   }
 
   scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
   if (!frame.get())
     return false;
 
-  shared_renderer_state_->SetCompositorFrame(frame.Pass(), false);
+  proxy_->SetCompositorFrame(frame.Pass(), false);
   GlobalTileManager::GetInstance()->DidUse(tile_manager_key_);
-  return client_->RequestDrawGL(java_canvas, false);
+  return gl_methods_->RequestDrawGL(java_canvas, false);
 }
 
 scoped_ptr<cc::CompositorFrame> BrowserViewRenderer::CompositeHw() {
@@ -254,7 +258,7 @@ scoped_ptr<cc::CompositorFrame> BrowserViewRenderer::CompositeHw() {
   RequestMemoryPolicy(new_policy);
   compositor_->SetMemoryPolicy(memory_policy_);
 
-  parent_draw_constraints_ = shared_renderer_state_->ParentDrawConstraints();
+  parent_draw_constraints_ = proxy_->GetParentDrawConstraints();
   gfx::Size surface_size(width_, height_);
   gfx::Rect viewport(surface_size);
   gfx::Rect clip = viewport;
@@ -284,34 +288,20 @@ scoped_ptr<cc::CompositorFrame> BrowserViewRenderer::CompositeHw() {
   return frame.Pass();
 }
 
-void BrowserViewRenderer::UpdateParentDrawConstraints() {
+void BrowserViewRenderer::SetParentDrawConstraints() {
   // Post an invalidate if the parent draw constraints are stale and there is
   // no pending invalidate.
-  bool needs_force_invalidate =
-      shared_renderer_state_->NeedsForceInvalidateOnNextDrawGL();
+  bool needs_force_invalidate = proxy_->NeedsForceInvalidateOnNextDrawGL();
   if (needs_force_invalidate ||
-      !parent_draw_constraints_.Equals(
-          shared_renderer_state_->ParentDrawConstraints())) {
-    shared_renderer_state_->SetForceInvalidateOnNextDrawGL(false);
+      !parent_draw_constraints_.Equals(proxy_->GetParentDrawConstraints())) {
+    proxy_->SetForceInvalidateOnNextDrawGL(false);
     EnsureContinuousInvalidation(true, needs_force_invalidate);
   }
 }
 
-void BrowserViewRenderer::ReturnUnusedResource(
-    scoped_ptr<cc::CompositorFrame> frame) {
-  if (!frame.get())
-    return;
-
-  cc::CompositorFrameAck frame_ack;
-  cc::TransferableResource::ReturnResources(
-      frame->delegated_frame_data->resource_list, &frame_ack.resources);
-  if (compositor_ && !frame_ack.resources.empty())
-    compositor_->ReturnResources(frame_ack);
-}
-
 void BrowserViewRenderer::ReturnResourceFromParent() {
   cc::CompositorFrameAck frame_ack;
-  shared_renderer_state_->SwapReturnedResources(&frame_ack.resources);
+  proxy_->SwapReturnedResources(&frame_ack.resources);
   if (compositor_ && !frame_ack.resources.empty()) {
     compositor_->ReturnResources(frame_ack);
   }
@@ -444,9 +434,8 @@ void BrowserViewRenderer::OnDetachedFromWindow() {
 
 void BrowserViewRenderer::ReleaseHardware() {
   DCHECK(hardware_enabled_);
-  ReturnUnusedResource(shared_renderer_state_->PassCompositorFrame());
+  // Unused resource held by proxy_ will be returned by the proxy.

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

Can we not do this in this CL?

If there's something depends on this change, pull it out in to a separate CL and
land that first

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

I put this back. I guess I will do this in part 2, where I move DrawGL and
hardware initialization/release from AwContents to SharedRendererState

   ReturnResourceFromParent();
-  DCHECK(shared_renderer_state_->ReturnedResourcesEmpty());
 
   if (compositor_) {
     compositor_->ReleaseHwDraw();
@@ -743,10 +732,12 @@ void BrowserViewRenderer::FallbackTickFired() {
   if (compositor_needs_continuous_invalidate_ && compositor_) {
     if (hardware_enabled_) {
       ReturnResourceFromParent();
-      ReturnUnusedResource(shared_renderer_state_->PassCompositorFrame());
       scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
       if (frame.get()) {
-        shared_renderer_state_->SetCompositorFrame(frame.Pass(), true);
+        // The resources in the current uncommitted frame held by
+        // BrowserViewRendererProxy will be
+        // returned by BrowserViewRenderProxy
+        proxy_->SetCompositorFrame(frame.Pass(), true);
       }
     } else {
       ForceFakeCompositeSW();