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"
+#include "ui/gfx/rect.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;
+  // Bounding box for error

[danakj, 2014/07/08 16:08:34]

nit: comments are sentences including periods.

but how about making the variable name say what you wanna say instead of needing
a comment?

[sohanjg, 2014/07/08 16:20:34]

Done.

+  gfx::Rect bounding_rect = gfx::Rect();
 
   // 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) << ")";
+        bounding_rect.set_x(std::min(x, bounding_rect.x()));
+        bounding_rect.set_y(std::min(y, bounding_rect.y()));
+        bounding_rect.set_width(
+            std::max(x, (bounding_rect.x() + bounding_rect.width())) -
+            bounding_rect.x());
+        bounding_rect.set_height(
+            std::max(y, (bounding_rect.y() + bounding_rect.bottom())) -
+            bounding_rect.y());
       }
     }
   }
 
   if (error_pixels_count != 0) {
     LOG(ERROR) << "Number of pixel with an error: " << error_pixels_count;
+    LOG(ERROR) << "Error Bounding Box : " << bounding_rect.ToString();
     return false;
   }
 
   return true;
 }
 
 FuzzyPixelComparator::FuzzyPixelComparator(
     const bool discard_alpha,
     const float error_pixels_percentage_limit,
     const float small_error_pixels_percentage_limit,
@@ skipping 17 matching lines @@
   // The per channel sums of absolute errors over all pixels.
   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;
+  // Bounding box for error
+  gfx::Rect bounding_rect = gfx::Rect();
 
   // 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 91 matching lines @@
 
       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) << ")";
+            bounding_rect.set_x(std::min(x, bounding_rect.x()));
+            bounding_rect.set_y(std::min(y, bounding_rect.y()));
+            bounding_rect.set_width(
+                std::max(x, (bounding_rect.x() + bounding_rect.width())) -
+                bounding_rect.x());
+            bounding_rect.set_height(
+                std::max(y, (bounding_rect.y() + bounding_rect.bottom())) -
+                bounding_rect.y());
           }
         }
       }
-
+      LOG(ERROR) << "Error Bounding Box : " << bounding_rect.ToString();
     return false;
   } else {
     return true;
   }
 }
 
 }  // namespace cc