Update profile switcher button on Linux.

chrome/browser/ui/views/profiles/new_avatar_button.cc

 // Copyright 2014 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 "chrome/browser/ui/views/profiles/new_avatar_button.h"
 
 #include <utility>
 
 #include "build/build_config.h"
 #include "chrome/app/vector_icons/vector_icons.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_attributes_entry.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profiles_state.h"
+#include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/views/profiles/avatar_button_delegate.h"
 #include "chrome/browser/ui/views/profiles/profile_chooser_view.h"
 #include "chrome/grit/theme_resources.h"
 #include "components/signin/core/common/profile_management_switches.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/base/theme_provider.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/vector_icons/vector_icons.h"
+#include "ui/views/animation/ink_drop_mask.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/button/label_button_border.h"
 #include "ui/views/painter.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 namespace {
 
+// Insets between view bounds and the filled region for
+// AvatarButtonThemedBorder.
+static constexpr gfx::InsetsF kFillInsets(1);
+
+// Corner radius of the roundrect for AvatarButtonThemedBorder.
+static constexpr float kCornerRadius = 1;
+
+// This class draws the border (and background) of the avatar button for
+// "themed" browser windows, i.e. OpaqueBrowserFrameView. Currently it's only
+// used on Linux as the shape specifically matches the Linux caption buttons.
+// TODO(estade): make this look nice on Windows and use it there as well.
+class AvatarButtonThemedBorder : public views::Border {
+ public:
+  AvatarButtonThemedBorder() {}
+  ~AvatarButtonThemedBorder() override {}
+
+  void Paint(const views::View& view, gfx::Canvas* canvas) override {
+    gfx::RectF fill_bounds(view.GetLocalBounds());
+    fill_bounds.Inset(kFillInsets);
+    cc::PaintFlags fill_flags;
+    fill_flags.setStyle(cc::PaintFlags::kFill_Style);
+    fill_flags.setColor(view.GetThemeProvider()->GetColor(
+        ThemeProperties::COLOR_BUTTON_BACKGROUND));
+    fill_flags.setAntiAlias(true);
+    canvas->DrawRoundRect(fill_bounds, kCornerRadius, fill_flags);
+
+    // Start with an outer dark stroke.
+    cc::PaintFlags stroke_flags;
+    stroke_flags.setStyle(cc::PaintFlags::kStroke_Style);
+    stroke_flags.setColor(SkColorSetA(SK_ColorBLACK, 0x2B));
+    stroke_flags.setStrokeWidth(1);
+    stroke_flags.setAntiAlias(true);
+    gfx::RectF stroke_bounds(view.GetLocalBounds());
+    stroke_bounds.Inset(gfx::InsetsF(0.5f));
+    canvas->DrawRoundRect(stroke_bounds, kCornerRadius, stroke_flags);
+
+    // There's a second, light stroke that matches the fill bounds.

[Peter Kasting, 2017/04/27 02:13:18]

I'm a little worried about the radii of the corners not matching up precisely at
high zoom levels.  I'm also worried about the fact that the stroke width and the
insets have to match, but the code doesn't force this.

I wonder if it makes sense to do something like what we do for tabs, where we
use Op() to compute the fill by subtracting the stroke from the overall region. 
Something like:

  constexpr outer stroke width = 1
  constexpr inner stroke width = 1

  outer stroke region = GetLocalBounds
  fill region = (outer stroke region) inset by (outer stroke width)
  inner carveout region = (fill region) inset by (inner stroke width)

  fill path = round rect for (fill region)
  outer stroke path = (round rect for outer stroke region) - (fill path)
  inner stroke path = (fill path) - (round rect for inner carveout region)

+    stroke_bounds.Inset(kFillInsets);
+    stroke_flags.setColor(SkColorSetA(SK_ColorWHITE, 0x3F));
+    canvas->DrawRoundRect(stroke_bounds, kCornerRadius, stroke_flags);
+  }
+
+  gfx::Insets GetInsets() const override {
+    const int kLeftRightInset = 8;
+    const int kTopInset = 2;
+    const int kBottomInset = 4;
+    return gfx::Insets(kTopInset, kLeftRightInset, kBottomInset,
+                       kLeftRightInset);
+  }
+
+  gfx::Size GetMinimumSize() const override {
+    return gfx::Size(GetInsets().width(), GetInsets().height());
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AvatarButtonThemedBorder);
+};
+
+#if !defined(OS_LINUX)
 std::unique_ptr<views::Border> CreateBorder(const int normal_image_set[],
                                             const int hot_image_set[],
                                             const int pushed_image_set[]) {
   std::unique_ptr<views::LabelButtonAssetBorder> border(
       new views::LabelButtonAssetBorder(views::Button::STYLE_TEXTBUTTON));
   border->SetPainter(false, views::Button::STATE_NORMAL,
       views::Painter::CreateImageGridPainter(normal_image_set));
   border->SetPainter(false, views::Button::STATE_HOVERED,
       views::Painter::CreateImageGridPainter(hot_image_set));
   border->SetPainter(false, views::Button::STATE_PRESSED,
       views::Painter::CreateImageGridPainter(pushed_image_set));
 
   const int kLeftRightInset = 8;
   const int kTopInset = 2;
   const int kBottomInset = 4;
   border->set_insets(gfx::Insets(kTopInset, kLeftRightInset,
                                  kBottomInset, kLeftRightInset));
 
   return std::move(border);
 }
