Fix LabelButtonBorder image blending.

ui/views/painter.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/views/painter.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/base/resource/resource_bundle.h"
@@ skipping 91 matching lines @@
   ImagePainter(const gfx::ImageSkia& image, const gfx::Insets& insets);
 
   virtual ~ImagePainter();
 
   // Returns true if the images are empty.
   bool IsEmpty() const;
 
   // Painter:
   virtual gfx::Size GetMinimumSize() const OVERRIDE;
   virtual void Paint(gfx::Canvas* canvas, const gfx::Size& size) OVERRIDE;
+  virtual void PaintWithSkPaint(gfx::Canvas* canvas,
+                                const gfx::Size& size,
+                                const SkPaint& paint) OVERRIDE;
 
  private:
   // Stretches the given image over the specified canvas area.
   static void Fill(gfx::Canvas* c,
                    const gfx::ImageSkia& i,
                    int x,
                    int y,
                    int w,
-                   int h);
+                   int h,
+                   const SkPaint& paint);
 
   // Images are numbered as depicted below.
   //  ____________________
   // |__i0__|__i1__|__i2__|
   // |__i3__|__i4__|__i5__|
   // |__i6__|__i7__|__i8__|
   gfx::ImageSkia images_[9];
 
   DISALLOW_COPY_AND_ASSIGN(ImagePainter);
 };
@@ skipping 31 matching lines @@
   return images_[0].isNull();
 }
 
 gfx::Size ImagePainter::GetMinimumSize() const {
   return IsEmpty() ? gfx::Size() : gfx::Size(
       images_[0].width() + images_[1].width() + images_[2].width(),
       images_[0].height() + images_[3].height() + images_[6].height());
 }
 
 void ImagePainter::Paint(gfx::Canvas* canvas, const gfx::Size& size) {
+  PaintWithSkPaint(canvas, size, SkPaint());
+}
+
+void ImagePainter::PaintWithSkPaint(gfx::Canvas* canvas,
+                                    const gfx::Size& size,
+                                    const SkPaint& paint) {
   if (IsEmpty())
     return;
 
   // In case the corners and edges don't all have the same width/height, we draw
   // the center first, and extend it out in all directions to the edges of the
   // images with the smallest widths/heights.  This way there will be no
   // unpainted areas, though some corners or edges might overlap the center.
   int w = size.width();
   int i0w = images_[0].width();
   int i2w = images_[2].width();
   int i3w = images_[3].width();
   int i5w = images_[5].width();
   int i6w = images_[6].width();
   int i8w = images_[8].width();
   int i4x = std::min(std::min(i0w, i3w), i6w);
   int i4w = w - i4x - std::min(std::min(i2w, i5w), i8w);
   int h = size.height();
   int i0h = images_[0].height();
   int i1h = images_[1].height();
   int i2h = images_[2].height();
   int i6h = images_[6].height();
   int i7h = images_[7].height();
   int i8h = images_[8].height();
   int i4y = std::min(std::min(i0h, i1h), i2h);
   int i4h = h - i4y - std::min(std::min(i6h, i7h), i8h);
   if (!images_[4].isNull())
-    Fill(canvas, images_[4], i4x, i4y, i4w, i4h);
-  canvas->DrawImageInt(images_[0], 0, 0);
-  Fill(canvas, images_[1], i0w, 0, w - i0w - i2w, i1h);
-  canvas->DrawImageInt(images_[2], w - i2w, 0);
-  Fill(canvas, images_[3], 0, i0h, i3w, h - i0h - i6h);
-  Fill(canvas, images_[5], w - i5w, i2h, i5w, h - i2h - i8h);
-  canvas->DrawImageInt(images_[6], 0, h - i6h);
-  Fill(canvas, images_[7], i6w, h - i7h, w - i6w - i8w, i7h);
-  canvas->DrawImageInt(images_[8], w - i8w, h - i8h);
+    Fill(canvas, images_[4], i4x, i4y, i4w, i4h, paint);
+  canvas->DrawImageInt(images_[0], 0, 0, paint);
+  Fill(canvas, images_[1], i0w, 0, w - i0w - i2w, i1h, paint);
+  canvas->DrawImageInt(images_[2], w - i2w, 0, paint);
+  Fill(canvas, images_[3], 0, i0h, i3w, h - i0h - i6h, paint);
+  Fill(canvas, images_[5], w - i5w, i2h, i5w, h - i2h - i8h, paint);
+  canvas->DrawImageInt(images_[6], 0, h - i6h, paint);
+  Fill(canvas, images_[7], i6w, h - i7h, w - i6w - i8w, i7h, paint);
+  canvas->DrawImageInt(images_[8], w - i8w, h - i8h, paint);
 }
 
 // static
 void ImagePainter::Fill(gfx::Canvas* c,
                         const gfx::ImageSkia& i,
                         int x,
                         int y,
                         int w,
-                        int h) {
-  c->DrawImageInt(i, 0, 0, i.width(), i.height(), x, y, w, h, false);
+                        int h,
+                        const SkPaint& paint) {
+  c->DrawImageInt(i, 0, 0, i.width(), i.height(), x, y, w, h, false, paint);
 }
 
 }  // namespace
 
 
 // Painter --------------------------------------------------------------------
 
 Painter::Painter() {
 }
 
@@ skipping 40 matching lines @@
 Painter* Painter::CreateImagePainter(const gfx::ImageSkia& image,
                                      const gfx::Insets& insets) {
   return new ImagePainter(image, insets);
 }
 
 // static
 Painter* Painter::CreateImageGridPainter(const int image_ids[]) {
   return new ImagePainter(image_ids);
 }
 
+void Painter::PaintWithSkPaint(gfx::Canvas* canvas,
+                               const gfx::Size& size,
+                               const SkPaint& paint) {
+  // Ignore SkPaint options by default, applicable painters should add support.
+  Paint(canvas, size);
+}
+
 
 // HorizontalPainter ----------------------------------------------------------
 
 HorizontalPainter::HorizontalPainter(const int image_resource_names[]) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   for (int i = 0; i < 3; ++i)
     images_[i] = rb.GetImageNamed(image_resource_names[i]).ToImageSkia();
   DCHECK_EQ(images_[LEFT]->height(), images_[CENTER]->height());
   DCHECK_EQ(images_[LEFT]->height(), images_[RIGHT]->height());
 }
@@ skipping 14 matching lines @@
   canvas->DrawImageInt(*images_[LEFT], 0, 0);
   canvas->DrawImageInt(*images_[RIGHT], size.width() - images_[RIGHT]->width(),
                        0);
   canvas->TileImageInt(
       *images_[CENTER], images_[LEFT]->width(), 0,
       size.width() - images_[LEFT]->width() - images_[RIGHT]->width(),
       images_[LEFT]->height());
 }
 
 }  // namespace views