Expose locks for CopyFromCompositingSurface/CopyFromBackingStore API

content/browser/renderer_host/render_widget_host_view_android.cc

 // Copyright (c) 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 "content/browser/renderer_host/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 267 matching lines @@
 
 bool RenderWidgetHostViewAndroid::HasValidFrame() const {
   if (!content_view_core_)
     return false;
   if (!layer_)
     return false;
 
   if (texture_size_in_layer_.IsEmpty())
     return false;
 
+  if (!frame_evictor_->HasFrame())
+    return false;
+
   if (using_delegated_renderer_) {
     if (!delegated_renderer_layer_.get())
       return false;
   } else {
     if (texture_id_in_layer_ == 0)
       return false;
   }
 
   return true;
 }
@@ skipping 70 matching lines @@
   WasHidden();
 }
 
 bool RenderWidgetHostViewAndroid::IsShowing() {
   // ContentViewCoreImpl represents the native side of the Java
   // ContentViewCore.  It being NULL means that it is not attached
   // to the View system yet, so we treat this RWHVA as hidden.
   return is_showing_ && content_view_core_;
 }
 
-void RenderWidgetHostViewAndroid::LockResources() {
+void RenderWidgetHostViewAndroid::LockSurfaceForCopy() {
   DCHECK(HasValidFrame());
   DCHECK(host_);
-  DCHECK(!host_->is_hidden());
+  DCHECK(frame_evictor_->HasFrame());
   frame_evictor_->LockFrame();
 }
 
-void RenderWidgetHostViewAndroid::UnlockResources() {
+void RenderWidgetHostViewAndroid::UnlockSurfaceForCopy() {
+  if (!frame_evictor_->HasFrame())
+    return;
+
+  size_t target_lock_count = is_showing_ ? 1 : 0;
+  DCHECK_GE(frame_evictor_->FrameLockCount(), target_lock_count);
+  if (frame_evictor_->FrameLockCount() == target_lock_count)

[piman, 2014/03/04 19:09:55]

This feels iffy.

If some other code starts talking to the frame evictor or the renderer frame
manager to lock/unlock, this code will become wrong.
It's similar to looking at the refcount of an object and deciding whether to
ref/unref it.

At a high level, the RWHVA should only concern itself with the locks it itself
takes. It can keep track of that. It would remove some amount of code in the
other classes, so that you can only, at worst, keep a counter that you increment
in LockSurfaceForCopy and decrement in UnlockSurfaceForCopy, and reset in
ReleaseLocksOnSurface, as you do the LockFrame/UnlockFrame operations.

[powei, 2014/03/04 20:49:22]

Done.

+    return;
+
   DCHECK(HasValidFrame());
   frame_evictor_->UnlockFrame();
 }
 
+void RenderWidgetHostViewAndroid::ReleaseLocksOnSurface() {
+  size_t target_lock_count = is_showing_ ? 1 : 0;
+  while (frame_evictor_->FrameLockCount() > target_lock_count ) {
+    UnlockSurfaceForCopy();
+  }
+}
+
 gfx::Rect RenderWidgetHostViewAndroid::GetViewBounds() const {
   if (!content_view_core_)
     return gfx::Rect(default_size_);
 
   gfx::Size size = content_view_core_->GetViewportSizeDip();
   gfx::Size offset = content_view_core_->GetViewportSizeOffsetDip();
   size.Enlarge(-offset.width(), -offset.height());
 
   return gfx::Rect(size);
 }
@@ skipping 401 matching lines @@
       layer_->layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
     }
   }
 
   if (frame->delegated_frame_data) {
     DCHECK(using_delegated_renderer_);
 
     DCHECK(frame->delegated_frame_data);
     DCHECK(!frame->delegated_frame_data->render_pass_list.empty());
 
+    size_t target_lock_count = is_showing_ ? 1 : 0;
+    if (frame_evictor_->FrameLockCount() > target_lock_count) {
+      base::Closure ack_callback =
+          base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     output_surface_id);
+      if (host_->is_hidden())
+        ack_callback.Run();
+      else
+        ack_callbacks_.push(ack_callback);
+      return;
+    }
     cc::RenderPass* root_pass =
         frame->delegated_frame_data->render_pass_list.back();
     texture_size_in_layer_ = root_pass->output_rect.size();
     ComputeContentsSize(frame->metadata);
 
     SwapDelegatedFrame(output_surface_id, frame->delegated_frame_data.Pass());
     frame_evictor_->SwappedFrame(!host_->is_hidden());
     return;
   }
 
@@ skipping 432 matching lines @@
 }
 
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
   RunAckCallbacks();
 
   RemoveLayers();
   if (content_view_core_ && !using_synchronous_compositor_)
     content_view_core_->GetWindowAndroid()->RemoveObserver(this);
 
+  if (content_view_core != content_view_core_)
+    ReleaseLocksOnSurface();
+
   content_view_core_ = content_view_core;
 
   if (GetBrowserAccessibilityManager()) {
     base::android::ScopedJavaLocalRef<jobject> obj;
     if (content_view_core_)
       obj = content_view_core_->GetJavaObject();
     GetBrowserAccessibilityManager()->ToBrowserAccessibilityManagerAndroid()->
         SetContentViewCore(obj);
   }
 
@@ skipping 13 matching lines @@
   RunAckCallbacks();
 }
 
 void RenderWidgetHostViewAndroid::OnDetachCompositor() {
   DCHECK(content_view_core_);
   DCHECK(!using_synchronous_compositor_);
   RunAckCallbacks();
 }
 
 void RenderWidgetHostViewAndroid::OnLostResources() {
+  ReleaseLocksOnSurface();
   if (texture_layer_.get())
     texture_layer_->SetIsDrawable(false);
   if (delegated_renderer_layer_.get())
     DestroyDelegatedContent();
   texture_id_in_layer_ = 0;
   RunAckCallbacks();
 }
 
 // static
 void RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult(
@@ skipping 104 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content