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 129 matching lines @@
       overscroll_effect_(OverscrollGlow::Create(overscroll_effect_enabled_)),
       flush_input_requested_(false),
       accelerated_surface_route_id_(0),
       using_synchronous_compositor_(SynchronousCompositorImpl::FromID(
                                         widget_host->GetProcess()->GetID(),
                                         widget_host->GetRoutingID()) != NULL),
       frame_evictor_(new DelegatedFrameEvictor(this)),
       using_delegated_renderer_(CommandLine::ForCurrentProcess()->HasSwitch(
                                     switches::kEnableDelegatedRenderer) &&
                                 !CommandLine::ForCurrentProcess()->HasSwitch(
-                                    switches::kDisableDelegatedRenderer)) {
+                                    switches::kDisableDelegatedRenderer)),
+      locks_on_frame_count_(0) {
   if (!using_delegated_renderer_) {
     texture_layer_ = cc::TextureLayer::Create(NULL);
     layer_ = texture_layer_;
   }
 
   host_->SetView(this);
   SetContentViewCore(content_view_core);
   ImageTransportFactoryAndroid::AddObserver(this);
 }
 
@@ skipping 117 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();
+  locks_on_frame_count_++;
 }
 
-void RenderWidgetHostViewAndroid::UnlockResources() {
+void RenderWidgetHostViewAndroid::UnlockSurfaceForCopy() {
+  if (!frame_evictor_->HasFrame() || locks_on_frame_count_ == 0)
+    return;
+
   DCHECK(HasValidFrame());
   frame_evictor_->UnlockFrame();
+  locks_on_frame_count_--;
+
+  if (locks_on_frame_count_ == 0 && last_frame_info_) {
+    InternalSwapCompositorFrame(last_frame_info_->output_surface_id,
+                                last_frame_info_->frame.Pass());
+    last_frame_info_.reset();
+  }
+}
+
+void RenderWidgetHostViewAndroid::ReleaseLocksOnSurface() {
+  if (!frame_evictor_->HasFrame()) {
+    DCHECK_EQ(locks_on_frame_count_, 0u);
+    return;
+  }
+  while (locks_on_frame_count_ > 0) {
+    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());
 
@@ skipping 346 matching lines @@
     delegated_renderer_layer_->SetBounds(content_size_in_layer_);
     delegated_renderer_layer_->SetNeedsDisplay();
   }
 
   base::Closure ack_callback =
       base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
                  weak_ptr_factory_.GetWeakPtr(),
                  output_surface_id);
 
   if (host_->is_hidden())
     ack_callback.Run();

[no sievers, 2014/03/18 23:44:07]

Do we need to call RunAckCallbacks() here instead now?
Since you might have this:

- Swap, push ack
- Lock
- Hide
- Swap, push ack for retained frame
- Unlock
- |-> calls Swap, now runs ack callback for retained frame but not orig

How about:
  ack_callbacks_.push(ack_callback);
  if (host_->is_hidden())
    RunAckCallbacks();

[powei, 2014/03/19 17:50:42]

Done.

   else
     ack_callbacks_.push(ack_callback);
 }
 
 void RenderWidgetHostViewAndroid::ComputeContentsSize(
     const cc::CompositorFrameMetadata& frame_metadata) {
   // Calculate the content size.  This should be 0 if the texture_size is 0.
   gfx::Vector2dF offset;
   if (texture_size_in_layer_.GetArea() > 0)
     offset = frame_metadata.location_bar_content_translation;
   offset.set_y(offset.y() + frame_metadata.overdraw_bottom_height);
   offset.Scale(frame_metadata.device_scale_factor);
   content_size_in_layer_ =
       gfx::Size(texture_size_in_layer_.width() - offset.x(),
                 texture_size_in_layer_.height() - offset.y());
   // Content size changes should be reflected in associated animation effects.
   UpdateAnimationSize(frame_metadata);
 }
 
