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) {
+  // Despite this assert, it seems like image is actually unpremultiplied.
+  // The math producing dst_row[x] below is a correct SrcOver when
+  // bg_* are premultiplied and img_* are unpremultiplied.
   DCHECK(image.colorType() == kN32_SkColorType);
   DCHECK(mask.colorType() == kN32_SkColorType);
 
   SkBitmap background;
   background.allocN32Pixels(mask.width(), mask.height());
 
   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(
+          // This is pretty weird; 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 604 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;
 }