Support error handling for Surface readbacks

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/android/build_info.h"
 #include "base/basictypes.h"
@@ skipping 81 matching lines @@
 const int kKitKatMR2SDKVersion = 19;
 
 static const char kAsyncReadBackString[] = "Compositing.CopyFromSurfaceTime";
 
 // Sends an acknowledgement to the renderer of a processed IME event.
 void SendImeEventAck(RenderWidgetHostImpl* host) {
   host->Send(new ViewMsg_ImeEventAck(host->GetRoutingID()));
 }
 
 void CopyFromCompositingSurfaceFinished(
-    const base::Callback<void(bool, const SkBitmap&)>& callback,
+    ReadbackRequestCallback& callback,
     scoped_ptr<cc::SingleReleaseCallback> release_callback,
     scoped_ptr<SkBitmap> bitmap,
     const base::TimeTicks& start_time,
     scoped_ptr<SkAutoLockPixels> bitmap_pixels_lock,
     bool result) {
   TRACE_EVENT0(
       "cc", "RenderWidgetHostViewAndroid::CopyFromCompositingSurfaceFinished");
   bitmap_pixels_lock.reset();
   uint32 sync_point = 0;
   if (result) {
     GLHelper* gl_helper =
         ImageTransportFactoryAndroid::GetInstance()->GetGLHelper();
     sync_point = gl_helper->InsertSyncPoint();
   }
   bool lost_resource = sync_point == 0;
   release_callback->Run(sync_point, lost_resource);
   UMA_HISTOGRAM_TIMES(kAsyncReadBackString,
                       base::TimeTicks::Now() - start_time);
-  callback.Run(result, *bitmap);
+  ReadbackResponse response = result ? READBACK_SUCCESS : READBACK_FAILED;
+  callback.Run(*bitmap, response);
 }
 
 ui::LatencyInfo CreateLatencyInfo(const blink::WebInputEvent& event) {
   ui::LatencyInfo latency_info;
   // The latency number should only be added if the timestamp is valid.
   if (event.timeStampSeconds) {
     const int64 time_micros = static_cast<int64>(
         event.timeStampSeconds * base::Time::kMicrosecondsPerSecond);
     latency_info.AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
@@ skipping 100 matching lines @@
 bool HasMobileViewport(const cc::CompositorFrameMetadata& frame_metadata) {
   float window_width_dip =
       frame_metadata.page_scale_factor *
           frame_metadata.scrollable_viewport_size.width();
   float content_width_css = frame_metadata.root_layer_size.width();
   return content_width_css <= window_width_dip + kMobileViewportWidthEpsilon;
 }
 
 }  // anonymous namespace
 
-ReadbackRequest::ReadbackRequest(
-    float scale,
-    SkColorType color_type,
-    gfx::Rect src_subrect,
-    const base::Callback<void(bool, const SkBitmap&)>& result_callback)
+ReadbackRequest::ReadbackRequest(float scale,
+                                 SkColorType color_type,
+                                 gfx::Rect src_subrect,
+                                 ReadbackRequestCallback& result_callback)
     : scale_(scale),
       color_type_(color_type),
       src_subrect_(src_subrect),
       result_callback_(result_callback) {
 }
 
 ReadbackRequest::ReadbackRequest() {
 }
 
 ReadbackRequest::~ReadbackRequest() {
@@ skipping 116 matching lines @@
   default_size_ = size;
 }
 
 void RenderWidgetHostViewAndroid::SetBounds(const gfx::Rect& rect) {
   SetSize(rect.size());
 }
 
 void RenderWidgetHostViewAndroid::AbortPendingReadbackRequests() {
   while (!readbacks_waiting_for_frame_.empty()) {
     ReadbackRequest& readback_request = readbacks_waiting_for_frame_.front();
-    readback_request.GetResultCallback().Run(false, SkBitmap());
+    readback_request.GetResultCallback().Run(SkBitmap(), READBACK_FAILED);
     readbacks_waiting_for_frame_.pop();
   }
 }
 
 void RenderWidgetHostViewAndroid::GetScaledContentBitmap(
     float scale,
     SkColorType color_type,
     gfx::Rect src_subrect,
-    CopyFromCompositingSurfaceCallback& result_callback) {
+    ReadbackRequestCallback& result_callback) {
   if (!host_ || host_->is_hidden()) {
-    result_callback.Run(false, SkBitmap());
+    result_callback.Run(SkBitmap(), READBACK_NOT_SUPPORTED);
     return;
   }
   if (!IsSurfaceAvailableForCopy()) {
     // The view is visible, probably the frame has not yet arrived.
     // Just add the ReadbackRequest to queue and wait for frame arrival
     // to get this request processed.
     readbacks_waiting_for_frame_.push(
         ReadbackRequest(scale, color_type, src_subrect, result_callback));
     return;
   }
@@ skipping 421 matching lines @@
 
 void RenderWidgetHostViewAndroid::SetBackgroundColor(SkColor color) {
   RenderWidgetHostViewBase::SetBackgroundColor(color);
   host_->SetBackgroundOpaque(GetBackgroundOpaque());
   OnDidChangeBodyBackgroundColor(color);
 }
 
 void RenderWidgetHostViewAndroid::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
-    CopyFromCompositingSurfaceCallback& callback,
+    ReadbackRequestCallback& callback,
     const SkColorType color_type) {
   TRACE_EVENT0("cc", "RenderWidgetHostViewAndroid::CopyFromCompositingSurface");
   if ((!host_ || host_->is_hidden()) ||
       !IsReadbackConfigSupported(color_type)) {
-    callback.Run(false, SkBitmap());
+    callback.Run(SkBitmap(), READBACK_FORMAT_NOT_SUPPORTED);
     return;
   }
   base::TimeTicks start_time = base::TimeTicks::Now();
   if (!using_synchronous_compositor_ && !IsSurfaceAvailableForCopy()) {
-    callback.Run(false, SkBitmap());
+    callback.Run(SkBitmap(), READBACK_NOT_SUPPORTED);
     return;
   }
   const gfx::Display& display =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
   float device_scale_factor = display.device_scale_factor();
   gfx::Size dst_size_in_pixel =
       ConvertRectToPixel(device_scale_factor, gfx::Rect(dst_size)).size();
   gfx::Rect src_subrect_in_pixel =
       ConvertRectToPixel(device_scale_factor, src_subrect);
 
@@ skipping 329 matching lines @@
       content_view_core_->GetLayer().get(),
       content_view_core_->GetDpiScale(),
       // Use the activity context (instead of the application context) to ensure
       // proper handle theming.
       content_view_core_->GetContext().obj()));
 }
 
 void RenderWidgetHostViewAndroid::SynchronousCopyContents(
     const gfx::Rect& src_subrect_in_pixel,
     const gfx::Size& dst_size_in_pixel,
-    const base::Callback<void(bool, const SkBitmap&)>& callback,
+    ReadbackRequestCallback& callback,
     const SkColorType color_type) {
   SynchronousCompositor* compositor =
       SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(),
                                         host_->GetRoutingID());
   if (!compositor) {
-    callback.Run(false, SkBitmap());
+    callback.Run(SkBitmap(), READBACK_FAILED);
     return;
   }
 
   SkBitmap bitmap;
   bitmap.allocPixels(SkImageInfo::Make(dst_size_in_pixel.width(),
                                        dst_size_in_pixel.height(),
                                        color_type,
                                        kPremul_SkAlphaType));
   SkCanvas canvas(bitmap);
   canvas.scale(
       (float)dst_size_in_pixel.width() / (float)src_subrect_in_pixel.width(),
       (float)dst_size_in_pixel.height() / (float)src_subrect_in_pixel.height());
   compositor->DemandDrawSw(&canvas);
