Maintain minimal error response.

content/browser/compositor/delegated_frame_host.cc

 // Copyright 2014 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/compositor/delegated_frame_host.h"
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
@@ skipping 565 matching lines @@
 void DelegatedFrameHost::PrepareTextureCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
     const SkColorType color_type,
     ReadbackRequestCallback& callback,
     scoped_ptr<cc::CopyOutputResult> result) {
   DCHECK(result->HasTexture());
   base::ScopedClosureRunner scoped_callback_runner(
       base::Bind(callback, SkBitmap(), content::READBACK_FAILED));
 
   // TODO(sikugu): We should be able to validate the format here using
   // GLHelper::IsReadbackConfigSupported before we processs the result.

[no sievers, 2015/05/06 23:08:03]

What keeps us from doing this here? And falling back to RGBA if not supported?
Glancing over the bug the problem seemed to arise if we did this earlier before
the compositor is initialized, but here we should be ok, right?

I'm just wondering... this can be done in a separate patch, esp. if it might
still cause some problem we'd want to isolate.

[sivag, 2015/05/07 14:14:20]

Actually this fails in the browser tests, where some snapshot is requested
before the compositor gets initialized, may be we can check this separately.

ptal at the below issue raised for this
http://code.google.com/p/chromium/issues/detail?id=415131

   // See crbug.com/415682.
   scoped_ptr<SkBitmap> bitmap(new SkBitmap);
-  if (!bitmap->tryAllocPixels(SkImageInfo::Make(dst_size_in_pixel.width(),
-                                                dst_size_in_pixel.height(),
-                                                color_type,
-                                                kOpaque_SkAlphaType)))
+  if (!bitmap->tryAllocPixels(SkImageInfo::Make(
+          dst_size_in_pixel.width(), dst_size_in_pixel.height(), color_type,
+          kOpaque_SkAlphaType))) {
+    scoped_callback_runner.Reset(base::Bind(
+        callback, SkBitmap(), content::READBACK_BITMAP_ALLOCATION_FAILURE));
     return;
+  }
 
   ImageTransportFactory* factory = ImageTransportFactory::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 16 matching lines @@
                  callback,
                  base::Passed(&release_callback),
                  base::Passed(&bitmap),
                  base::Passed(&bitmap_pixels_lock)),
       GLHelper::SCALER_QUALITY_FAST);
 }
 
 // static
 void DelegatedFrameHost::PrepareBitmapCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
-    const SkColorType color_type,
+    const SkColorType request_color_type,
     ReadbackRequestCallback& callback,
     scoped_ptr<cc::CopyOutputResult> result) {
+  SkColorType color_type = request_color_type;
   if (color_type != kN32_SkColorType && color_type != kAlpha_8_SkColorType) {
-    NOTIMPLEMENTED();
-    callback.Run(SkBitmap(), READBACK_FORMAT_NOT_SUPPORTED);
-    return;
+    // Switch back to default colortype if format not supported.
+    color_type = kN32_SkColorType;
   }
   DCHECK(result->HasBitmap());
   scoped_ptr<SkBitmap> source = result->TakeBitmap();
   DCHECK(source);
   SkBitmap scaled_bitmap;
   if (source->width() != dst_size_in_pixel.width() ||
       source->height() != dst_size_in_pixel.height()) {
     scaled_bitmap =
         skia::ImageOperations::Resize(*source,
                                       skia::ImageOperations::RESIZE_BEST,
                                       dst_size_in_pixel.width(),
                                       dst_size_in_pixel.height());
   } else {
     scaled_bitmap = *source;
   }
   if (color_type == kN32_SkColorType) {
     DCHECK_EQ(scaled_bitmap.colorType(), kN32_SkColorType);
     callback.Run(scaled_bitmap, READBACK_SUCCESS);
     return;
   }
   DCHECK_EQ(color_type, kAlpha_8_SkColorType);
   // The software path currently always returns N32 bitmap regardless of the
   // |color_type| we ask for.
   DCHECK_EQ(scaled_bitmap.colorType(), kN32_SkColorType);
   // Paint |scaledBitmap| to alpha-only |grayscale_bitmap|.
   SkBitmap grayscale_bitmap;
   bool success = grayscale_bitmap.tryAllocPixels(
       SkImageInfo::MakeA8(scaled_bitmap.width(), scaled_bitmap.height()));
   if (!success) {
-    callback.Run(SkBitmap(), content::READBACK_MEMORY_ALLOCATION_FAILURE);
+    callback.Run(SkBitmap(), content::READBACK_BITMAP_ALLOCATION_FAILURE);
     return;
   }
   SkCanvas canvas(grayscale_bitmap);
   SkPaint paint;
   skia::RefPtr<SkColorFilter> filter =
       skia::AdoptRef(SkLumaColorFilter::Create());
   paint.setColorFilter(filter.get());
   canvas.drawBitmap(scaled_bitmap, SkIntToScalar(0), SkIntToScalar(0), &paint);
   callback.Run(grayscale_bitmap, READBACK_SUCCESS);
 }
@@ skipping 328 matching lines @@
     cc::SurfaceManager* manager = factory->GetSurfaceManager();
     new_layer->SetShowSurface(
         surface_id_, base::Bind(&SatisfyCallback, base::Unretained(manager)),
         base::Bind(&RequireCallback, base::Unretained(manager)),
         current_surface_size_, current_scale_factor_,
         current_frame_size_in_dip_);
   }
 }
 
 }  // namespace content