Revert of Remove FORMAT_RGB from gfx::PngCodec

ui/gfx/codec/png_codec_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <cmath>
 
@@ skipping 258 matching lines @@
 }
 
 void MakeTestA8SkBitmap(int w, int h, SkBitmap* bmp) {
   bmp->allocPixels(SkImageInfo::MakeA8(w, h));
 
   uint8_t* src_data = bmp->getAddr8(0, 0);
   for (int i = 0; i < w * h; i++)
     src_data[i] = i % 255;
 }
 
+TEST(PNGCodec, EncodeDecodeRGB) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeRGBImage(w, h, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGB,
+                               Size(w, h), w * 3, false,
+                               std::vector<PNGCodec::Comment>(),
+                               &encoded));
+
+  // decode, it should have the same size as the original
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGB, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(original.size(), decoded.size());
+
+  // Images must be equal
+  ASSERT_TRUE(original == decoded);
+}
+
 TEST(PNGCodec, EncodeDecodeRGBA) {
   const int w = 20, h = 20;
 
   // create an image with known values, a must be opaque because it will be
   // lost during encoding
   std::vector<unsigned char> original;
   MakeRGBAImage(w, h, true, &original);
 
   // encode
   std::vector<unsigned char> encoded;
@@ skipping 83 matching lines @@
       unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
 
       EXPECT_EQ(palette_color.red, rgba_pixel[0]);
       EXPECT_EQ(palette_color.green, rgba_pixel[1]);
       EXPECT_EQ(palette_color.blue, rgba_pixel[2]);
       EXPECT_EQ(alpha, rgba_pixel[3]);
     }
   }
 }
 
+TEST(PNGCodec, DecodePaletteDiscardAlpha) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  std::vector<png_color> original_palette;
+  std::vector<unsigned char> original_trans_chunk;
+  MakePaletteImage(w, h, &original, &original_palette, &original_trans_chunk);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_PALETTE,
+                          &encoded,
+                          PNG_INTERLACE_NONE,
+                          &original_palette,
+                          &original_trans_chunk));
+
+  // decode
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGB, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(decoded.size(), w * h * 3U);
+
+  // Images must be equal
+  for (int y = 0; y < h; ++y) {
+    for (int x = 0; x < w; ++x) {
+      unsigned char palette_pixel = original[y * w + x];
+      png_color& palette_color = original_palette[palette_pixel];
+      unsigned char* rgba_pixel = &decoded[(y * w + x) * 3];
+
+      EXPECT_EQ(palette_color.red, rgba_pixel[0]);
+      EXPECT_EQ(palette_color.green, rgba_pixel[1]);
+      EXPECT_EQ(palette_color.blue, rgba_pixel[2]);
+    }
+  }
+}
+
 TEST(PNGCodec, DecodeInterlacedPalette) {
   const int w = 20, h = 20;
 
   // create an image with known values
   std::vector<unsigned char> original;
   std::vector<png_color> original_palette;
   std::vector<unsigned char> original_trans_chunk;
   MakePaletteImage(w, h, &original, &original_palette, &original_trans_chunk);
 
   // encode
@@ skipping 40 matching lines @@
   MakeGrayscaleImage(w, h, &original);
 
   // encode
   std::vector<unsigned char> encoded;
   ASSERT_TRUE(EncodeImage(original, w, h, COLOR_TYPE_GRAY, &encoded));
 
   // decode
   std::vector<unsigned char> decoded;
   int outw, outh;
   ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
-                               PNGCodec::FORMAT_RGBA, &decoded, &outw, &outh));
+                               PNGCodec::FORMAT_RGB, &decoded,
+                               &outw, &outh));
   ASSERT_EQ(w, outw);
   ASSERT_EQ(h, outh);