+#endif
 
 }  // namespace
 
 NewAvatarButton::NewAvatarButton(AvatarButtonDelegate* delegate,
                                  AvatarButtonStyle button_style,
                                  Profile* profile)
     : LabelButton(delegate, base::string16()),
       delegate_(delegate),
       error_controller_(this, profile),
       profile_(profile),
       suppress_mouse_released_action_(false) {
   set_triggerable_event_flags(
       ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON);
   set_animate_on_state_change(false);
   SetEnabledTextColors(SK_ColorWHITE);
   SetTextSubpixelRenderingEnabled(false);
   SetHorizontalAlignment(gfx::ALIGN_CENTER);
 
   // The largest text height that fits in the button. If the font list height
   // is larger than this, it will be shrunk to match it.
   // TODO(noms): Calculate this constant algorithmically from the button's size.
   const int kDisplayFontHeight = 16;
   SetFontList(
       label()->font_list().DeriveWithHeightUpperBound(kDisplayFontHeight));
 
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
+  generic_avatar_ =
+      rb->GetImageNamed(IDR_AVATAR_THEMED_BUTTON_AVATAR).AsImageSkia();
+#if defined(OS_LINUX)
+  DCHECK_EQ(AvatarButtonStyle::THEMED, button_style);
+  SetBorder(base::MakeUnique<AvatarButtonThemedBorder>());
+  SetInkDropMode(InkDropMode::ON);
+#else  // !defined(OS_LINUX)
   if (button_style == AvatarButtonStyle::THEMED) {
+    SetBorder(base::MakeUnique<AvatarButtonThemedBorder>());
+    SetInkDropMode(InkDropMode::ON);
     const int kNormalImageSet[] = IMAGE_GRID(IDR_AVATAR_THEMED_BUTTON_NORMAL);
     const int kHotImageSet[] = IMAGE_GRID(IDR_AVATAR_THEMED_BUTTON_HOVER);
     const int kPushedImageSet[] = IMAGE_GRID(IDR_AVATAR_THEMED_BUTTON_PRESSED);
 
     SetBorder(CreateBorder(kNormalImageSet, kHotImageSet, kPushedImageSet));
-    generic_avatar_ =
-        *rb->GetImageNamed(IDR_AVATAR_THEMED_BUTTON_AVATAR).ToImageSkia();
 #if defined(OS_WIN)
   } else if (base::win::GetVersion() < base::win::VERSION_WIN8) {
     const int kNormalImageSet[] = IMAGE_GRID(IDR_AVATAR_GLASS_BUTTON_NORMAL);
     const int kHotImageSet[] = IMAGE_GRID(IDR_AVATAR_GLASS_BUTTON_HOVER);
     const int kPushedImageSet[] = IMAGE_GRID(IDR_AVATAR_GLASS_BUTTON_PRESSED);
 
     SetBorder(CreateBorder(kNormalImageSet, kHotImageSet, kPushedImageSet));
     generic_avatar_ =
         *rb->GetImageNamed(IDR_AVATAR_GLASS_BUTTON_AVATAR).ToImageSkia();
 #endif
   } else {
     const int kNormalImageSet[] = IMAGE_GRID(IDR_AVATAR_NATIVE_BUTTON_NORMAL);
     const int kHotImageSet[] = IMAGE_GRID(IDR_AVATAR_NATIVE_BUTTON_HOVER);
     const int kPushedImageSet[] = IMAGE_GRID(IDR_AVATAR_NATIVE_BUTTON_PRESSED);
 
     SetBorder(CreateBorder(kNormalImageSet, kHotImageSet, kPushedImageSet));
     generic_avatar_ =
         *rb->GetImageNamed(IDR_AVATAR_NATIVE_BUTTON_AVATAR).ToImageSkia();
   }
+#endif  // !defined(OS_LINUX)
 
   g_browser_process->profile_manager()->
       GetProfileAttributesStorage().AddObserver(this);
   Update();
   SchedulePaint();
 }
 
 NewAvatarButton::~NewAvatarButton() {
   g_browser_process->profile_manager()->
       GetProfileAttributesStorage().RemoveObserver(this);
 }
 
 bool NewAvatarButton::OnMousePressed(const ui::MouseEvent& event) {
   // Prevent the bubble from being re-shown if it's already showing.
   suppress_mouse_released_action_ = ProfileChooserView::IsShowing();
   return LabelButton::OnMousePressed(event);
 }
 
 void NewAvatarButton::OnMouseReleased(const ui::MouseEvent& event) {
   if (suppress_mouse_released_action_)
     suppress_mouse_released_action_ = false;
   else
     LabelButton::OnMouseReleased(event);
 }
 
