Fix rounding rules for skia operations to work with non-integer scaling factors.

ui/gfx/skbitmap_operations.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 "ui/gfx/skbitmap_operations.h"
 
 #include <algorithm>
 #include <string.h>
 
 #include "base/logging.h"
@@ skipping 63 matching lines @@
   canvas.drawBitmapRect(second, NULL, rect);
 
   return superimposed;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateBlendedBitmap(const SkBitmap& first,
                                                  const SkBitmap& second,
                                                  double alpha) {
   DCHECK((alpha >= 0) && (alpha <= 1));
-  DCHECK(first.width() == second.width());
-  DCHECK(first.height() == second.height());
+  // Allow for a 1 pixel mismatch in height or width, which may result from

[pkotwicz, 2013/03/12 15:54:37]

I would rather that you did the clipping before calling
CreateImageSkiaRep(first_rep, second_rep) in BinaryImageSource.
You can use SkBitmap::extractSubset() to do the clipping.

[kevers, 2013/03/12 22:02:25]

Done.

+  // rounding errors when working with fractional scale factors.
+  DCHECK(abs(first.width() - second.width()) <= 1);
+  DCHECK(abs(first.height() - second.height()) <= 1);
   DCHECK(first.bytesPerPixel() == second.bytesPerPixel());
   DCHECK(first.config() == SkBitmap::kARGB_8888_Config);
 
   // Optimize for case where we won't need to blend anything.
   static const double alpha_min = 1.0 / 255;
   static const double alpha_max = 254.0 / 255;
   if (alpha < alpha_min)
     return first;
   else if (alpha > alpha_max)
     return second;
 
   SkAutoLockPixels lock_first(first);
   SkAutoLockPixels lock_second(second);
 
+  int width = std::min(first.width(), second.width());
+  int height = std::min(first.height(), second.height());
+
   SkBitmap blended;
-  blended.setConfig(SkBitmap::kARGB_8888_Config, first.width(), first.height(),
-                    0);
+  blended.setConfig(SkBitmap::kARGB_8888_Config, width, height, 0);
   blended.allocPixels();
   blended.eraseARGB(0, 0, 0, 0);
 
   double first_alpha = 1 - alpha;
 
-  for (int y = 0; y < first.height(); ++y) {
+  for (int y = 0; y < height; ++y) {
     uint32* first_row = first.getAddr32(0, y);
     uint32* second_row = second.getAddr32(0, y);
     uint32* dst_row = blended.getAddr32(0, y);
 
-    for (int x = 0; x < first.width(); ++x) {
+    for (int x = 0; x < width; ++x) {
       uint32 first_pixel = first_row[x];
       uint32 second_pixel = second_row[x];
 
       int a = static_cast<int>((SkColorGetA(first_pixel) * first_alpha) +
                                (SkColorGetA(second_pixel) * alpha));
       int r = static_cast<int>((SkColorGetR(first_pixel) * first_alpha) +
                                (SkColorGetR(second_pixel) * alpha));
       int g = static_cast<int>((SkColorGetG(first_pixel) * first_alpha) +
                                (SkColorGetG(second_pixel) * alpha));
       int b = static_cast<int>((SkColorGetB(first_pixel) * first_alpha) +
                                (SkColorGetB(second_pixel) * alpha));
 
       dst_row[x] = SkColorSetARGB(a, r, g, b);
     }
   }
 
   return blended;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateMaskedBitmap(const SkBitmap& rgb,
                                                 const SkBitmap& alpha) {
-  DCHECK(rgb.width() == alpha.width());
-  DCHECK(rgb.height() == alpha.height());
+  // Allow for a 1 pixel mismatch in height or width, which may result from
+  // rounding errors when working with fractional scale factors.
+  DCHECK(abs(rgb.width() - alpha.width()) <= 1);
+  DCHECK(abs(rgb.height() - alpha.height()) <= 1);
   DCHECK(rgb.bytesPerPixel() == alpha.bytesPerPixel());
   DCHECK(rgb.config() == SkBitmap::kARGB_8888_Config);
   DCHECK(alpha.config() == SkBitmap::kARGB_8888_Config);
 
   SkBitmap masked;
   masked.setConfig(SkBitmap::kARGB_8888_Config, rgb.width(), rgb.height(), 0);
   masked.allocPixels();
   masked.eraseARGB(0, 0, 0, 0);
 
   SkAutoLockPixels lock_rgb(rgb);
   SkAutoLockPixels lock_alpha(alpha);
   SkAutoLockPixels lock_masked(masked);
 
-  for (int y = 0; y < masked.height(); ++y) {
+  int height = std::min(rgb.height(), masked.height());
+  int width = std::min(rgb.width(), masked.width());
+
+  for (int y = 0; y < height; ++y) {
     uint32* rgb_row = rgb.getAddr32(0, y);
     uint32* alpha_row = alpha.getAddr32(0, y);
     uint32* dst_row = masked.getAddr32(0, y);
 
-    for (int x = 0; x < masked.width(); ++x) {
+    for (int x = 0; x < width; ++x) {
       SkColor rgb_pixel = SkUnPreMultiply::PMColorToColor(rgb_row[x]);
       SkColor alpha_pixel = SkUnPreMultiply::PMColorToColor(alpha_row[x]);
       int alpha = SkAlphaMul(SkColorGetA(rgb_pixel),
                              SkAlpha255To256(SkColorGetA(alpha_pixel)));
       int alpha_256 = SkAlpha255To256(alpha);
       dst_row[x] = SkColorSetARGB(alpha,
                                   SkAlphaMul(SkColorGetR(rgb_pixel), alpha_256),
                                   SkAlphaMul(SkColorGetG(rgb_pixel), alpha_256),
                                   SkAlphaMul(SkColorGetB(rgb_pixel),
                                              alpha_256));
@@ skipping 675 matching lines @@
   canvas.translate(SkFloatToScalar(result.width() * 0.5f),
                    SkFloatToScalar(result.height() * 0.5f));
   canvas.rotate(angle);
   canvas.translate(-SkFloatToScalar(source.width() * 0.5f),
                    -SkFloatToScalar(source.height() * 0.5f));
   canvas.drawBitmap(source, 0, 0);
   canvas.flush();
 
   return result;
 }