Add fuzziness to checking whether two SkBitmaps are equal for ImageTest.*

ui/gfx/image/image_unittest_util.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.
 
 // Because the unit tests for gfx::Image are spread across multiple
 // implementation files, this header contains the reusable components.
 
 #include "ui/gfx/image/image_unittest_util.h"
 
+#include <cmath>
+
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image_skia.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #include "ui/gfx/gtk_util.h"
 #elif defined(OS_IOS)
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "skia/ext/skia_utils_ios.h"
 #elif defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #include "skia/ext/skia_utils_mac.h"
 #endif
 
 namespace gfx {
 namespace test {
 
+namespace {
+
+bool ColorComponentsClose(SkColor component1, SkColor component2) {
+  int c1 = static_cast<int>(component1);
+  int c2 = static_cast<int>(component2);
+  return (std::abs(c1 - c2) <= 40);

[Robert Sesek, 2013/01/03 17:37:52]

nit: no () around return values

[pkotwicz, 2013/01/03 18:02:49]

Will do.
I want the try jobs to finish first.

+}
+
+bool ColorsClose(SkColor color1, SkColor color2) {
+  // Be tolerant of floating point rounding and lossy color space conversions.
+  return ColorComponentsClose(SkColorGetR(color1), SkColorGetR(color2)) &&
+         ColorComponentsClose(SkColorGetG(color1), SkColorGetG(color2)) &&
+         ColorComponentsClose(SkColorGetB(color1), SkColorGetB(color2)) &&
+         ColorComponentsClose(SkColorGetA(color1), SkColorGetA(color2));
+}
+
+}  // namespace
+
 void SetSupportedScaleFactorsTo1xAnd2x() {
   std::vector<ui::ScaleFactor> supported_scale_factors;
   supported_scale_factors.push_back(ui::SCALE_FACTOR_100P);
   supported_scale_factors.push_back(ui::SCALE_FACTOR_200P);
   ui::test::SetSupportedScaleFactors(supported_scale_factors);
 }
 
 const SkBitmap CreateBitmap(int width, int height) {
   SkBitmap bitmap;
   bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
@@ skipping 46 matching lines @@
     return false;
   }
 
   SkAutoLockPixels lock1(bmp1);
   SkAutoLockPixels lock2(bmp2);
   if (!bmp1.getPixels() || !bmp2.getPixels())
     return false;
 
   for (int y = 0; y < bmp1.height(); ++y) {
     for (int x = 0; x < bmp1.width(); ++x) {
-      if (*bmp1.getAddr32(x,y) != *bmp2.getAddr32(x,y))
+      if (!ColorsClose(bmp1.getColor(x,y), bmp2.getColor(x,y)))
         return false;
     }
   }
 
   return true;
 }
 
 bool IsEqual(const scoped_refptr<base::RefCountedMemory>& bytes,
              const SkBitmap& bitmap) {
   SkBitmap decoded;
   if (!bytes.get() ||
       !PNGCodec::Decode(bytes->front(), bytes->size(), &decoded)) {
     return bitmap.isNull();
   }
 
   return IsEqual(bitmap, decoded);
 }
 
 void CheckImageIndicatesPNGDecodeFailure(const gfx::Image& image) {
   SkBitmap bitmap = image.AsBitmap();
   EXPECT_FALSE(bitmap.isNull());
   EXPECT_LE(16, bitmap.width());
   EXPECT_LE(16, bitmap.height());
   SkAutoLockPixels auto_lock(bitmap);
-  CheckColor(bitmap.getColor(10, 10), true);
+  CheckColors(bitmap.getColor(10, 10), SK_ColorRED);
 }
 
 bool ImageSkiaStructureMatches(
     const gfx::ImageSkia& image_skia,
     int width,
     int height,
     const std::vector<ui::ScaleFactor>& scale_factors) {
   if (image_skia.isNull() ||
       image_skia.width() != width ||
       image_skia.height() != height ||
@@ skipping 94 matching lines @@
   guchar alpha = gdk_pixbuf_get_has_alpha(image) ? pixel[3] : 255;
   return SkColorSetARGB(alpha, pixel[0], pixel[1], pixel[2]);
 }
 #else
 SkColor GetPlatformImageColor(PlatformImage image, int x, int y) {
   SkAutoLockPixels auto_lock(image);
   return image.getColor(x, y);
 }
 #endif
 
-void CheckColor(SkColor color, bool is_red) {
-  // Be tolerant of floating point rounding and lossy color space conversions.
-  if (is_red) {
-    EXPECT_GT(SkColorGetR(color) / 255.0, 0.95);
-    EXPECT_LT(SkColorGetG(color) / 255.0, 0.05);
-  } else {
-    EXPECT_GT(SkColorGetG(color) / 255.0, 0.95);
-    EXPECT_LT(SkColorGetR(color) / 255.0, 0.05);
-  }
-  EXPECT_LT(SkColorGetB(color) / 255.0, 0.05);
-  EXPECT_GT(SkColorGetA(color) / 255.0, 0.95);
+void CheckColors(SkColor color1, SkColor color2) {
+  EXPECT_TRUE(ColorsClose(color1, color2));
 }
 
 void CheckIsTransparent(SkColor color) {
   EXPECT_LT(SkColorGetA(color) / 255.0, 0.05);
 }
 
 bool IsPlatformImageValid(PlatformImage image) {
 #if defined(OS_MACOSX) || defined(TOOLKIT_GTK)
   return image != NULL;
 #else
   return !image.isNull();
 #endif
 }
 
 bool PlatformImagesEqual(PlatformImage image1, PlatformImage image2) {
 #if defined(OS_MACOSX) || defined(TOOLKIT_GTK)
   return image1 == image2;
 #else
   return image1.getPixels() == image2.getPixels();
 #endif
 }
 
 }  // namespace test
 }  // namespace gfx