+SkColor NewAvatarButton::GetInkDropBaseColor() const {
+  return SK_ColorWHITE;

[Evan Stade, 2017/04/26 19:24:49]

I stuck with white because the theme-colored background is drawn separately
(regardless of press state).

[Peter Kasting, 2017/04/27 02:13:18]

Is the drop visible at all on a pure-white toolbar (or whatever causes the
theme-colored background to be white)?

I'd think we'd need to select a contrasting color as Bret did for the Win 10
custom titlebar.

+}
+
+std::unique_ptr<views::InkDropMask> NewAvatarButton::CreateInkDropMask() const {
+  return base::MakeUnique<views::RoundRectInkDropMask>(size(), kFillInsets,
+                                                       kCornerRadius);
+}
+
+void NewAvatarButton::NotifyClick(const ui::Event& event) {
+  LabelButton::NotifyClick(event);
+
+  if (ProfileChooserView::IsShowing() && ink_drop_mode() == InkDropMode::ON) {
+    ProfileChooserView::GetCurrentBubbleWidget()->AddObserver(this);
+    AnimateInkDrop(views::InkDropState::ACTIVATED,
+                   ui::LocatedEvent::FromIfValid(&event));
+  }
+}
+
 void NewAvatarButton::OnGestureEvent(ui::GestureEvent* event) {
   // TODO(wjmaclean): The check for ET_GESTURE_LONG_PRESS is done here since
   // no other UI button based on CustomButton appears to handle mouse
   // right-click. If other cases are identified, it may make sense to move this
   // check to CustomButton.
   if (event->type() == ui::ET_GESTURE_LONG_PRESS)
     NotifyClick(*event);
   else
     LabelButton::OnGestureEvent(event);
 }
@@ skipping 21 matching lines @@
   if (profile_->GetPath() == profile_path)
     Update();
 }
 
 void NewAvatarButton::OnProfileSupervisedUserIdChanged(
       const base::FilePath& profile_path) {
   if (profile_->GetPath() == profile_path)
     Update();
 }
 
+void NewAvatarButton::OnWidgetClosing(views::Widget* widget) {
+  if (ink_drop_mode() == InkDropMode::ON)
+    AnimateInkDrop(views::InkDropState::DEACTIVATED, nullptr);
+}
+
 void NewAvatarButton::Update() {
   ProfileAttributesStorage& storage =
       g_browser_process->profile_manager()->GetProfileAttributesStorage();
 
   // If we have a single local profile, then use the generic avatar
   // button instead of the profile name. Never use the generic button if
   // the active profile is Guest.
   const bool use_generic_button =
       !profile_->IsGuestSession() &&
       storage.GetNumberOfProfiles() == 1 &&
@@ skipping 24 matching lines @@
   }
 
   // If we are not using the generic button, then reset the spacing between
   // the text and the possible authentication error icon.
   const int kDefaultImageTextSpacing = 5;
   SetImageLabelSpacing(use_generic_button ? 0 : kDefaultImageTextSpacing);
 
   PreferredSizeChanged();
   delegate_->ButtonPreferredSizeChanged();
 }