android: Migrate old content readback to use async readback (and delegated renderer)

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 121 matching lines @@
   return latency_info;
 }
 
 }  // anonymous namespace
 
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
       needs_begin_frame_(false),
-      are_layers_attached_(!widget_host->is_hidden()),
+      is_showing_(!widget_host->is_hidden()),
       content_view_core_(NULL),
       ime_adapter_android_(this),
       cached_background_color_(SK_ColorWHITE),
       texture_id_in_layer_(0),
       last_output_surface_id_(kUndefinedOutputSurfaceId),
       weak_ptr_factory_(this),
       overscroll_effect_enabled_(
           !CommandLine::ForCurrentProcess()->
               HasSwitch(switches::kDisableOverscrollEdgeEffect)),
       overscroll_effect_(OverscrollGlow::Create(overscroll_effect_enabled_)),
@@ skipping 99 matching lines @@
   // Ignore the given size as only the Java code has the power to
   // resize the view on Android.
   default_size_ = size;
   WasResized();
 }
 
 void RenderWidgetHostViewAndroid::SetBounds(const gfx::Rect& rect) {
   SetSize(rect.size());
 }
 
-blink::WebGLId RenderWidgetHostViewAndroid::GetScaledContentTexture(
+void RenderWidgetHostViewAndroid::GetScaledContentBitmap(
     float scale,
-    gfx::Size* out_size) {
-  gfx::Size size(gfx::ToCeiledSize(
-      gfx::ScaleSize(texture_size_in_layer_, scale)));
-
-  if (!CompositorImpl::IsInitialized() ||
-      texture_id_in_layer_ == 0 ||
-      texture_size_in_layer_.IsEmpty() ||
-      size.IsEmpty()) {
-    if (out_size)
-        out_size->SetSize(0, 0);
-
-    return 0;
-  }
-
-  if (out_size)
-    *out_size = size;
-
-  GLHelper* helper = ImageTransportFactoryAndroid::GetInstance()->GetGLHelper();
-  return helper->CopyAndScaleTexture(texture_id_in_layer_,
-                                     texture_size_in_layer_,
-                                     size,
-                                     true,
-                                     GLHelper::SCALER_QUALITY_FAST);
+    gfx::Size* out_size,
+    const base::Callback<void(bool, const SkBitmap&)>& callback) {
+  gfx::Size bounds = layer_->bounds();
+  gfx::Rect src_subrect(bounds);
+  const gfx::Display& display =
+      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
+  float device_scale_factor = display.device_scale_factor();
+  DCHECK_GT(device_scale_factor, 0);
+  gfx::Size dst_size(
+      gfx::ToCeiledSize(gfx::ScaleSize(bounds, scale / device_scale_factor)));
+  *out_size = dst_size;
+  view->ResetClipping();

[no sievers, 2014/01/28 20:47:21]

Not sure how this is used by the app, it's really not obvious unfortunately.
But how comes this is not a problem to reset this arbitrarily?

[powei, 2014/01/29 13:53:17]

Done.  Not affecting delegated rendering so removed.

+  CopyFromCompositingSurface(src_subrect, dst_size, callback, false);
 }
 
 bool RenderWidgetHostViewAndroid::PopulateBitmapWithContents(jobject jbitmap) {
   if (!CompositorImpl::IsInitialized() ||
       texture_id_in_layer_ == 0 ||
       texture_size_in_layer_.IsEmpty())
     return false;
 
   gfx::JavaBitmap bitmap(jbitmap);
 
@@ skipping 18 matching lines @@
 
   gpu::gles2::GLES2Interface* gl =
       ImageTransportFactoryAndroid::GetInstance()->GetContextGL();
   gl->DeleteTextures(1, &texture);
 
   return true;
 }
 
 bool RenderWidgetHostViewAndroid::HasValidFrame() const {
   if (!content_view_core_)
     return false;

[no sievers, 2014/01/28 20:47:21]

nit: Can we just check for !layer_ here.

If the layer is not attached, it's not strictly an error. It just means that the
readback will be delayed until the layer gets reattached to the root.

We could allow this - it doesn't seem particularly illegal. If you are worried
that it could cause unwanted bugs, how about putting a check for that into the
app?

Can we also DCHECK(!is_showing_ || layer_) before?
Ideally even DCHECK((!is_showing_ && !is_locked_) || layer_);

[powei, 2014/01/29 13:53:17]

Done
Not quite sure what you mean here.  Why would we allow a readback without a
layer to do the readback on?

+  if (!layer_ || !layer_->parent())
+    return false;
+
   if (texture_size_in_layer_.IsEmpty())
     return false;
 
   if (UsingDelegatedRenderer()) {
     if (!delegated_renderer_layer_.get())
       return false;
   } else {
     if (texture_id_in_layer_ == 0)
       return false;
   }
@@ skipping 44 matching lines @@
     return false;  // ContentViewCore not created yet.
 
   return content_view_core_->HasFocus();
 }
 
 bool RenderWidgetHostViewAndroid::IsSurfaceAvailableForCopy() const {
   return HasValidFrame();
 }
 
 void RenderWidgetHostViewAndroid::Show() {
-  if (are_layers_attached_)
+  if (is_showing_)
     return;
 
-  are_layers_attached_ = true;
+  is_showing_ = true;
   AttachLayers();

[no sievers, 2014/01/28 20:47:21]

Can this just call layer_->SetHideLayerAndSubtree(false) instead?

[powei, 2014/01/29 13:53:17]

Done.

 
   frame_evictor_->SetVisible(true);
   WasShown();
 }
 
 void RenderWidgetHostViewAndroid::Hide() {
-  if (!are_layers_attached_)
+  if (!is_showing_)
     return;
 
-  are_layers_attached_ = false;
-  RemoveLayers();
+  is_showing_ = false;
+  AttachLayers();

[no sievers, 2014/01/28 20:47:21]

Can this just call layer_->SetHideLayerAndSubtree(true) instead?

[powei, 2014/01/29 13:53:17]

Done.

 
   frame_evictor_->SetVisible(false);
   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 are_layers_attached_ && content_view_core_;
+  return is_showing_ && content_view_core_;
 }
 
 void RenderWidgetHostViewAndroid::LockResources() {
   DCHECK(HasValidFrame());
   DCHECK(host_);
   DCHECK(!host_->is_hidden());
   frame_evictor_->LockFrame();
 }
 
 void RenderWidgetHostViewAndroid::UnlockResources() {
@@ skipping 257 matching lines @@
           start_time,
           callback));
   } else {
       request = cc::CopyOutputRequest::CreateRequest(base::Bind(
           &RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult,
           dst_size_in_pixel,
           bitmap_config,
           start_time,
           callback));
   }
