GLHelper: Address inconsistent mapping of SkColorType to GL format

content/common/gpu/client/gl_helper_unittest.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 <stdio.h>
 #include <cmath>
 #include <string>
 #include <vector>
 
 #include <GLES2/gl2.h>
@@ skipping 645 matching lines @@
                                      flip,
                                      kQualities[quality]);
 
     SkBitmap output_pixels;
     output_pixels.allocN32Pixels(scaled_xsize, scaled_ysize);
 
     helper_->ReadbackTextureSync(
         dst_texture,
         gfx::Rect(0, 0, scaled_xsize, scaled_ysize),
         static_cast<unsigned char*>(output_pixels.getPixels()),
-        kN32_SkColorType);
+        kRGBA_8888_SkColorType);
     if (flip) {
       // Flip the pixels back.
       FlipSKBitmap(&output_pixels);
     }
     if (xsize == scaled_xsize && ysize == scaled_ysize) {
       Compare(&input_pixels,
               &output_pixels,
               2,
               NULL,
               stages,
@@ skipping 175 matching lines @@
     ASSERT_GT(grid_pitch, 0);
     ASSERT_GT(grid_width, 0);
     ASSERT_NE(background_color, grid_color);
 
     for (int y = 0; y < h; ++y) {
       bool y_on_grid = ((y % grid_pitch) < grid_width);
 
       for (int x = 0; x < w; ++x) {
         bool on_grid = (y_on_grid || ((x % grid_pitch) < grid_width));
 
-        if (bmp.colorType() == kN32_SkColorType) {
+        if (bmp.colorType() == kRGBA_8888_SkColorType ||
+            bmp.colorType() == kBGRA_8888_SkColorType) {
           *bmp.getAddr32(x, y) = (on_grid ? grid_color : background_color);
         } else if (bmp.colorType() == kRGB_565_SkColorType) {
           *bmp.getAddr16(x, y) = (on_grid ? grid_color : background_color);
         }
       }
     }
   }
 
   void DrawCheckerToBitmap(int w, int h,
                            SkColor color1, SkColor color2,
                            int rect_w, int rect_h,
                            SkBitmap& bmp) {
     ASSERT_GT(rect_w, 0);
     ASSERT_GT(rect_h, 0);
     ASSERT_NE(color1, color2);
 
     for (int y = 0; y < h; ++y) {
       bool y_bit = (((y / rect_h) & 0x1) == 0);
 
       for (int x = 0; x < w; ++x) {
         bool x_bit = (((x / rect_w) & 0x1) == 0);
 
         bool use_color2 = (x_bit != y_bit);  // xor
-        if (bmp.colorType() == kN32_SkColorType) {
+        if (bmp.colorType() == kRGBA_8888_SkColorType ||
+            bmp.colorType() == kBGRA_8888_SkColorType) {
           *bmp.getAddr32(x, y) = (use_color2 ? color2 : color1);
         } else if (bmp.colorType() == kRGB_565_SkColorType) {
           *bmp.getAddr16(x, y) = (use_color2 ? color2 : color1);
         }
       }
     }
   }
 
   bool ColorComponentsClose(SkColor component1,
                             SkColor component2,
                             SkColorType color_type) {
     int c1 = static_cast<int>(component1);
     int c2 = static_cast<int>(component2);
     bool result = false;
     switch (color_type) {
-      case kN32_SkColorType:
+      case kRGBA_8888_SkColorType:
+      case kBGRA_8888_SkColorType:
         result = (std::abs(c1 - c2) == 0);
         break;
       case kRGB_565_SkColorType:
         result = (std::abs(c1 - c2) <= 7);
         break;
       default:
         break;
     }
     return result;
   }
@@ skipping 41 matching lines @@
       }
     }
     return true;
   }
 
   void BindAndAttachTextureWithPixels(GLuint src_texture,
                                       SkColorType color_type,
                                       const gfx::Size& src_size,
                                       const SkBitmap& input_pixels) {
     context_->bindTexture(GL_TEXTURE_2D, src_texture);
-    GLenum format = (color_type == kRGB_565_SkColorType) ?
-                    GL_RGB : GL_RGBA;
+    GLenum format = 0;
+    switch (color_type) {
+      case kBGRA_8888_SkColorType:
+        format = GL_BGRA_EXT;
+        break;
+      case kRGBA_8888_SkColorType:
+        format = GL_RGBA;
+        break;
+      case kRGB_565_SkColorType:
+        format = GL_RGB;
+        break;
+      default:
+        NOTREACHED();
+    }
     GLenum type = (color_type == kRGB_565_SkColorType) ?
                   GL_UNSIGNED_SHORT_5_6_5 : GL_UNSIGNED_BYTE;
     context_->texImage2D(GL_TEXTURE_2D,
                          0,
                          format,
                          src_size.width(),
                          src_size.height(),
                          0,
                          format,
                          type,
@@ skipping 470 matching lines @@
   scoped_ptr<content::GLHelper> helper_;
   scoped_ptr<content::GLHelperScaling> helper_scaling_;
   std::deque<GLHelperScaling::ScaleOp> x_ops_, y_ops_;
 };
 
 class GLHelperPixelTest : public GLHelperTest {
  private:
   gfx::DisableNullDrawGLBindings enable_pixel_output_;
 };
 
-TEST_F(GLHelperTest, ARGBSyncReadbackTest) {
+TEST_F(GLHelperTest, RGBASyncReadbackTest) {
   const int kTestSize = 64;
   bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
-                                          kN32_SkColorType,
+                                          kRGBA_8888_SkColorType,
                                           false);
   EXPECT_EQ(result, true);
 }
+
+
+TEST_F(GLHelperTest, BGRASyncReadbackTest) {
+  const int kTestSize = 64;
+  bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
+                                          kBGRA_8888_SkColorType,
+                                          false);
+  EXPECT_EQ(result, true);
+}
 
 TEST_F(GLHelperTest, RGB565SyncReadbackTest) {
   const int kTestSize = 64;
   bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
                                           kRGB_565_SkColorType,
                                           false);
   EXPECT_EQ(result, true);
 }
 
-TEST_F(GLHelperTest, ARGBASyncReadbackTest) {
+TEST_F(GLHelperTest, RGBAASyncReadbackTest) {
   const int kTestSize = 64;
   bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
-                                          kN32_SkColorType,
+                                          kRGBA_8888_SkColorType,
                                           true);
   EXPECT_EQ(result, true);
 }
+
+TEST_F(GLHelperTest, BGRAASyncReadbackTest) {
+  const int kTestSize = 64;
+  bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
+                                          kBGRA_8888_SkColorType,
+                                          true);
+  EXPECT_EQ(result, true);
+}
 
 TEST_F(GLHelperTest, RGB565ASyncReadbackTest) {
   const int kTestSize = 64;
   bool result = TestTextureFormatReadback(gfx::Size(kTestSize,kTestSize),
                                           kRGB_565_SkColorType,
                                           true);
   EXPECT_EQ(result, true);
 }
 
 TEST_F(GLHelperPixelTest, YUVReadbackOptTest) {
@@ skipping 179 matching lines @@
   CommandLine::Init(argc, argv);
   base::TestSuite* suite = new content::ContentTestSuite(argc, argv);
 #if defined(OS_MACOSX)
   base::mac::ScopedNSAutoreleasePool pool;
 #endif
 
   content::UnitTestTestSuite runner(suite);
   base::MessageLoop message_loop;
   return runner.Run();
 }