Add the ability to write comments to PNGCodec::Encode.

ui/gfx/codec/png_codec_unittest.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 <math.h>
+#include <algorithm>
+#include <cmath>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkUnPreMultiply.h"
 #include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/size.h"
 
 namespace gfx {
 
 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) * 3];
       org_px[0] = x * 3;      // r
       org_px[1] = x * 3 + 1;  // g
@@ skipping 51 matching lines @@
 
 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;
-  EXPECT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGB, w, h,
-                               w * 3, false, &encoded));
+  EXPECT_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;
   EXPECT_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;
-  EXPECT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGBA, w, h,
-                               w * 4, false, &encoded));
+  EXPECT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGBA,
+                               Size(w, h), w * 4, false,
+                               std::vector<PNGCodec::Comment>(),
+                               &encoded));
 
   // decode, it should have the same size as the original
   std::vector<unsigned char> decoded;
   int outw, outh;
   EXPECT_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());
@@ skipping 12 matching lines @@
 
   // 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_RGB, &output,
                                 &outw, &outh));
 
   // Make some compressed data.
   std::vector<unsigned char> compressed;
-  EXPECT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_RGB, w, h,
-                               w * 3, false, &compressed));
+  EXPECT_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_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_RGB, &output,
                                 &outw, &outh));
 }
 
 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;
-  EXPECT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_BGRA, w, h,
-                               w * 4, false, &encoded));
+  EXPECT_TRUE(PNGCodec::Encode(&original[0], PNGCodec::FORMAT_BGRA,
+                               Size(w, h), w * 4, false,
+                               std::vector<PNGCodec::Comment>(),
+                               &encoded));
 
   // Decode, it should have the same size as the original.
   std::vector<unsigned char> decoded;
   int outw, outh;
   EXPECT_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());
 
   // Images must be exactly equal.
   ASSERT_TRUE(original == decoded);
 }
 
 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,
-                               w, h,
-                               w * 4, true, &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_TRUE(original_rgba == decoded);
 
   // Encode RGBA to RGBA.
-  EXPECT_TRUE(PNGCodec::Encode(&original_rgba[0],
-                               PNGCodec::FORMAT_RGBA,
-                               w, h,
-                               w * 4, false, &encoded));
+  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());
@@ skipping 57 matching lines @@
           << SkColorGetG(unpremultiplied) << ", "
           << SkColorGetB(unpremultiplied) << "), "
           << "Decoded pixel: ("
           << SkColorGetR(decoded_pixel) << ", "
           << SkColorGetG(decoded_pixel) << ", "
           << SkColorGetB(decoded_pixel) << ")";
     }
   }
 }
 
+TEST(PNGCodec, EncodeWithComment) {
+  const int w = 10, h = 10;
+
+  std::vector<unsigned char> 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_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";
+
+  EXPECT_NE(search(encoded.begin(), encoded.end(), kExpected1,
+                   kExpected1 + arraysize(kExpected1)),
+            encoded.end());
+  EXPECT_NE(search(encoded.begin(), encoded.end(), kExpected2,
+                   kExpected2 + arraysize(kExpected2)),
+            encoded.end());
+  EXPECT_NE(search(encoded.begin(), encoded.end(), kExpected3,
+                   kExpected3 + arraysize(kExpected3)),
+            encoded.end());
+}
+
 }  // namespace gfx