Part 1: Refactor Android WebView graphics code

android_webview/browser/compositor_proxy.cc

 // Copyright 2014 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/shared_renderer_state.h"
+#include "android_webview/browser/compositor_proxy.h"
 
-#include "android_webview/browser/browser_view_renderer_client.h"
+#include "android_webview/browser/aw_gl_methods.h"
+#include "android_webview/browser/browser_view_renderer.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 
 namespace android_webview {
 
 namespace internal {
 
 class RequestDrawGLTracker {
  public:
   RequestDrawGLTracker();
-  bool ShouldRequestOnNoneUiThread(SharedRendererState* state);
-  bool ShouldRequestOnUiThread(SharedRendererState* state);
+  bool ShouldRequestOnNonUiThread(CompositorProxy* proxy);
+  bool ShouldRequestOnUiThread(CompositorProxy* proxy);
   void DidRequestOnUiThread();
   void ResetPending();
 
  private:
   base::Lock lock_;
-  SharedRendererState* pending_ui_;
-  SharedRendererState* pending_non_ui_;
+  CompositorProxy* pending_ui_;
+  CompositorProxy* pending_non_ui_;
 };
 
 RequestDrawGLTracker::RequestDrawGLTracker()
     : pending_ui_(NULL), pending_non_ui_(NULL) {
 }
 
-bool RequestDrawGLTracker::ShouldRequestOnNoneUiThread(
-    SharedRendererState* state) {
+bool RequestDrawGLTracker::ShouldRequestOnNonUiThread(CompositorProxy* proxy) {
   base::AutoLock lock(lock_);
   if (pending_ui_ || pending_non_ui_)
     return false;
-  pending_non_ui_ = state;
+  pending_non_ui_ = proxy;
   return true;
 }
 
-bool RequestDrawGLTracker::ShouldRequestOnUiThread(SharedRendererState* state) {
+bool RequestDrawGLTracker::ShouldRequestOnUiThread(CompositorProxy* proxy) {
   base::AutoLock lock(lock_);
   if (pending_non_ui_) {
     pending_non_ui_->ResetRequestDrawGLCallback();
     pending_non_ui_ = NULL;
   }
   if (pending_ui_)
     return false;
-  pending_ui_ = state;
+  pending_ui_ = proxy;
   return true;
 }
 
 void RequestDrawGLTracker::ResetPending() {
   base::AutoLock lock(lock_);
   pending_non_ui_ = NULL;
   pending_ui_ = NULL;
 }
 
 }  // namespace internal
 
 namespace {
 
 base::LazyInstance<internal::RequestDrawGLTracker> g_request_draw_gl_tracker =
     LAZY_INSTANCE_INITIALIZER;
-
 }
 
-SharedRendererState::SharedRendererState(
-    scoped_refptr<base::MessageLoopProxy> ui_loop,
-    BrowserViewRendererClient* client)
+CompositorProxy::CompositorProxy(scoped_refptr<base::MessageLoopProxy> ui_loop,
+                                 AwGLMethods* gl_methods)
     : ui_loop_(ui_loop),
-      client_on_ui_(client),
+      gl_methods_on_ui_(gl_methods),
       force_commit_(false),
       inside_hardware_release_(false),
       needs_force_invalidate_on_next_draw_gl_(false),
       weak_factory_on_ui_thread_(this) {
   DCHECK(ui_loop_->BelongsToCurrentThread());
-  DCHECK(client_on_ui_);
+  DCHECK(gl_methods_on_ui_);
   ui_thread_weak_ptr_ = weak_factory_on_ui_thread_.GetWeakPtr();
   ResetRequestDrawGLCallback();
 }
 
-SharedRendererState::~SharedRendererState() {
+CompositorProxy::~CompositorProxy() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
 }
 
-void SharedRendererState::ClientRequestDrawGL() {
+void CompositorProxy::ClientRequestDrawGL() {
   if (ui_loop_->BelongsToCurrentThread()) {
     if (!g_request_draw_gl_tracker.Get().ShouldRequestOnUiThread(this))
       return;
     ClientRequestDrawGLOnUIThread();
   } else {
-    if (!g_request_draw_gl_tracker.Get().ShouldRequestOnNoneUiThread(this))
+    if (!g_request_draw_gl_tracker.Get().ShouldRequestOnNonUiThread(this))
       return;
     base::Closure callback;
     {
       base::AutoLock lock(lock_);
       callback = request_draw_gl_closure_;
     }
     ui_loop_->PostTask(FROM_HERE, callback);
   }
 }
 
-void SharedRendererState::DidDrawGLProcess() {
+void CompositorProxy::DidDrawGLProcess() {
   g_request_draw_gl_tracker.Get().ResetPending();
 }
 
-void SharedRendererState::ResetRequestDrawGLCallback() {
+void CompositorProxy::ResetRequestDrawGLCallback() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   base::AutoLock lock(lock_);
-  request_draw_gl_cancelable_closure_.Reset(
-      base::Bind(&SharedRendererState::ClientRequestDrawGLOnUIThread,
-                 base::Unretained(this)));
+  request_draw_gl_cancelable_closure_.Reset(base::Bind(
+      &CompositorProxy::ClientRequestDrawGLOnUIThread, base::Unretained(this)));
   request_draw_gl_closure_ = request_draw_gl_cancelable_closure_.callback();
 }
 
-void SharedRendererState::ClientRequestDrawGLOnUIThread() {
+void CompositorProxy::ClientRequestDrawGLOnUIThread() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   ResetRequestDrawGLCallback();
-  if (!client_on_ui_->RequestDrawGL(NULL, false)) {
+  if (!gl_methods_on_ui_->RequestDrawGL(NULL, false)) {
     g_request_draw_gl_tracker.Get().ResetPending();
     LOG(ERROR) << "Failed to request GL process. Deadlock likely";
   }
 }
 
-void SharedRendererState::UpdateParentDrawConstraintsOnUIThread() {
+void CompositorProxy::SetParentDrawConstraintsOnUIThread() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
-  client_on_ui_->UpdateParentDrawConstraints();
+  browser_view_renderer_->SetParentDrawConstraints();
 }
 
-void SharedRendererState::SetScrollOffset(gfx::Vector2d scroll_offset) {
+void CompositorProxy::SetScrollOffset(gfx::Vector2d scroll_offset) {
   base::AutoLock lock(lock_);
   scroll_offset_ = scroll_offset;
 }
 
-gfx::Vector2d SharedRendererState::GetScrollOffset() {
+gfx::Vector2d CompositorProxy::GetScrollOffset() {
   base::AutoLock lock(lock_);
   return scroll_offset_;
 }
 
-bool SharedRendererState::HasCompositorFrame() const {
+bool CompositorProxy::HasCompositorFrame() const {
   base::AutoLock lock(lock_);
   return compositor_frame_.get();
 }
 
-void SharedRendererState::SetCompositorFrame(
-    scoped_ptr<cc::CompositorFrame> frame, bool force_commit) {
+void CompositorProxy::SetCompositorFrame(scoped_ptr<cc::CompositorFrame> frame,
+                                         bool force_commit) {
+  ReturnUnusedResources();
+
   base::AutoLock lock(lock_);
-  DCHECK(!compositor_frame_.get());
   compositor_frame_ = frame.Pass();
   force_commit_ = force_commit;
 }
 
-scoped_ptr<cc::CompositorFrame> SharedRendererState::PassCompositorFrame() {
+scoped_ptr<cc::CompositorFrame> CompositorProxy::PassCompositorFrame() {
   base::AutoLock lock(lock_);
   return compositor_frame_.Pass();
 }
 
-bool SharedRendererState::ForceCommit() const {
+bool CompositorProxy::ForceCommit() const {
   base::AutoLock lock(lock_);
   return force_commit_;
 }
 
-bool SharedRendererState::UpdateDrawConstraints(
+bool CompositorProxy::SetParentCompositorDrawConstraints(
     const ParentCompositorDrawConstraints& parent_draw_constraints) {
   base::AutoLock lock(lock_);
   if (needs_force_invalidate_on_next_draw_gl_ ||
       !parent_draw_constraints_.Equals(parent_draw_constraints)) {
     parent_draw_constraints_ = parent_draw_constraints;
     return true;
   }
 
   return false;
 }
 
-void SharedRendererState::PostExternalDrawConstraintsToChildCompositor(
+void CompositorProxy::PostExternalDrawConstraintsToChildCompositor(
     const ParentCompositorDrawConstraints& parent_draw_constraints) {
-  if (UpdateDrawConstraints(parent_draw_constraints)) {
+  if (SetParentCompositorDrawConstraints(parent_draw_constraints)) {
     // No need to hold the lock_ during the post task.
     ui_loop_->PostTask(
         FROM_HERE,
-        base::Bind(&SharedRendererState::UpdateParentDrawConstraintsOnUIThread,
+        base::Bind(&CompositorProxy::SetParentDrawConstraintsOnUIThread,
                    ui_thread_weak_ptr_));
   }
 }
 
-void SharedRendererState::DidSkipCommitFrame() {
-  ui_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&SharedRendererState::DidSkipCommitFrameOnUIThread,
-                 ui_thread_weak_ptr_));
+void CompositorProxy::DidSkipCommitFrame() {
+  ui_loop_->PostTask(FROM_HERE,
+                     base::Bind(&CompositorProxy::DidSkipCommitFrameOnUIThread,
+                                ui_thread_weak_ptr_));
 }
 
-void SharedRendererState::DidSkipCommitFrameOnUIThread() {
+void CompositorProxy::DidSkipCommitFrameOnUIThread() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
-  client_on_ui_->DidSkipCommitFrame();
+  DCHECK(browser_view_renderer_);
+  browser_view_renderer_->DidSkipCommitFrame();
 }
 
 const ParentCompositorDrawConstraints
-SharedRendererState::ParentDrawConstraints() const {
+CompositorProxy::GetParentDrawConstraints() const {
   base::AutoLock lock(lock_);
   return parent_draw_constraints_;
 }
 
-void SharedRendererState::SetForceInvalidateOnNextDrawGL(
+void CompositorProxy::SetForceInvalidateOnNextDrawGL(
     bool needs_force_invalidate_on_next_draw_gl) {
   base::AutoLock lock(lock_);
   needs_force_invalidate_on_next_draw_gl_ =
       needs_force_invalidate_on_next_draw_gl;
 }
 
-bool SharedRendererState::NeedsForceInvalidateOnNextDrawGL() const {
+bool CompositorProxy::NeedsForceInvalidateOnNextDrawGL() const {
   base::AutoLock lock(lock_);
   return needs_force_invalidate_on_next_draw_gl_;
 }
 
-void SharedRendererState::SetInsideHardwareRelease(bool inside) {
+void CompositorProxy::SetInsideHardwareRelease(bool inside) {
   base::AutoLock lock(lock_);
   inside_hardware_release_ = inside;
 }
 
-bool SharedRendererState::IsInsideHardwareRelease() const {
+void CompositorProxy::ReturnUnusedResources() {
+  DCHECK(ui_loop_->BelongsToCurrentThread());
+
+  if (scoped_ptr<cc::CompositorFrame> frame = PassCompositorFrame()) {
+    cc::ReturnedResourceArray resources;
+    cc::TransferableResource::ReturnResources(
+        frame->delegated_frame_data->resource_list, &resources);
+    InsertReturnedResources(resources);
+  }
+}
+
+bool CompositorProxy::IsInsideHardwareRelease() const {
   base::AutoLock lock(lock_);
   return inside_hardware_release_;
 }
 
-void SharedRendererState::InsertReturnedResources(
+void CompositorProxy::InsertReturnedResources(
     const cc::ReturnedResourceArray& resources) {
   base::AutoLock lock(lock_);
   returned_resources_.insert(
       returned_resources_.end(), resources.begin(), resources.end());
 }
 
-void SharedRendererState::SwapReturnedResources(
+void CompositorProxy::SwapReturnedResources(
     cc::ReturnedResourceArray* resources) {
   DCHECK(resources->empty());
   base::AutoLock lock(lock_);
   resources->swap(returned_resources_);
 }
 
-bool SharedRendererState::ReturnedResourcesEmpty() const {
+void CompositorProxy::SetBrowserViewRenderer(
+    BrowserViewRenderer* browser_view_renderer) {
   base::AutoLock lock(lock_);
-  return returned_resources_.empty();
+  browser_view_renderer_ = browser_view_renderer;
 }
 
 InsideHardwareReleaseReset::InsideHardwareReleaseReset(
-    SharedRendererState* shared_renderer_state)
-    : shared_renderer_state_(shared_renderer_state) {
-  DCHECK(!shared_renderer_state_->IsInsideHardwareRelease());
-  shared_renderer_state_->SetInsideHardwareRelease(true);
+    CompositorProxy* compositor_proxy)
+    : compositor_proxy_(compositor_proxy) {
+  DCHECK(!compositor_proxy_->IsInsideHardwareRelease());
+  compositor_proxy_->SetInsideHardwareRelease(true);
 }
 
 InsideHardwareReleaseReset::~InsideHardwareReleaseReset() {
-  shared_renderer_state_->SetInsideHardwareRelease(false);
+  compositor_proxy_->SetInsideHardwareRelease(false);
 }
 
 }  // namespace android_webview