Implement GLHelperReadbackSupport for GLHelper usage.

content/common/gpu/client/gl_helper.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_CLIENT_GL_HELPER_H_
 #define CONTENT_COMMON_GPU_CLIENT_GL_HELPER_H_
 
 #include "base/atomicops.h"
 #include "base/basictypes.h"
 #include "base/callback.h"
@@ skipping 151 matching lines @@
     // Image quality is nearly as good as the BEST option.
     SCALER_QUALITY_GOOD = 2,
 
     // Bicubic upscale + N * 50% bicubic downscales.
     // Produces very good quality scaled images, but it's
     // 2-8x slower than the "GOOD" quality, so it's not always
     // worth it.
     SCALER_QUALITY_BEST = 3,
   };
 
+  enum FormatSupport {
+    FORMAT_NOT_SUPPORTED = 0,
+    FORMAT_SUPPORTED,
+    FORMAT_SUPPORT_UNKNOWN,
+  };
+
   // Copies the block of pixels specified with |src_subrect| from |src_texture|,
   // scales it to |dst_size|, and writes it into |out|.
   // |src_size| is the size of |src_texture|. The result is of format GL_BGRA
   // and is potentially flipped vertically to make it a correct image
   // representation.  |callback| is invoked with the copy result when the copy
   // operation has completed.
   // Note that the src_texture will have the min/mag filter set to GL_LINEAR
   // and wrap_s/t set to CLAMP_TO_EDGE in this call.
   void CropScaleReadbackAndCleanTexture(
       GLuint src_texture,
@@ skipping 88 matching lines @@
   // Resizes the texture's size to |size|.
   void ResizeTexture(GLuint texture, const gfx::Size& size);
 
   // Copies the framebuffer data given in |rect| to |texture|.
   void CopyTextureSubImage(GLuint texture, const gfx::Rect& rect);
 
   // Copies the all framebuffer data to |texture|. |size| specifies the
   // size of the framebuffer.
   void CopyTextureFullImage(GLuint texture, const gfx::Size& size);
 
-  // Check whether rgb565 readback is supported or not.
-  bool CanUseRgb565Readback();
+  // Checks whether the readback (Color read format and type) is supported
+  // for the requested texture format  by the hardware or not.
+  // For ex: some hardwares have rgb565 readback
+  // support when binded with the frame buffer for others it may fail.
+
+  bool IsReadbackConfigSupported(SkBitmap::Config bitmap_format);
 
   // A scaler will cache all intermediate textures and programs
   // needed to scale from a specified size to a destination size.
   // If the source or destination sizes changes, you must create
   // a new scaler.
   class CONTENT_EXPORT ScalerInterface {
    public:
     ScalerInterface() {}
     virtual ~ScalerInterface() {}
 
@@ skipping 29 matching lines @@
                                                   const gfx::Rect& src_subrect,
                                                   const gfx::Size& dst_size,
                                                   const gfx::Rect& dst_subrect,
                                                   bool flip_vertically,
                                                   bool use_mrt);
 
   // Returns the maximum number of draw buffers available,
   // 0 if GL_EXT_draw_buffers is not available.
   GLint MaxDrawBuffers();
 
+ private:
+  // IsReadbackConfigSupported does texture bind and attach operations,
+  // better do it in the constructor, and never do it again.
+  // This populates the readback support list at a time once.
+  void InitializeReadbackSupport();
+
+  // Helper functions for checking the supported texture formats.
+  // Avoid using this API in between texture operations, as this does some
+  // teture opertions (bind, attach) internally.
+  bool SupportsFormat(GLint format, GLint type);
+
  protected:
   class CopyTextureToImpl;
 
   // Creates |copy_texture_to_impl_| if NULL.
   void InitCopyTextToImpl();
   // Creates |scaler_impl_| if NULL.
   void InitScalerImpl();
 
   gpu::gles2::GLES2Interface* gl_;
   gpu::ContextSupport* context_support_;
   scoped_ptr<CopyTextureToImpl> copy_texture_to_impl_;
   scoped_ptr<GLHelperScaling> scaler_impl_;
-  bool initialized_565_format_check_;
-  bool support_565_format_;
+  FormatSupport format_support_table_[SkBitmap::kConfigCount];
 
   DISALLOW_COPY_AND_ASSIGN(GLHelper);
 };
 
 // Similar to a ScalerInterface, a yuv readback pipeline will
 // cache a scaler and all intermediate textures and frame buffers
 // needed to scale, crop, letterbox and read back a texture from
 // the GPU into CPU-accessible RAM. A single readback pipeline
 // can handle multiple outstanding readbacks at the same time, but
 // if the source or destination sizes change, you'll need to create
 // a new readback pipeline.
 class CONTENT_EXPORT ReadbackYUVInterface {
  public:
   ReadbackYUVInterface() {}
   virtual ~ReadbackYUVInterface() {}
 
   // Note that |target| must use YV12 format.
   virtual void ReadbackYUV(const gpu::Mailbox& mailbox,
                            uint32 sync_point,
                            const scoped_refptr<media::VideoFrame>& target,
                            const base::Callback<void(bool)>& callback) = 0;
   virtual GLHelper::ScalerInterface* scaler() = 0;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_CLIENT_GL_HELPER_H_