-  callback.Run(true, bitmap);
+  callback.Run(bitmap, READBACK_SUCCESS);
 }
 
 void RenderWidgetHostViewAndroid::OnFrameMetadataUpdated(
     const cc::CompositorFrameMetadata& frame_metadata) {
 
   // Disable double tap zoom for pages that have a width=device-width or
   // narrower viewport (indicating that this is a mobile-optimized or responsive
   // web design, so text will be legible without zooming). Also disable
   // double tap and pinch for pages that prevent zooming in or out.
   bool has_mobile_viewport = HasMobileViewport(frame_metadata);
@@ skipping 454 matching lines @@
   DCHECK(readbacks_waiting_for_frame_.empty());
 }
 
 // static
 void
 RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResultForDelegatedReadback(
     const gfx::Size& dst_size_in_pixel,
     const SkColorType color_type,
     const base::TimeTicks& start_time,
     scoped_refptr<cc::Layer> readback_layer,
-    const base::Callback<void(bool, const SkBitmap&)>& callback,
+    ReadbackRequestCallback& callback,
     scoped_ptr<cc::CopyOutputResult> result) {
   readback_layer->RemoveFromParent();
   PrepareTextureCopyOutputResult(
       dst_size_in_pixel, color_type, start_time, callback, result.Pass());
 }
 
 // static
 void RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
     const SkColorType color_type,
     const base::TimeTicks& start_time,
-    const base::Callback<void(bool, const SkBitmap&)>& callback,
+    ReadbackRequestCallback& callback,
     scoped_ptr<cc::CopyOutputResult> result) {
   base::ScopedClosureRunner scoped_callback_runner(
-      base::Bind(callback, false, SkBitmap()));
+      base::Bind(callback, SkBitmap(), READBACK_FAILED));
   TRACE_EVENT0("cc",
                "RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult");
 
   if (!result->HasTexture() || result->IsEmpty() || result->size().IsEmpty())
     return;
 
   scoped_ptr<SkBitmap> bitmap(new SkBitmap);
   if (!bitmap->tryAllocPixels(SkImageInfo::Make(dst_size_in_pixel.width(),
                                                 dst_size_in_pixel.height(),
                                                 color_type,
@@ skipping 91 matching lines @@
   results->orientationAngle = display.RotationAsDegree();
   results->orientationType =
       RenderWidgetHostViewBase::GetOrientationTypeForMobile(display);
   gfx::DeviceDisplayInfo info;
   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 } // namespace content