Add VectorIconButton functionality to ImageButton.

ui/views/controls/button/image_button.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/controls/button/image_button.h"
 
 #include <utility>
 
 #include "base/strings/utf_string_conversions.h"
 #include "ui/accessibility/ax_node_data.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image_skia_operations.h"
+#include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/scoped_canvas.h"
+#include "ui/gfx/vector_icon_types.h"
+#include "ui/views/animation/ink_drop_host_view.h"
+#include "ui/views/border.h"
 #include "ui/views/painter.h"
+#include "ui/views/views_delegate.h"
 #include "ui/views/widget/widget.h"
 
 namespace views {
 
 // Default button size if no image is set. This is ignored if there is an image,
 // and exists for historical reasons (any number of clients could depend on this
 // behaviour).
 static const int kDefaultWidth = 16;
 static const int kDefaultHeight = 14;
 
 const char ImageButton::kViewClassName[] = "ImageButton";
 
+SkColor ImageButtonDelegate::GetVectorIconColor() const {
+  return SK_ColorBLACK;
+}
+
+// static
+ImageButton* ImageButton::CreateDefaultVectorIconButton(
+    const gfx::VectorIcon& icon,
+    ImageButtonDelegate* delegate) {
+  ImageButton* button = new ImageButton(delegate);
+  button->SetVectorIcon(icon);
+  button->SetInkDropMode(InkDropHostView::InkDropMode::ON);
+  button->set_has_ink_drop_action_on_click(true);
+  button->SetImageAlignment(ImageButton::ALIGN_CENTER,
+                            ImageButton::ALIGN_MIDDLE);
+  button->SetFocusPainter(nullptr);
+  button->SetPadding(ViewsDelegate::GetInstance()->GetButtonMargins());
+  return button;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ImageButton, public:
 
-ImageButton::ImageButton(ButtonListener* listener)
-    : CustomButton(listener),
+ImageButton::ImageButton(ImageButtonDelegate* delegate)
+    : CustomButton(delegate),
+      vector_icon_(nullptr),
       h_alignment_(ALIGN_LEFT),
       v_alignment_(ALIGN_TOP),
       draw_image_mirrored_(false),
       focus_painter_(Painter::CreateDashedFocusPainter()) {
+  delegate_ = delegate;
   // By default, we request that the gfx::Canvas passed to our View::OnPaint()
   // implementation is flipped horizontally so that the button's images are
   // mirrored when the UI directionality is right-to-left.
   EnableCanvasFlippingForRTLUI(true);
 }
 
 ImageButton::~ImageButton() {
 }
 
 const gfx::ImageSkia& ImageButton::GetImage(ButtonState state) const {
@@ skipping 10 matching lines @@
   const gfx::Size old_preferred_size = GetPreferredSize();
   images_[for_state] = image;
 
   if (old_preferred_size != GetPreferredSize())
     PreferredSizeChanged();
 
   if (state() == for_state)
     SchedulePaint();
 }
 
+void ImageButton::SetVectorIcon(const gfx::VectorIcon& icon) {
+  vector_icon_ = &icon;
+  UpdateImagesFromVectorIcon();
+}
+
 void ImageButton::SetBackground(SkColor color,
                                 const gfx::ImageSkia* image,
                                 const gfx::ImageSkia* mask) {
   if (image == NULL || mask == NULL) {
     background_image_ = gfx::ImageSkia();
     return;
   }
 
   background_image_ = gfx::ImageSkiaOperations::CreateButtonBackground(color,
      *image, *mask);
@@ skipping 11 matching lines @@
 }
 
 void ImageButton::SetMinimumImageSize(const gfx::Size& size) {
   if (minimum_image_size_ == size)
     return;
 
   minimum_image_size_ = size;
   PreferredSizeChanged();
 }
 
+void ImageButton::SetPadding(const gfx::Insets& padding) {
+  if (padding.IsEmpty())
+    SetBorder(nullptr);
+  else
+    SetBorder(CreateEmptyBorder(padding));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ImageButton, View overrides:
 
 gfx::Size ImageButton::GetPreferredSize() const {
   gfx::Size size(kDefaultWidth, kDefaultHeight);
   if (!images_[STATE_NORMAL].isNull()) {
     size = gfx::Size(images_[STATE_NORMAL].width(),
                      images_[STATE_NORMAL].height());
   }
 
@@ skipping 27 matching lines @@
     gfx::Point position = ComputeImagePaintPosition(img);
     if (!background_image_.isNull())
       canvas->DrawImageInt(background_image_, position.x(), position.y());
 
     canvas->DrawImageInt(img, position.x(), position.y());
   }
 
   Painter::PaintFocusPainter(this, canvas, focus_painter());
 }
 
+void ImageButton::OnThemeChanged() {
+  UpdateImagesFromVectorIcon();
+}
+
+void ImageButton::OnNativeThemeChanged(const ui::NativeTheme* theme) {
+  UpdateImagesFromVectorIcon();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ImageButton, protected:
 
 void ImageButton::OnFocus() {
   CustomButton::OnFocus();
   if (focus_painter_.get())
     SchedulePaint();
 }
 
 void ImageButton::OnBlur() {
@@ skipping 40 matching lines @@
     y = (rect.height() - image.height()) / 2;
   else if (v_alignment_ == ALIGN_BOTTOM)
     y = rect.height() - image.height();
 
   x += rect.x();
   y += rect.y();
 
   return gfx::Point(x, y);
 }
 
+void ImageButton::UpdateImagesFromVectorIcon() {
+  if (!vector_icon_)
+    return;
+
+  SkColor icon_color =
+      color_utils::DeriveDefaultIconColor(delegate_->GetVectorIconColor());
+  SkColor disabled_color = SkColorSetA(icon_color, 0xff / 2);
+  SetImage(CustomButton::STATE_NORMAL,
+           gfx::CreateVectorIcon(*vector_icon_, icon_color));
+  SetImage(CustomButton::STATE_DISABLED,
+           gfx::CreateVectorIcon(*vector_icon_, disabled_color));
+  set_ink_drop_base_color(icon_color);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ToggleImageButton, public:
 
-ToggleImageButton::ToggleImageButton(ButtonListener* listener)
-    : ImageButton(listener),
-      toggled_(false) {
-}
+ToggleImageButton::ToggleImageButton(ImageButtonDelegate* delegate)
+    : ImageButton(delegate), toggled_(false) {}
 
 ToggleImageButton::~ToggleImageButton() {
 }
 
 void ToggleImageButton::SetToggled(bool toggled) {
   if (toggled == toggled_)
     return;
 
   for (int i = 0; i < STATE_COUNT; ++i) {
     gfx::ImageSkia temp = images_[i];
@@ skipping 65 matching lines @@
   // accessible toggle button.
   if ((toggled_ && !images_[ButtonState::STATE_NORMAL].isNull()) ||
       (!toggled_ && !alternate_images_[ButtonState::STATE_NORMAL].isNull())) {
     node_data->role = ui::AX_ROLE_TOGGLE_BUTTON;
     if (toggled_)
       node_data->AddStateFlag(ui::AX_STATE_PRESSED);
   }
 }
 
 }  // namespace views