Add Async API unittests to readback format.

content/common/gpu/client/gl_helper.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/common/gpu/client/gl_helper.h"
 
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 118 matching lines @@
       unsigned char* out,
       const SkBitmap::Config config,
       const base::Callback<void(bool)>& callback,
       GLHelper::ScalerQuality quality);
 
   void ReadbackTextureSync(GLuint texture,
                            const gfx::Rect& src_rect,
                            unsigned char* out,
                            SkBitmap::Config format);
 
+  void ReadbackTextureAsync(GLuint texture,
+                            const gfx::Size& dst_size,
+                            unsigned char* out,
+                            SkBitmap::Config config,
+                            const base::Callback<void(bool)>& callback);
+
   // Reads back bytes from the currently bound frame buffer.
   // Note that dst_size is specified in bytes, not pixels.
   void ReadbackAsync(const gfx::Size& dst_size,
                      int32 bytes_per_row,     // generally dst_size.width() * 4
                      int32 row_stride_bytes,  // generally dst_size.width() * 4
                      unsigned char* out,
                      const SkBitmap::Config config,
                      const base::Callback<void(bool)>& callback);
 
   void ReadbackPlane(TextureFrameBufferPair* source,
@@ skipping 373 matching lines @@
                 GL_UNSIGNED_BYTE;
   gl_->ReadPixels(src_rect.x(),
                   src_rect.y(),
                   src_rect.width(),
                   src_rect.height(),
                   format,
                   type,
                   out);
 }
 
+void GLHelper::CopyTextureToImpl::ReadbackTextureAsync(
+    GLuint texture,
+    const gfx::Size& dst_size,
+    unsigned char* out,
+    SkBitmap::Config config,
+    const base::Callback<void(bool)>& callback) {
+  // Only ARGB888 and RGB565 supported as of now.
+  bool format_support = ((config == SkBitmap::kRGB_565_Config) ||
+                         (config == SkBitmap::kARGB_8888_Config));
+  if (!format_support) {
+    DCHECK(format_support);
+    return;
+  }
+  ScopedFramebuffer dst_framebuffer(gl_);
+  ScopedFramebufferBinder<GL_FRAMEBUFFER> framebuffer_binder(gl_,
+                                                             dst_framebuffer);
+  ScopedTextureBinder<GL_TEXTURE_2D> texture_binder(gl_, texture);
+  gl_->FramebufferTexture2D(GL_FRAMEBUFFER,
+                            GL_COLOR_ATTACHMENT0,
+                            GL_TEXTURE_2D,
+                            texture,
+                            0);
+  int readback_config_rgb565 = (config ==  SkBitmap::kRGB_565_Config);
+  int bytes_per_pixel = readback_config_rgb565 ? 2 : 4;

[piman, 2014/01/24 20:26:31]

nit: you're not otherwise using readback_config_rgb565 anymore, so coalesce
these 2 lines:

int bytes_per_pixel = (config == SkBitmap::kRGB_565_Config) ? 2 : 4;

(also note, single space after ==)

[sivag, 2014/01/25 08:34:02]

Done.

+  ReadbackAsync(dst_size,
+                dst_size.width() * bytes_per_pixel,
+                dst_size.width() * bytes_per_pixel,
+                out,
+                config,
+                callback);
+}
+
 GLuint GLHelper::CopyTextureToImpl::CopyAndScaleTexture(
     GLuint src_texture,
     const gfx::Size& src_size,
     const gfx::Size& dst_size,
     bool vertically_flip_texture,
     GLHelper::ScalerQuality quality) {
   return ScaleTexture(src_texture,
                       src_size,
                       gfx::Rect(src_size),
                       dst_size,
@@ skipping 114 matching lines @@
 }
 
 void GLHelper::ReadbackTextureSync(GLuint texture,
                                    const gfx::Rect& src_rect,
                                    unsigned char* out,
                                    SkBitmap::Config format) {
   InitCopyTextToImpl();
   copy_texture_to_impl_->ReadbackTextureSync(texture, src_rect, out, format);
 }
 
+void GLHelper::ReadbackTextureAsync(
+    GLuint texture,
+    const gfx::Size& dst_size,
+    unsigned char* out,
+    SkBitmap::Config config,
+    const base::Callback<void(bool)>& callback) {
+  InitCopyTextToImpl();
+  copy_texture_to_impl_->ReadbackTextureAsync(texture,
+                                              dst_size,
+                                              out,
+                                              config,
+                                              callback);
+}
+
 GLuint GLHelper::CopyTexture(GLuint texture, const gfx::Size& size) {
   InitCopyTextToImpl();
   return copy_texture_to_impl_->CopyAndScaleTexture(
       texture, size, size, false, GLHelper::SCALER_QUALITY_FAST);
 }
 
 GLuint GLHelper::CopyAndScaleTexture(GLuint texture,
                                      const gfx::Size& src_size,
                                      const gfx::Size& dst_size,
                                      bool vertically_flip_texture,
@@ skipping 510 matching lines @@
   return copy_texture_to_impl_->CreateReadbackPipelineYUV(quality,
                                                           src_size,
                                                           src_subrect,
                                                           dst_size,
                                                           dst_subrect,
                                                           flip_vertically,
                                                           use_mrt);
 }
 
 }  // namespace content