CreateButtonBackground() has been creating unpremultiplied bitmaps.

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 <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <algorithm>
@@ skipping 111 matching lines @@
     }
   }
 
   return masked;
 }
 
 // static
 SkBitmap SkBitmapOperations::CreateButtonBackground(SkColor color,
                                                     const SkBitmap& image,
                                                     const SkBitmap& mask) {
+  // TODO: can we just do this with a couple SkCanvas draw calls?

[danakj, 2016/06/22 00:51:27]

TODO format is:

TODO(chromiumname): text
or
TODO(crbug.com/LMNOP): text

[mtklein_C, 2016/07/28 19:56:04]

Gotcha.  Good point... no one will probably ever care to fix these.

+  // e.g. drawColor(color) -> drawBitmap(image) -> drawBitmap(mask, kDstIn_Mode)
+  // This requires we first pin down the premul/unpremul state of each bitmap.
+
+  // TODO: It sure seems like image is actually unpremultiplied.
+  // The math producing dst_row[x] below is a correct SrcOver when bg is

[mtklein_C, 2016/06/22 15:19:40]

Is this one too far away?

[sky, 2016/06/22 15:37:43]

It wasn't obvious to me that the two relate. Comments with TODO in them are easy
to ignore.

[mtklein_C, 2016/07/28 19:56:04]

Fixed up, I think.

+  // premultiplied and img is unpremultiplied.
   DCHECK(image.colorType() == kN32_SkColorType);
   DCHECK(mask.colorType() == kN32_SkColorType);
 
   SkBitmap background;
   background.allocN32Pixels(mask.width(), mask.height());
 
+  // We premultiply bg here.

[sky, 2016/06/22 15:17:40]

This comment just documents the code, and isn't very helpful. A comment that
describes why we need to premultiply helps those looking at the code understand
why the code is the way it is.

[mtklein_C, 2016/07/28 19:56:04]

Gone.

   double bg_a = SkColorGetA(color);
-  double bg_r = SkColorGetR(color);
-  double bg_g = SkColorGetG(color);
-  double bg_b = SkColorGetB(color);
+  double bg_r = SkColorGetR(color) * (bg_a / 255.0);
+  double bg_g = SkColorGetG(color) * (bg_a / 255.0);
+  double bg_b = SkColorGetB(color) * (bg_a / 255.0);
 
   SkAutoLockPixels lock_mask(mask);
   SkAutoLockPixels lock_image(image);
   SkAutoLockPixels lock_background(background);
 
   for (int y = 0; y < mask.height(); ++y) {
     uint32_t* dst_row = background.getAddr32(0, y);
     uint32_t* image_row = image.getAddr32(0, y % image.height());
     uint32_t* mask_row = mask.getAddr32(0, y);
 
     for (int x = 0; x < mask.width(); ++x) {
       uint32_t image_pixel = image_row[x % image.width()];
 
       double img_a = SkColorGetA(image_pixel);
       double img_r = SkColorGetR(image_pixel);
       double img_g = SkColorGetG(image_pixel);
       double img_b = SkColorGetB(image_pixel);
 
-      double img_alpha = static_cast<double>(img_a) / 255.0;
+      double img_alpha = img_a / 255.0;
       double img_inv = 1 - img_alpha;
 
       double mask_a = static_cast<double>(SkColorGetA(mask_row[x])) / 255.0;
 
       dst_row[x] = SkColorSetARGB(
+          // TODO: why not the usual SrcOver alpha?
           static_cast<int>(std::min(255.0, bg_a + img_a) * mask_a),
           static_cast<int>(((bg_r * img_inv) + (img_r * img_alpha)) * mask_a),
           static_cast<int>(((bg_g * img_inv) + (img_g * img_alpha)) * mask_a),
           static_cast<int>(((bg_b * img_inv) + (img_b * img_alpha)) * mask_a));
     }
   }
 
   return background;
 }
 
@@ skipping 606 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;
 }