+
   request->set_area(src_subrect_in_pixel);
   layer_->RequestCopyOfOutput(request.Pass());
 }
 
 void RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceToVideoFrame(
       const gfx::Rect& src_subrect,
       const scoped_refptr<media::VideoFrame>& target,
       const base::Callback<void(bool)>& callback) {
   NOTIMPLEMENTED();
   callback.Run(false);
@@ skipping 29 matching lines @@
                                                    output_surface_id,
                                                    host_->GetProcess()->GetID(),
                                                    ack);
 }
 
 void RenderWidgetHostViewAndroid::UnusedResourcesAreAvailable() {
   // TODO(danakj): If no ack is pending, collect and send resources now.
 }
 
 void RenderWidgetHostViewAndroid::DestroyDelegatedContent() {
-  if (are_layers_attached_)
-    RemoveLayers();
+  RemoveLayers();
   frame_provider_ = NULL;
   delegated_renderer_layer_ = NULL;
   layer_ = NULL;
 }
 
 void RenderWidgetHostViewAndroid::SwapDelegatedFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::DelegatedFrameData> frame_data) {
   bool has_content = !texture_size_in_layer_.IsEmpty();
 
@@ skipping 15 matching lines @@
 
   if (!has_content) {
     DestroyDelegatedContent();
   } else {
     if (!resource_collection_.get()) {
       resource_collection_ = new cc::DelegatedFrameResourceCollection;
       resource_collection_->SetClient(this);
     }
     if (!frame_provider_ ||
         texture_size_in_layer_ != frame_provider_->frame_size()) {
-      if (are_layers_attached_)
-        RemoveLayers();
+      RemoveLayers();
       frame_provider_ = new cc::DelegatedFrameProvider(
           resource_collection_.get(), frame_data.Pass());
       delegated_renderer_layer_ =
           cc::DelegatedRendererLayer::Create(frame_provider_);
       layer_ = delegated_renderer_layer_;
-      if (are_layers_attached_)
-        AttachLayers();
+      AttachLayers();
     } else {
       frame_provider_->SetFrameData(frame_data.Pass());
     }
   }
 
   if (delegated_renderer_layer_.get()) {
     delegated_renderer_layer_->SetDisplaySize(texture_size_in_layer_);
     delegated_renderer_layer_->SetIsDrawable(true);
     delegated_renderer_layer_->SetContentsOpaque(true);
     delegated_renderer_layer_->SetBounds(content_size_in_layer_);
@@ skipping 38 matching lines @@
 
     DCHECK(frame->delegated_frame_data);
     DCHECK(!frame->delegated_frame_data->render_pass_list.empty());
 
     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;
   }
 
   DCHECK(!UsingDelegatedRenderer());
 
   if (!frame->gl_frame_data || frame->gl_frame_data->mailbox.IsZero())
     return;
 
   if (output_surface_id != last_output_surface_id_) {
     current_mailbox_ = gpu::Mailbox();
@@ skipping 132 matching lines @@
 
 void RenderWidgetHostViewAndroid::AttachLayers() {
   if (!content_view_core_)
     return;
   if (!layer_.get())
     return;
 
   content_view_core_->AttachLayer(layer_);
   if (overscroll_effect_enabled_)
     overscroll_effect_->Enable();
+  layer_->SetHideLayerAndSubtree(!is_showing_);
 }
 
 void RenderWidgetHostViewAndroid::RemoveLayers() {
   if (!content_view_core_)
     return;
   if (!layer_.get())
     return;
 
   content_view_core_->RemoveLayer(layer_);
   overscroll_effect_->Disable();
@@ skipping 311 matching lines @@
                   (offset.y() + clipped_content.height()) * uv_scale.y()));
 }
 
 SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
   return cached_background_color_;
 }
 
 void RenderWidgetHostViewAndroid::OnOverscrolled(
     gfx::Vector2dF accumulated_overscroll,
     gfx::Vector2dF current_fling_velocity) {
-  if (!content_view_core_ || !are_layers_attached_)
+  if (!content_view_core_ || !layer_ || !is_showing_)
     return;
 
   if (overscroll_effect_->OnOverscrolled(content_view_core_->GetLayer(),
                                          base::TimeTicks::Now(),
                                          accumulated_overscroll,
                                          current_fling_velocity)) {
     content_view_core_->SetNeedsAnimate();
   }
 }
 
 void RenderWidgetHostViewAndroid::DidStopFlinging() {
   if (content_view_core_)
     content_view_core_->DidStopFlinging();
 }
 
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
   RunAckCallbacks();
 
