[Android] Implement asynchronous zero-copy bitmap capture 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 235 matching lines @@
   default_size_ = size;
   WasResized();
 }
 
 void RenderWidgetHostViewAndroid::SetBounds(const gfx::Rect& rect) {
   SetSize(rect.size());
 }
 
 void RenderWidgetHostViewAndroid::GetScaledContentBitmap(
     float scale,
-    const base::Callback<void(bool, const SkBitmap&)>& result_callback) {
+    const base::Callback<void(bool, const SkBitmap&)>& result_callback,
+    SkBitmap::Config bitmap_config,
+    const gfx::Rect& bounding_rect,
+    const BitmapAllocator bitmap_allocator) {
   if (!IsSurfaceAvailableForCopy()) {
     result_callback.Run(false, SkBitmap());
     return;
   }
 
-  gfx::Size bounds = layer_->bounds();
+  gfx::Size bounds = bounding_rect.IsEmpty() ?
+                     layer_->bounds() :
+                     gfx::Size(bounding_rect.width(), bounding_rect.height());
   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)));
+
+  scoped_ptr<SkBitmap> bitmap;
+  if (!bitmap_allocator.is_null()) {
+    SkBitmap* bitmap_ptr = NULL;
+    bitmap_allocator.Run(bitmap_ptr, dst_size, bitmap_config);
+    DCHECK(bitmap_ptr);
+    DCHECK_EQ(bitmap_ptr->width(), bounds.width());
+    DCHECK_EQ(bitmap_ptr->height(), bounds.height());
+    DCHECK_EQ(bitmap_ptr->config(), bitmap_config);
+    DCHECK_NE(bitmap_ptr->getPixels(), static_cast<void*>(NULL));
+    bitmap.reset(bitmap_ptr);
+  }
+
   CopyFromCompositingSurface(
-      src_subrect, dst_size, result_callback, SkBitmap::kARGB_8888_Config);
+      src_subrect, dst_size, result_callback, bitmap_config, bitmap.Pass());
 }
 
 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 332 matching lines @@
 
 void RenderWidgetHostViewAndroid::SetBackground(const SkBitmap& background) {
   RenderWidgetHostViewBase::SetBackground(background);
   host_->Send(new ViewMsg_SetBackground(host_->GetRoutingID(), background));
 }
 
 void RenderWidgetHostViewAndroid::CopyFromCompositingSurface(
     const gfx::Rect& src_subrect,
     const gfx::Size& dst_size,
     const base::Callback<void(bool, const SkBitmap&)>& callback,
-    const SkBitmap::Config bitmap_config) {
+    const SkBitmap::Config bitmap_config,
+    scoped_ptr<SkBitmap> bitmap) {
   // Only ARGB888 and RGB565 supported as of now.
   bool format_support = ((bitmap_config == SkBitmap::kRGB_565_Config) ||
                          (bitmap_config == SkBitmap::kARGB_8888_Config));
   if (!format_support) {
     DCHECK(format_support);
     callback.Run(false, SkBitmap());
     return;
   }
   base::TimeTicks start_time = base::TimeTicks::Now();
   if (!using_synchronous_compositor_ && !IsSurfaceAvailableForCopy()) {
@@ skipping 26 matching lines @@
     UMA_HISTOGRAM_TIMES("Compositing.CopyFromSurfaceTimeSynchronous",
                         base::TimeTicks::Now() - start_time);
     return;
   }
   scoped_ptr<cc::CopyOutputRequest> request =
       cc::CopyOutputRequest::CreateRequest(base::Bind(
           &RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult,
           dst_size_in_pixel,
           bitmap_config,
           start_time,
+          base::Passed(&bitmap),
           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();
@@ skipping 647 matching lines @@
     DestroyDelegatedContent();
   texture_id_in_layer_ = 0;
   RunAckCallbacks();
 }
 
 // static
 void RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
     const SkBitmap::Config bitmap_config,
     const base::TimeTicks& start_time,
+    scoped_ptr<SkBitmap> bitmap,
     const base::Callback<void(bool, const SkBitmap&)>& callback,
     scoped_ptr<cc::CopyOutputResult> result) {
   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(),
-                    0, kOpaque_SkAlphaType);
-  if (!bitmap->allocPixels())
-    return;
+  if (!bitmap.get()) {
+    bitmap.reset(new SkBitmap);
+    bitmap->setConfig(bitmap_config,
+                      dst_size_in_pixel.width(),
+                      dst_size_in_pixel.height(),
+                      0, kOpaque_SkAlphaType);
+    if (!bitmap->allocPixels())
+      return;
+  }
 
   ImageTransportFactoryAndroid* factory =
       ImageTransportFactoryAndroid::GetInstance();
   GLHelper* gl_helper = factory->GetGLHelper();
   if (!gl_helper)
     return;
 
   scoped_ptr<SkAutoLockPixels> bitmap_pixels_lock(
       new SkAutoLockPixels(*bitmap));
   uint8* pixels = static_cast<uint8*>(bitmap->getPixels());
@@ skipping 76 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content