-  ASSERT_EQ(decoded.size(), original.size() * 4);
+  ASSERT_EQ(decoded.size(), original.size() * 3);
 
   // Images must be equal
   for (int y = 0; y < h; ++y) {
     for (int x = 0; x < w; ++x) {
       unsigned char gray_pixel = original[(y * w + x)];
-      unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
+      unsigned char* rgba_pixel = &decoded[(y * w + x) * 3];
       EXPECT_EQ(rgba_pixel[0], gray_pixel);
       EXPECT_EQ(rgba_pixel[1], gray_pixel);
       EXPECT_EQ(rgba_pixel[2], gray_pixel);
-      EXPECT_EQ(rgba_pixel[3], 0xff);
     }
   }
 }
 
 TEST(PNGCodec, DecodeGrayscaleWithAlpha) {
   const int w = 20, h = 20;
 
   // create an image with known values
   std::vector<unsigned char> original;
   MakeGrayscaleAlphaImage(w, h, &original);
@@ skipping 21 matching lines @@
       unsigned char* gray_pixel = &original[(y * w + x) * 2];
       unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
       EXPECT_EQ(rgba_pixel[0], gray_pixel[0]);
       EXPECT_EQ(rgba_pixel[1], gray_pixel[0]);
       EXPECT_EQ(rgba_pixel[2], gray_pixel[0]);
       EXPECT_EQ(rgba_pixel[3], gray_pixel[1]);
     }
   }
 }
 
+TEST(PNGCodec, DecodeGrayscaleWithAlphaDiscardAlpha) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeGrayscaleAlphaImage(w, h, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_GRAY_ALPHA,
+                          &encoded));
+
+  // decode
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGB, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(decoded.size(), w * h * 3U);
+
+  // Images must be equal
+  for (int y = 0; y < h; ++y) {
+    for (int x = 0; x < w; ++x) {
+      unsigned char* gray_pixel = &original[(y * w + x) * 2];
+      unsigned char* rgba_pixel = &decoded[(y * w + x) * 3];
+      EXPECT_EQ(rgba_pixel[0], gray_pixel[0]);
+      EXPECT_EQ(rgba_pixel[1], gray_pixel[0]);
+      EXPECT_EQ(rgba_pixel[2], gray_pixel[0]);
+    }
+  }
+}
+
 TEST(PNGCodec, DecodeInterlacedGrayscale) {
   const int w = 20, h = 20;
 
   // create an image with known values
   std::vector<unsigned char> original;
   MakeGrayscaleImage(w, h, &original);
 
   // encode
   std::vector<unsigned char> encoded;
   ASSERT_TRUE(EncodeImage(original,
@@ skipping 56 matching lines @@
       unsigned char* gray_pixel = &original[(y * w + x) * 2];
       unsigned char* rgba_pixel = &decoded[(y * w + x) * 4];
       EXPECT_EQ(rgba_pixel[0], gray_pixel[0]);
       EXPECT_EQ(rgba_pixel[1], gray_pixel[0]);
       EXPECT_EQ(rgba_pixel[2], gray_pixel[0]);
       EXPECT_EQ(rgba_pixel[3], gray_pixel[1]);
     }
   }
 }
 
+TEST(PNGCodec, DecodeInterlacedRGB) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeRGBImage(w, h, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_RGB,
+                          &encoded,
+                          PNG_INTERLACE_ADAM7));
+
+  // decode, it should have the same size as the original
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGB, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(original.size(), decoded.size());
+
+  // Images must be equal
+  ASSERT_EQ(original, decoded);
+}
+
 TEST(PNGCodec, DecodeInterlacedRGBA) {
   const int w = 20, h = 20;
 
   // create an image with known values
   std::vector<unsigned char> original;
   MakeRGBAImage(w, h, false, &original);
 
   // encode
   std::vector<unsigned char> encoded;
   ASSERT_TRUE(EncodeImage(original,
                           w, h,
                           COLOR_TYPE_RGBA,
                           &encoded,
                           PNG_INTERLACE_ADAM7));
 
   // decode, it should have the same size as the original
   std::vector<unsigned char> decoded;
   int outw, outh;
   ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
                                PNGCodec::FORMAT_RGBA, &decoded,
                                &outw, &outh));
   ASSERT_EQ(w, outw);
   ASSERT_EQ(h, outh);
   ASSERT_EQ(original.size(), decoded.size());
 
   // Images must be equal
   ASSERT_EQ(original, decoded);
 }
 
