Handle Left out paths on Android/Aura for Async ReadBack.

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 244 matching lines @@
   WasResized();
 }
 
 void RenderWidgetHostViewAndroid::SetBounds(const gfx::Rect& rect) {
   SetSize(rect.size());
 }
 
 void RenderWidgetHostViewAndroid::GetScaledContentBitmap(
     float scale,
     gfx::Size* out_size,
+    bool config_565,
     const base::Callback<void(bool, const SkBitmap&)>& result_callback) {
   if (!IsSurfaceAvailableForCopy()) {
     result_callback.Run(false, SkBitmap());
     return;
   }
 
   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;
+  SkBitmap::Config config = config_565 ?
+                            SkBitmap::kRGB_565_Config :
+                            SkBitmap::kARGB_8888_Config;
   CopyFromCompositingSurface(
-      src_subrect, dst_size, result_callback, SkBitmap::kARGB_8888_Config);
+      src_subrect, dst_size, result_callback, config);
 }
 
 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 371 matching lines @@
   float device_scale_factor = display.device_scale_factor();
 
   DCHECK_EQ(device_scale_factor,
             ui::GetImageScale(GetScaleFactorForView(this)));
 
   const gfx::Size& dst_size_in_pixel = ConvertViewSizeToPixel(this, dst_size);
   gfx::Rect src_subrect_in_pixel =
       ConvertRectToPixel(device_scale_factor, src_subrect);
 
   if (using_synchronous_compositor_) {
-    SynchronousCopyContents(src_subrect_in_pixel, dst_size_in_pixel, callback);
+    SynchronousCopyContents(src_subrect_in_pixel, dst_size_in_pixel, callback,
+                            bitmap_config);
     UMA_HISTOGRAM_TIMES("Compositing.CopyFromSurfaceTimeSynchronous",
                         base::TimeTicks::Now() - start_time);
     return;
   }
   scoped_ptr<cc::CopyOutputRequest> request;
-  if (src_subrect_in_pixel.size() == dst_size_in_pixel) {
+  if ((src_subrect_in_pixel.size() == dst_size_in_pixel) &&
+      (bitmap_config == SkBitmap::kARGB_8888_Config)) {
       request = cc::CopyOutputRequest::CreateBitmapRequest(base::Bind(
           &RenderWidgetHostViewAndroid::PrepareBitmapCopyOutputResult,
           dst_size_in_pixel,
+          bitmap_config,
           start_time,
           callback));
   } else {
       request = cc::CopyOutputRequest::CreateRequest(base::Bind(
           &RenderWidgetHostViewAndroid::PrepareTextureCopyOutputResult,
           dst_size_in_pixel,
           bitmap_config,
           start_time,
           callback));
   }
@@ skipping 222 matching lines @@
   }
 }
 
 void RenderWidgetHostViewAndroid::SetOverlayVideoMode(bool enabled) {
   layer_->SetContentsOpaque(!enabled);
 }
 
 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) {
+    const base::Callback<void(bool, const SkBitmap&)>& callback,
+    const SkBitmap::Config config) {
   SynchronousCompositor* compositor =
       SynchronousCompositorImpl::FromID(host_->GetProcess()->GetID(),
                                         host_->GetRoutingID());
   if (!compositor) {
     callback.Run(false, SkBitmap());
     return;
   }
 
   SkBitmap bitmap;
-  bitmap.setConfig(SkBitmap::kARGB_8888_Config,
+  bitmap.setConfig(config,
                    dst_size_in_pixel.width(),
                    dst_size_in_pixel.height());
   bitmap.allocPixels();
   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);
 }
@@ skipping 501 matching lines @@
                  callback,
                  base::Passed(&release_callback),
                  base::Passed(&bitmap),
                  start_time,
                  base::Passed(&bitmap_pixels_lock)));
 }
 
 // static
 void RenderWidgetHostViewAndroid::PrepareBitmapCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
+    const SkBitmap::Config config,
     const base::TimeTicks& start_time,
     const base::Callback<void(bool, const SkBitmap&)>& callback,
     scoped_ptr<cc::CopyOutputResult> result) {
+  if (config != SkBitmap::kARGB_8888_Config) {
+    NOTIMPLEMENTED();
+    callback.Run(false, SkBitmap());
+    return;
+  }
   DCHECK(result->HasBitmap());
   base::ScopedClosureRunner scoped_callback_runner(
       base::Bind(callback, false, SkBitmap()));
 
   if (!result->HasBitmap() || result->IsEmpty() || result->size().IsEmpty())
     return;
 
   scoped_ptr<SkBitmap> source = result->TakeBitmap();
   DCHECK(source);
   if (!source)
@@ skipping 28 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content