Fix for Issue 331895: Make gesturenav screenshot greyscale

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 <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libpng/png.h"
@@ skipping 231 matching lines @@
          abs(static_cast<int>(SkColorGetA(a) - SkColorGetA(b))) < 2;
 }
 
 // Returns true if the RGB components are "close."
 bool NonAlphaColorsClose(uint32_t a, uint32_t b) {
   return abs(static_cast<int>(SkColorGetB(a) - SkColorGetB(b))) < 2 &&
          abs(static_cast<int>(SkColorGetG(a) - SkColorGetG(b))) < 2 &&
          abs(static_cast<int>(SkColorGetR(a) - SkColorGetR(b))) < 2;
 }
 
-void MakeTestSkBitmap(int w, int h, SkBitmap* bmp) {
+// Returns true if the BGRA 4-bit SkColor is "close" to the Gray 8-bit SkColor.

[Peter Kasting, 2014/02/04 01:37:15]

Nit: Don't you mean 32-bit (or 4-byte)?

+bool BGRAGrayColorsClose(uint32_t a, uint8_t b) {
+  return abs(static_cast<int>(SkColorGetB(a) - b)) < 2 &&
+         abs(static_cast<int>(SkColorGetG(a) - b)) < 2 &&
+         abs(static_cast<int>(SkColorGetR(a) - b)) < 2 &&
+         abs(static_cast<int>(SkColorGetA(a) - 255)) < 2;
+}
+
+void MakeTestBGRASkBitmap(int w, int h, SkBitmap* bmp) {
   bmp->setConfig(SkBitmap::kARGB_8888_Config, w, h);
   bmp->allocPixels();
 
   uint32_t* src_data = bmp->getAddr32(0, 0);
   for (int i = 0; i < w * h; i++) {

[Peter Kasting, 2014/02/04 01:37:15]

Nit: {} unnecessary

     src_data[i] = SkPreMultiplyARGB(i % 255, i % 250, i % 245, i % 240);
   }
 }
 
+void MakeTestA8SkBitmap(int w, int h, SkBitmap* bmp) {
+  bmp->setConfig(SkBitmap::kA8_Config, w, h);
+  bmp->allocPixels();
+
+  uint8_t* src_data = bmp->getAddr8(0, 0);
+  for (int i = 0; i < w * h; i++) {

[Peter Kasting, 2014/02/04 01:37:15]

Nit: {} unnecessary

+    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,
@@ skipping 738 matching lines @@
       uint32_t decoded_pixel = decoded_bitmap.getAddr32(0, y)[x];
       EXPECT_TRUE(ColorsClose(original_pixel, decoded_pixel));
     }
   }
 }
 
 TEST(PNGCodec, EncodeBGRASkBitmap) {
   const int w = 20, h = 20;
 
   SkBitmap original_bitmap;
-  MakeTestSkBitmap(w, h, &original_bitmap);
+  MakeTestBGRASkBitmap(w, h, &original_bitmap);
 
   // Encode the bitmap.
   std::vector<unsigned char> encoded;
   PNGCodec::EncodeBGRASkBitmap(original_bitmap, false, &encoded);
 
   // Decode the encoded string.
   SkBitmap decoded_bitmap;
   EXPECT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
                                &decoded_bitmap));
 
   // Compare the original bitmap and the output bitmap. We use ColorsClose
   // as SkBitmaps are considered to be pre-multiplied, the unpremultiplication
   // (in Encode) and repremultiplication (in Decode) can be lossy.
   for (int x = 0; x < w; x++) {
     for (int y = 0; y < h; y++) {
       uint32_t original_pixel = original_bitmap.getAddr32(0, y)[x];
       uint32_t decoded_pixel = decoded_bitmap.getAddr32(0, y)[x];
       EXPECT_TRUE(ColorsClose(original_pixel, decoded_pixel));
     }
   }
 }
 
+TEST(PNGCodec, EncodeA8SkBitmap) {
+  const int w = 20, h = 20;
+
+  SkBitmap original_bitmap;
+  MakeTestA8SkBitmap(w, h, &original_bitmap);
+
+  // Encode the bitmap.
+  std::vector<unsigned char> encoded;
+  EXPECT_TRUE(PNGCodec::EncodeA8SkBitmap(original_bitmap, &encoded));
+
+  // Decode the encoded string.
+  SkBitmap decoded_bitmap;
+  EXPECT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
+                               &decoded_bitmap));
+
+  for (int x = 0; x < w; x++) {
+    for (int y = 0; y < h; y++) {
+      uint8_t original_pixel = *original_bitmap.getAddr8(x, y);
+      uint32_t decoded_pixel = *decoded_bitmap.getAddr32(x, y);
+      EXPECT_TRUE(BGRAGrayColorsClose(decoded_pixel, original_pixel));

[Peter Kasting, 2014/02/04 01:37:15]

How come we can't just check for direct equality?  Shouldn't a lossless encode
of a greyscale image be perfectly representable in full color?

+    }
+  }
+}
+
 TEST(PNGCodec, EncodeBGRASkBitmapDiscardTransparency) {
   const int w = 20, h = 20;
 
   SkBitmap original_bitmap;
-  MakeTestSkBitmap(w, h, &original_bitmap);
+  MakeTestBGRASkBitmap(w, h, &original_bitmap);
 
   // Encode the bitmap.
   std::vector<unsigned char> encoded;
   PNGCodec::EncodeBGRASkBitmap(original_bitmap, true, &encoded);
 
   // Decode the encoded string.
   SkBitmap decoded_bitmap;
   EXPECT_TRUE(PNGCodec::Decode(&encoded.front(), encoded.size(),
                                &decoded_bitmap));
 
@@ skipping 56 matching lines @@
                         kExpected3 + arraysize(kExpected3)),
             encoded.end());
 }
 
 TEST(PNGCodec, EncodeDecodeWithVaryingCompressionLevels) {
   const int w = 20, h = 20;
 
   // create an image with known values, a must be opaque because it will be
   // lost during encoding
   SkBitmap original_bitmap;
-  MakeTestSkBitmap(w, h, &original_bitmap);
+  MakeTestBGRASkBitmap(w, h, &original_bitmap);
 
   // encode
   std::vector<unsigned char> encoded_normal;
   EXPECT_TRUE(
       PNGCodec::EncodeBGRASkBitmap(original_bitmap, false, &encoded_normal));
 
   std::vector<unsigned char> encoded_fast;
   EXPECT_TRUE(
       PNGCodec::FastEncodeBGRASkBitmap(original_bitmap, false, &encoded_fast));
 
   // Make sure the different compression settings actually do something; the
   // sizes should be different.
   EXPECT_NE(encoded_normal.size(), encoded_fast.size());
 
   // decode, they should be identical to the original.
   SkBitmap decoded;
   EXPECT_TRUE(
       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