cc: For cc pixel test, create data url for pngs and print bounding rect.

cc/test/pixel_comparator.cc

 // Copyright (c) 2013 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 "cc/test/pixel_comparator.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 
 namespace cc {
 
 ExactPixelComparator::ExactPixelComparator(const bool discard_alpha)
     : discard_alpha_(discard_alpha) {
 }
 
 bool ExactPixelComparator::Compare(const SkBitmap& actual_bmp,
                                    const SkBitmap& expected_bmp) const {
   // Number of pixels with an error
   int error_pixels_count = 0;
+  // Min/Max X,Y for bounding box
+  int minimum_difference_x = -99;

[danakj, 2014/07/07 16:07:02]

Can you just use a gfx::Rect that starts empty and Union in pixels that are
wrong?

[sohanjg, 2014/07/08 07:31:08]

Done.

+  int minimum_difference_y = -99;
+  int maximum_difference_x = 0;
+  int maximum_difference_y = 0;
 
   // Check that bitmaps have identical dimensions.
   DCHECK(actual_bmp.width() == expected_bmp.width() &&
          actual_bmp.height() == expected_bmp.height());
 
   SkAutoLockPixels lock_actual_bmp(actual_bmp);
   SkAutoLockPixels lock_expected_bmp(expected_bmp);
-
   for (int x = 0; x < actual_bmp.width(); ++x) {
     for (int y = 0; y < actual_bmp.height(); ++y) {
       SkColor actual_color = actual_bmp.getColor(x, y);
       SkColor expected_color = expected_bmp.getColor(x, y);
       if (discard_alpha_) {
         actual_color = SkColorSetA(actual_color, 0);
         expected_color = SkColorSetA(expected_color, 0);
       }
-
       if (actual_color != expected_color) {
         ++error_pixels_count;
-        LOG(ERROR) << "Pixel error at x=" << x << " y=" << y << "; "
-                   << "actual RGBA=("
-                   << SkColorGetR(actual_color) << ","
-                   << SkColorGetG(actual_color) << ","
-                   << SkColorGetB(actual_color) << ","
-                   << SkColorGetA(actual_color) << "); "
-                   << "expected RGBA=("
-                   << SkColorGetR(expected_color) << ","
-                   << SkColorGetG(expected_color) << ","
-                   << SkColorGetB(expected_color) << ","
-                   << SkColorGetA(expected_color) << ")";
+        int difference_color = actual_color - expected_color;
+        if (difference_color < 0)
+          difference_color = 0 - difference_color;
+        if ((error_pixels_count == 1) ||
+            (x < minimum_difference_x && y < minimum_difference_y)) {
+          minimum_difference_x = x;
+          minimum_difference_y = y;
+        }
+        if (x > maximum_difference_x && y > maximum_difference_y) {
+          maximum_difference_x = x;
+          maximum_difference_y = y;
+        }
       }
     }
   }
 
   if (error_pixels_count != 0) {
     LOG(ERROR) << "Number of pixel with an error: " << error_pixels_count;
+    LOG(ERROR) << "Error Bounding Box : "
+               << " Max X-Y Co-ordinates X = " << maximum_difference_x

[danakj, 2014/07/07 16:07:02]

You can just use ToString() on the Rect if you use one.

[sohanjg, 2014/07/08 07:31:08]

Done.

+               << " Y = " << maximum_difference_y;
+    LOG(ERROR) << "Error Bounding Box : "
+               << " Min X-Y Co-ordinates X = " << minimum_difference_x
+               << " Y = " << minimum_difference_y;
     return false;
   }
 
   return true;
 }
 
 FuzzyPixelComparator::FuzzyPixelComparator(
     const bool discard_alpha,
     const float error_pixels_percentage_limit,
     const float small_error_pixels_percentage_limit,
@@ skipping 18 matching lines @@
   int64 sum_abs_error_r = 0;
   int64 sum_abs_error_g = 0;
   int64 sum_abs_error_b = 0;
   int64 sum_abs_error_a = 0;
   // The per channel maximum absolute errors over all pixels.
   int max_abs_error_r = 0;
   int max_abs_error_g = 0;
   int max_abs_error_b = 0;
   int max_abs_error_a = 0;
 
+  // Min/Max X,Y for bounding box
+  int minimum_difference_x = -99;
+  int minimum_difference_y = -99;
+  int maximum_difference_x = 0;
+  int maximum_difference_y = 0;
+
   // Check that bitmaps have identical dimensions.
   DCHECK(actual_bmp.width() == expected_bmp.width() &&
          actual_bmp.height() == expected_bmp.height());
 
   // Check that bitmaps are not empty.
   DCHECK(actual_bmp.width() > 0 && actual_bmp.height() > 0);
 
   SkAutoLockPixels lock_actual_bmp(actual_bmp);
   SkAutoLockPixels lock_expected_bmp(expected_bmp);
 
@@ skipping 80 matching lines @@
     LOG(ERROR) << "Average absolute error (excluding identical pixels): "
                << "R=" << avg_abs_error_r << " "
                << "G=" << avg_abs_error_g << " "
                << "B=" << avg_abs_error_b << " "
                << "A=" << avg_abs_error_a;
     LOG(ERROR) << "Largest absolute error: "
                << "R=" << max_abs_error_r << " "
                << "G=" << max_abs_error_g << " "
                << "B=" << max_abs_error_b << " "
                << "A=" << max_abs_error_a;
-
+    error_pixels_count = 0;
       for (int x = 0; x < actual_bmp.width(); ++x) {
         for (int y = 0; y < actual_bmp.height(); ++y) {
           SkColor actual_color = actual_bmp.getColor(x, y);
           SkColor expected_color = expected_bmp.getColor(x, y);
           if (discard_alpha_) {
             actual_color = SkColorSetA(actual_color, 0);
             expected_color = SkColorSetA(expected_color, 0);
           }
           if (actual_color != expected_color) {
-            LOG(ERROR) << "Pixel error at x=" << x << " y=" << y << "; "
-                       << "actual RGBA=("
-                       << SkColorGetR(actual_color) << ","
-                       << SkColorGetG(actual_color) << ","
-                       << SkColorGetB(actual_color) << ","
-                       << SkColorGetA(actual_color) << "); "
-                       << "expected RGBA=("
-                       << SkColorGetR(expected_color) << ","
-                       << SkColorGetG(expected_color) << ","
-                       << SkColorGetB(expected_color) << ","
-                       << SkColorGetA(expected_color) << ")";
+            ++error_pixels_count;
+            int difference_color = actual_color - expected_color;
+            if (difference_color < 0)
+              difference_color = 0 - difference_color;
+            if ((error_pixels_count == 1) ||
+                (x < minimum_difference_x && y < minimum_difference_y)) {
+              minimum_difference_x = x;
+              minimum_difference_y = y;
+            }
+            if (x > maximum_difference_x && y > maximum_difference_y) {
+              maximum_difference_x = x;
+              maximum_difference_y = y;
+            }
           }
         }
       }
-
+      LOG(ERROR) << "Error Bounding Box : "
+                 << " Max X-Y Co-ordinates X = " << maximum_difference_x
+                 << " Y = " << maximum_difference_y;
+      LOG(ERROR) << "Error Bounding Box : "
+                 << " Min X-Y Co-ordinates X = " << minimum_difference_x
+                 << " Y = " << minimum_difference_y;
     return false;
   } else {
     return true;
   }
 }
 
 }  // namespace cc