Use SkPngEncoder in gfx jpeg_codec

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 261 matching lines @@
   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, EncodeDecodeRGBA) {
   const int w = 20, h = 20;
 
   // create an image with known values, a must be opaque because it will be

[scroggo_chromium, 2017/06/16 18:56:51]

This comment is strange. Why can we not have transparency?

[liyuqian, 2017/06/23 13:54:26]

I've no idea what this comment means... Anyway, I think that my code doesn't
change any behavior of the test (other than wrapping all format information into
SkPixmap)?

   // lost during encoding
   std::vector<unsigned char> original;
   MakeRGBAImage(w, h, true, &original);
 
   // encode
   std::vector<unsigned char> encoded;
-  ASSERT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGBA,
-                               Size(w, h), w * 4, false,
-                               std::vector<PNGCodec::Comment>(),
-                               &encoded));
+  SkImageInfo info =
+      SkImageInfo::Make(w, h, kRGBA_8888_SkColorType, kUnpremul_SkAlphaType);
+  SkPixmap src(info, &original[0], w * 4);
+  ASSERT_TRUE(
+      PNGCodec::Encode(src, 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_RGBA, &decoded,
                                &outw, &outh));
   ASSERT_EQ(w, outw);
   ASSERT_EQ(h, outh);
   ASSERT_EQ(original.size(), decoded.size());
 
   // Images must be exactly equal
   ASSERT_TRUE(original == decoded);
 }
 
 TEST(PNGCodec, EncodeDecodeBGRA) {
   const int w = 20, h = 20;
 
   // Create an image with known values, alpha 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;
-  ASSERT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_BGRA,
-                               Size(w, h), w * 4, false,
-                               std::vector<PNGCodec::Comment>(),
-                               &encoded));
+  SkImageInfo info =
+      SkImageInfo::Make(w, h, kBGRA_8888_SkColorType, kUnpremul_SkAlphaType);
+  SkPixmap src(info, &original[0], w * 4);
+  ASSERT_TRUE(
+      PNGCodec::Encode(src, 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_BGRA, &decoded,
                                &outw, &outh));
   ASSERT_EQ(w, outw);
   ASSERT_EQ(h, outh);
   ASSERT_EQ(original.size(), decoded.size());
@@ skipping 410 matching lines @@
   MakeRGBAImage(w, h, false, &original);
 
   // It should fail when given non-PNG compressed data.
   std::vector<unsigned char> output;
   int outw, outh;
   EXPECT_FALSE(PNGCodec::Decode(&original[0], original.size(),
                                 PNGCodec::FORMAT_RGBA, &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>(),
-                               &compressed));
+  SkImageInfo info =
+      SkImageInfo::Make(w, h, kRGBA_8888_SkColorType, kUnpremul_SkAlphaType);
+  SkPixmap src(info, &original[0], w * 4);
+  ASSERT_TRUE(
+      PNGCodec::Encode(src, 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));
 
   // 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));
@@ skipping 136 matching lines @@
   const int w = 10, h = 10;
 
   std::vector<unsigned char> original;
   MakeRGBAImage(w, h, true, &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));
+  SkImageInfo info =
+      SkImageInfo::Make(w, h, kRGBA_8888_SkColorType, kUnpremul_SkAlphaType);
+  SkPixmap src(info, &original[0], w * 4);
+  EXPECT_TRUE(PNGCodec::Encode(src, 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