+TEST(PNGCodec, DecodeInterlacedRGBADiscardAlpha) {
+  const int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeRGBAImage(w, h, false, &original);
+
+  // encode
+  std::vector<unsigned char> encoded;
+  ASSERT_TRUE(EncodeImage(original,
+                          w, h,
+                          COLOR_TYPE_RGBA,
+                          &encoded,
+                          PNG_INTERLACE_ADAM7));
+
+  // decode
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  ASSERT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGB, &decoded,
+                               &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(decoded.size(), w * h * 3U);
+
+  // Images must be equal
+  for (int x = 0; x < w; x++) {
+    for (int y = 0; y < h; y++) {
+      unsigned char* orig_px = &original[(y * w + x) * 4];
+      unsigned char* dec_px = &decoded[(y * w + x) * 3];
+      EXPECT_EQ(dec_px[0], orig_px[0]);
+      EXPECT_EQ(dec_px[1], orig_px[1]);
+      EXPECT_EQ(dec_px[2], orig_px[2]);
+    }
+  }
+}
+
 TEST(PNGCodec, DecodeInterlacedBGR) {
   const int w = 20, h = 20;
 
   // create an image with known values
   std::vector<unsigned char> original;
   MakeRGBImage(w, h, &original);
 
   // encode
   std::vector<unsigned char> encoded;
   ASSERT_TRUE(EncodeImage(original,
@@ skipping 120 matching lines @@
     }
   }
 }
 
 // Test that corrupted data decompression causes failures.
 TEST(PNGCodec, DecodeCorrupted) {
   int w = 20, h = 20;
 
   // Make some random data (an uncompressed image).
   std::vector<unsigned char> original;
-  MakeRGBAImage(w, h, false, &original);
+  MakeRGBImage(w, h, &original);
 
-  // It should fail when given non-PNG compressed data.
+  // It should fail when given non-JPEG compressed data.
   std::vector<unsigned char> output;
   int outw, outh;
   EXPECT_FALSE(PNGCodec::Decode(&original[0], original.size(),
-                                PNGCodec::FORMAT_RGBA, &output, &outw, &outh));
+                                PNGCodec::FORMAT_RGB, &output,
+                                &outw, &outh));
 
   // Make some compressed data.
   std::vector<unsigned char> compressed;
