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 652 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 208 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 527 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();

[no sievers, 2014/01/27 18:41:49]

Either return here, or just turn this into:
DCHECK(config == SkBitmap::kARGB_8888_Config);

[sivag, 2014/01/28 13:17:01]

Done.

+    callback.Run(false, SkBitmap());
+  }
   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