Revert of Delete FORMAT_RGB and legacy libjpeg support from gfx::JpegCodec

ui/gfx/codec/jpeg_codec_unittest.cc

Index: ui/gfx/codec/jpeg_codec_unittest.cc
diff --git a/ui/gfx/codec/jpeg_codec_unittest.cc b/ui/gfx/codec/jpeg_codec_unittest.cc
index 9c4c8f1dd83e3a390f93d8222f36024748d836e7..8849102e17b0330f9155c77806d7747fd579f7d4 100644
--- a/ui/gfx/codec/jpeg_codec_unittest.cc
+++ b/ui/gfx/codec/jpeg_codec_unittest.cc
@@ -88,17 +88,44 @@
   return acc / static_cast<double>(a.size());
 }
 
-static void MakeRGBAImage(int w, int h, std::vector<unsigned char>* dat) {
-  dat->resize(w * h * 4);
+static void MakeRGBImage(int w, int h, std::vector<unsigned char>* dat) {
+  dat->resize(w * h * 3);
   for (int y = 0; y < h; y++) {
     for (int x = 0; x < w; x++) {
-      unsigned char* org_px = &(*dat)[(y * w + x) * 4];
+      unsigned char* org_px = &(*dat)[(y * w + x) * 3];
       org_px[0] = x * 3;      // r
       org_px[1] = x * 3 + 1;  // g
       org_px[2] = x * 3 + 2;  // b
-      org_px[3] = 0xFF;       // a
     }
   }
+}
+
+TEST(JPEGCodec, EncodeDecodeRGB) {
+  int w = 20, h = 20;
+
+  // create an image with known values
+  std::vector<unsigned char> original;
+  MakeRGBImage(w, h, &original);
+
+  // encode, making sure it was compressed some
+  std::vector<unsigned char> encoded;
+  EXPECT_TRUE(JPEGCodec::Encode(&original[0], JPEGCodec::FORMAT_RGB, w, h,
+                                w * 3, jpeg_quality, &encoded));
+  EXPECT_GT(original.size(), encoded.size());
+
+  // decode, it should have the same size as the original
+  std::vector<unsigned char> decoded;
+  int outw, outh;
+  EXPECT_TRUE(JPEGCodec::Decode(&encoded[0], encoded.size(),
+                                JPEGCodec::FORMAT_RGB, &decoded,
+                                &outw, &outh));
+  ASSERT_EQ(w, outw);
+  ASSERT_EQ(h, outh);
+  ASSERT_EQ(original.size(), decoded.size());
+
+  // Images must be approximately equal (compression will have introduced some
+  // minor artifacts).
+  ASSERT_GE(jpeg_equality_threshold, AveragePixelDelta(original, decoded));
 }
 
 TEST(JPEGCodec, EncodeDecodeRGBA) {
@@ -107,7 +134,16 @@
   // create an image with known values, a must be opaque because it will be
   // lost during compression
   std::vector<unsigned char> original;
-  MakeRGBAImage(w, h, &original);
+  original.resize(w * h * 4);
+  for (int y = 0; y < h; y++) {
+    for (int x = 0; x < w; x++) {
+      unsigned char* org_px = &original[(y * w + x) * 4];
+      org_px[0] = x * 3;      // r
+      org_px[1] = x * 3 + 1;  // g
+      org_px[2] = x * 3 + 2;  // b
+      org_px[3] = 0xFF;       // a (opaque)
+    }
+  }
 
   // encode, making sure it was compressed some
   std::vector<unsigned char> encoded;
@@ -136,31 +172,31 @@
 
   // some random data (an uncompressed image)
   std::vector<unsigned char> original;
-  MakeRGBAImage(w, h, &original);
+  MakeRGBImage(w, h, &original);
 
   // it should fail when given non-JPEG compressed data
   std::vector<unsigned char> output;
   int outw, outh;
   ASSERT_FALSE(JPEGCodec::Decode(&original[0], original.size(),
-                                 JPEGCodec::FORMAT_RGBA, &output, &outw,
-                                 &outh));
+                                 JPEGCodec::FORMAT_RGB, &output,
+                                 &outw, &outh));
 
   // make some compressed data
   std::vector<unsigned char> compressed;
-  ASSERT_TRUE(JPEGCodec::Encode(&original[0], JPEGCodec::FORMAT_RGBA, w, h,
+  ASSERT_TRUE(JPEGCodec::Encode(&original[0], JPEGCodec::FORMAT_RGB, w, h,
                                 w * 3, jpeg_quality, &compressed));
 
   // try decompressing a truncated version
   ASSERT_FALSE(JPEGCodec::Decode(&compressed[0], compressed.size() / 2,
-                                 JPEGCodec::FORMAT_RGBA, &output, &outw,
-                                 &outh));
+                                 JPEGCodec::FORMAT_RGB, &output,
+                                 &outw, &outh));
 
   // corrupt it and try decompressing that
   for (int i = 10; i < 30; i++)
     compressed[i] = i;
   ASSERT_FALSE(JPEGCodec::Decode(&compressed[0], compressed.size(),
-                                 JPEGCodec::FORMAT_RGBA, &output, &outw,
-                                 &outh));
+                                 JPEGCodec::FORMAT_RGB, &output,
+                                 &outw, &outh));
 }
 
 // Test that we can decode JPEG images without invalid-read errors on valgrind.
@@ -171,6 +207,11 @@
   int outw, outh;
   JPEGCodec::Decode(kTopSitesMigrationTestImage,
                     arraysize(kTopSitesMigrationTestImage),
+                    JPEGCodec::FORMAT_RGB, &output,
+                    &outw, &outh);
+
+  JPEGCodec::Decode(kTopSitesMigrationTestImage,
+                    arraysize(kTopSitesMigrationTestImage),
                     JPEGCodec::FORMAT_RGBA, &output,
                     &outw, &outh);
 }