-  if (are_layers_attached_)
-    RemoveLayers();
-
+  RemoveLayers();
   if (content_view_core_ && !using_synchronous_compositor_)
     content_view_core_->GetWindowAndroid()->RemoveObserver(this);
 
   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);
   }
 
-  if (are_layers_attached_) {
-    AttachLayers();
-    if (content_view_core_ && !using_synchronous_compositor_)
-      content_view_core_->GetWindowAndroid()->AddObserver(this);
-  }
+  AttachLayers();
+  if (content_view_core_ && !using_synchronous_compositor_)
+    content_view_core_->GetWindowAndroid()->AddObserver(this);
 
   // Ensure ContentsViewCore is aware of the current touch handling state, eg.
   // in case we've already been running JS for the page as part of preload.
   if (content_view_core_ && host_)
     content_view_core_->HasTouchEventHandlers(host_->has_touch_handler());
 }
 
 void RenderWidgetHostViewAndroid::RunAckCallbacks() {
   while (!ack_callbacks_.empty()) {
     ack_callbacks_.front().Run();
@@ skipping 26 matching lines @@
   RunAckCallbacks();
 }
 
 // static
 void RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
     const SkBitmap::Config bitmap_config,
     const base::TimeTicks& start_time,
     const base::Callback<void(bool, const SkBitmap&)>& callback,
     scoped_ptr<cc::CopyOutputResult> result) {
-  DCHECK(result->HasTexture());

[no sievers, 2014/01/28 20:47:21]

just wondering: when is this failing?

[powei, 2014/01/29 13:53:17]

Don't have a consistent repo, but I do hit this sometimes.  I can put a TODO for
investigation if you'd prefer that.

   base::ScopedClosureRunner scoped_callback_runner(
       base::Bind(callback, false, SkBitmap()));
 
   if (!result->HasTexture() || result->IsEmpty() || result->size().IsEmpty())
     return;
 
   scoped_ptr<SkBitmap> bitmap(new SkBitmap);
   bitmap->setConfig(bitmap_config,
                     dst_size_in_pixel.width(),
                     dst_size_in_pixel.height(),
@@ skipping 83 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content