-void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
+void RenderWidgetHostViewAndroid::InternalSwapCompositorFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::CompositorFrame> frame) {
+  if (locks_on_frame_count_ > 0) {
+    DCHECK(HasValidFrame());
+    RetainFrame(output_surface_id, frame.Pass());
+    return;
+  }
+
   // Always let ContentViewCore know about the new frame first, so it can decide
   // to schedule a Draw immediately when it sees the texture layer invalidation.
   UpdateContentViewCoreFrameMetadata(frame->metadata);
 
   if (layer_ && layer_->layer_tree_host()) {
     for (size_t i = 0; i < frame->metadata.latency_info.size(); i++) {
       scoped_ptr<cc::SwapPromise> swap_promise(
           new cc::LatencyInfoSwapPromise(frame->metadata.latency_info[i]));
       layer_->layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
     }
@@ skipping 34 matching lines @@
   ImageTransportFactoryAndroid::GetInstance()->WaitSyncPoint(
       frame->gl_frame_data->sync_point);
 
   texture_size_in_layer_ = frame->gl_frame_data->size;
   ComputeContentsSize(frame->metadata);
 
   BuffersSwapped(frame->gl_frame_data->mailbox, output_surface_id, callback);
   frame_evictor_->SwappedFrame(!host_->is_hidden());
 }
 
+void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
+    uint32 output_surface_id,
+    scoped_ptr<cc::CompositorFrame> frame) {
+  InternalSwapCompositorFrame(output_surface_id, frame.Pass());
+}
+
+void RenderWidgetHostViewAndroid::RetainFrame(
+    uint32 output_surface_id,
+    scoped_ptr<cc::CompositorFrame> frame) {
+  DCHECK(locks_on_frame_count_);
+
+  // Store the incoming frame so that it can be swapped when all the locks have
+  // been released.  If there is already a stored frame, then send

[no sievers, 2014/03/18 23:44:07]

nit: extra space

[powei, 2014/03/19 17:50:42]

Done.

+  // acknowledgement and drop it.
+  if (last_frame_info_) {
+    base::Closure ack_callback =
+        base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   last_frame_info_->output_surface_id);
+    if (host_->is_hidden())
+      ack_callback.Run();

[no sievers, 2014/03/18 23:44:07]

The code does actually not match the comment above. We only send the ack if we
are hidden, otherwise it's deferred.

I'm wondering if that can have unwanted consequences if we run the ack here and
return unused child resources for the current frame (the one supposed to be
locked, not the one received here). Can we always just push the ack here?

[powei, 2014/03/19 17:50:42]

Done.

+    else
+      ack_callbacks_.push(ack_callback);
+  }
+
+  last_frame_info_.reset(new LastFrameInfo(output_surface_id, frame.Pass()));
+}
+
 void RenderWidgetHostViewAndroid::SynchronousFrameMetadata(
     const cc::CompositorFrameMetadata& frame_metadata) {
   // This is a subset of OnSwapCompositorFrame() used in the synchronous
   // compositor flow.
   UpdateContentViewCoreFrameMetadata(frame_metadata);
   ComputeContentsSize(frame_metadata);
 
   // DevTools ScreenCast support for Android WebView.
   if (DevToolsAgentHost::HasFor(RenderViewHost::From(GetRenderWidgetHost()))) {
     scoped_refptr<DevToolsAgentHost> dtah =
@@ skipping 80 matching lines @@
     texture_layer_->SetContentsOpaque(true);
   }
 
   ImageTransportFactoryAndroid::GetInstance()->AcquireTexture(
       texture_id_in_layer_, mailbox.name);
 
   current_mailbox_ = mailbox;
   last_output_surface_id_ = output_surface_id;
 
   if (host_->is_hidden())
     ack_callback.Run();

[no sievers, 2014/03/18 23:44:07]

see comment in SwapDelegatedFrame(), although this is deprecated.

[powei, 2014/03/19 17:50:42]

Done.

   else
     ack_callbacks_.push(ack_callback);
 }
 
 void RenderWidgetHostViewAndroid::AttachLayers() {
   if (!content_view_core_)
     return;
   if (!layer_.get())
     return;
 
@@ skipping 295 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 115 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content