-  ASSERT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGBA, Size(w, h),
-                               w * 4, false, std::vector<PNGCodec::Comment>(),
+  ASSERT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGB,
+                               Size(w, h), w * 3, false,
+                               std::vector<PNGCodec::Comment>(),
                                &compressed));
 
   // Try decompressing a truncated version.
   EXPECT_FALSE(PNGCodec::Decode(&compressed[0], compressed.size() / 2,
-                                PNGCodec::FORMAT_RGBA, &output, &outw, &outh));
+                                PNGCodec::FORMAT_RGB, &output,
+                                &outw, &outh));
 
   // Corrupt it and try decompressing that.
   for (int i = 10; i < 30; i++)
     compressed[i] = i;
   EXPECT_FALSE(PNGCodec::Decode(&compressed[0], compressed.size(),
-                                PNGCodec::FORMAT_RGBA, &output, &outw, &outh));
+                                PNGCodec::FORMAT_RGB, &output,
+                                &outw, &outh));
+}
+
+TEST(PNGCodec, StripAddAlpha) {
+  const int w = 20, h = 20;
+
+  // These should be the same except one has a 0xff alpha channel.
+  std::vector<unsigned char> original_rgb;
+  MakeRGBImage(w, h, &original_rgb);
+  std::vector<unsigned char> original_rgba;
+  MakeRGBAImage(w, h, false, &original_rgba);
+
+  // Encode RGBA data as RGB.
+  std::vector<unsigned char> encoded;
+  EXPECT_TRUE(PNGCodec::Encode(&original_rgba[0], PNGCodec::FORMAT_RGBA,
+                               Size(w, h), w * 4, true,
+                               std::vector<PNGCodec::Comment>(),
+                               &encoded));
+
+  // Decode the RGB to RGBA.
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  EXPECT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGBA, &decoded,
+                               &outw, &outh));
+
+  // Decoded and reference should be the same (opaque alpha).
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(original_rgba.size(), decoded.size());
+  ASSERT_EQ(original_rgba, decoded);
+
+  // Encode RGBA to RGBA.
+  EXPECT_TRUE(PNGCodec::Encode(&original_rgba[0], PNGCodec::FORMAT_RGBA,
+                               Size(w, h), w * 4, false,
+                               std::vector<PNGCodec::Comment>(),
+                               &encoded));
+
+  // Decode the RGBA to RGB.
+  EXPECT_TRUE(PNGCodec::Decode(&encoded[0], encoded.size(),
+                               PNGCodec::FORMAT_RGB, &decoded,
+                               &outw, &outh));
+
+  // It should be the same as our non-alpha-channel reference.
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(original_rgb.size(), decoded.size());
+  ASSERT_EQ(original_rgb, decoded);
 }
 
 TEST(PNGCodec, EncodeBGRASkBitmapStridePadded) {
   const int kWidth = 20;
   const int kHeight = 20;
   const int kPaddedWidth = 32;
   const int kBytesPerPixel = 4;
   const int kPaddedSize = kPaddedWidth * kHeight;
   const int kRowBytes = kPaddedWidth * kBytesPerPixel;
 
@@ skipping 119 matching lines @@
           << SkColorGetG(unpremultiplied_decoded) << ", "
           << SkColorGetB(unpremultiplied_decoded) << ")";
     }
   }
 }
 
 TEST(PNGCodec, EncodeWithComment) {
   const int w = 10, h = 10;
 
   std::vector<unsigned char> original;
-  MakeRGBAImage(w, h, true, &original);
+  MakeRGBImage(w, h, &original);
 
   std::vector<unsigned char> encoded;
   std::vector<PNGCodec::Comment> comments;
   comments.push_back(PNGCodec::Comment("key", "text"));
   comments.push_back(PNGCodec::Comment("test", "something"));
   comments.push_back(PNGCodec::Comment("have some", "spaces in both"));
-  EXPECT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGBA, Size(w, h),
-                               w * 4, false, comments, &encoded));
+  EXPECT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGB,
+                               Size(w, h), w * 3, false, comments, &encoded));
 
   // Each chunk is of the form length (4 bytes), chunk type (tEXt), data,
   // checksum (4 bytes).  Make sure we find all of them in the encoded
   // results.
   const unsigned char kExpected1[] =
       "\x00\x00\x00\x08tEXtkey\x00text\x9e\xe7\x66\x51";
   const unsigned char kExpected2[] =
       "\x00\x00\x00\x0etEXttest\x00something\x29\xba\xef\xac";
   const unsigned char kExpected3[] =
       "\x00\x00\x00\x18tEXthave some\x00spaces in both\x8d\x69\x34\x2d";
@@ skipping 36 matching lines @@
       PNGCodec::Decode(&encoded_normal[0], encoded_normal.size(), &decoded));
   EXPECT_TRUE(BitmapsAreEqual(decoded, original_bitmap));
 
   EXPECT_TRUE(
       PNGCodec::Decode(&encoded_fast[0], encoded_fast.size(), &decoded));
   EXPECT_TRUE(BitmapsAreEqual(decoded, original_bitmap));
 }
 
 
 }  // namespace gfx