Add ink drop ripple to shelf overflow button

ash/common/shelf/overflow_button.cc

 // Copyright 2013 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 "ash/common/shelf/overflow_button.h"
 
 #include "ash/common/ash_constants.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/shelf/ink_drop_button_listener.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_util.h"
 #include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/vector_icons_public.h"
+#include "ui/views/animation/flood_fill_ink_drop_ripple.h"
 
 namespace ash {
 
 OverflowButton::OverflowButton(InkDropButtonListener* listener,
                                WmShelf* wm_shelf)
     : CustomButton(nullptr),
       bottom_image_(nullptr),
       listener_(listener),
       wm_shelf_(wm_shelf) {
   if (MaterialDesignController::IsShelfMaterial()) {
+    SetInkDropMode(InkDropMode::ON);
+    set_ink_drop_base_color(kShelfInkDropBaseColor);
+    set_ink_drop_visible_opacity(kShelfInkDropVisibleOpacity);
     bottom_image_md_ =
         CreateVectorIcon(gfx::VectorIconId::SHELF_OVERFLOW, kShelfIconColor);
     bottom_image_ = &bottom_image_md_;
   } else {
     bottom_image_ = ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
         IDR_ASH_SHELF_OVERFLOW);
   }
 
   SetFocusBehavior(FocusBehavior::ACCESSIBLE_ONLY);
   SetAccessibleName(l10n_util::GetStringUTF16(IDS_ASH_SHELF_OVERFLOW_NAME));
 }
 
 OverflowButton::~OverflowButton() {}
 
 void OverflowButton::OnShelfAlignmentChanged() {
   SchedulePaint();
 }
 
+void OverflowButton::OnOverflowBubbleShown() {
+  AnimateInkDrop(views::InkDropState::ACTIVATED, nullptr);
+  // While overflow bubble is active, showing context menu should not hide ink
+  // drop.
+  set_hide_ink_drop_when_showing_context_menu(false);

[bruthig, 2016/07/26 13:57:15]

Does this need to be toggled or can it just be initialized to false?

[mohsen, 2016/07/26 20:00:58]

My OverflowButton::ShouldEnterPushedState() was wrong, which I fixed it. Now
this can just be initialized to false. Thanks for pointing this out!

+  if (!ash::MaterialDesignController::IsShelfMaterial())
+    SchedulePaint();
+}
+
+void OverflowButton::OnOverflowBubbleHidden() {
+  AnimateInkDrop(views::InkDropState::DEACTIVATED, nullptr);
+  set_hide_ink_drop_when_showing_context_menu(true);
+  if (!ash::MaterialDesignController::IsShelfMaterial())
+    SchedulePaint();
+}
+
 void OverflowButton::OnPaint(gfx::Canvas* canvas) {
   gfx::Rect bounds = CalculateButtonBounds();
   PaintBackground(canvas, bounds);
   PaintForeground(canvas, bounds);
 }
 
+std::unique_ptr<views::InkDropRipple> OverflowButton::CreateInkDropRipple()
+    const {
+  return base::WrapUnique(new views::FloodFillInkDropRipple(
+      CalculateButtonBounds(), GetInkDropCenterBasedOnLastEvent(),
+      GetInkDropBaseColor(), ink_drop_visible_opacity()));
+}
+
+bool OverflowButton::ShouldEnterPushedState(const ui::Event& event) {
+  return !wm_shelf_->IsShowingOverflowBubble();
+}
+
+bool OverflowButton::ShouldShowInkDropHighlight() const {
+  return false;
+}
+
 void OverflowButton::NotifyClick(const ui::Event& event) {
   CustomButton::NotifyClick(event);
   if (listener_)
     listener_->ButtonPressed(this, event, ink_drop());
 }
 
 void OverflowButton::PaintBackground(gfx::Canvas* canvas,
                                      const gfx::Rect& bounds) {
   if (MaterialDesignController::IsShelfMaterial()) {
     SkColor background_color = SK_ColorTRANSPARENT;
     if (wm_shelf_->GetBackgroundType() ==
         ShelfBackgroundType::SHELF_BACKGROUND_DEFAULT) {
       background_color = SkColorSetA(kShelfBaseColor,
                                      GetShelfConstant(SHELF_BACKGROUND_ALPHA));
     }
 
     // TODO(bruthig|tdanderson): The background should be changed using a
     // fade in/out animation.
     SkPaint background_paint;
     background_paint.setFlags(SkPaint::kAntiAlias_Flag);
     background_paint.setColor(background_color);
     canvas->DrawRoundRect(bounds, kOverflowButtonCornerRadius,
                           background_paint);
-
-    if (wm_shelf_->IsShowingOverflowBubble()) {
-      SkPaint highlight_paint;
-      highlight_paint.setFlags(SkPaint::kAntiAlias_Flag);
-      highlight_paint.setColor(kShelfButtonActivatedHighlightColor);
-      canvas->DrawRoundRect(bounds, kOverflowButtonCornerRadius,
-                            highlight_paint);
-    }
   } else {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     const gfx::ImageSkia* background =
         rb.GetImageNamed(NonMaterialBackgroundImageId()).ToImageSkia();
     canvas->DrawImageInt(*background, bounds.x(), bounds.y());
   }
 }
 
 void OverflowButton::PaintForeground(gfx::Canvas* canvas,
                                      const gfx::Rect& bounds) {
@@ skipping 17 matching lines @@
     default:
       image = bottom_image_;
       break;
   }
 
   canvas->DrawImageInt(*image,
                        bounds.x() + ((bounds.width() - image->width()) / 2),
                        bounds.y() + ((bounds.height() - image->height()) / 2));
 }
 
-int OverflowButton::NonMaterialBackgroundImageId() {
+int OverflowButton::NonMaterialBackgroundImageId() const {
   if (wm_shelf_->IsShowingOverflowBubble())
     return IDR_AURA_NOTIFICATION_BACKGROUND_PRESSED;
   else if (wm_shelf_->IsDimmed())
     return IDR_AURA_NOTIFICATION_BACKGROUND_ON_BLACK;
   return IDR_AURA_NOTIFICATION_BACKGROUND_NORMAL;
 }
 
-gfx::Rect OverflowButton::CalculateButtonBounds() {
+gfx::Rect OverflowButton::CalculateButtonBounds() const {
   ShelfAlignment alignment = wm_shelf_->GetAlignment();
   gfx::Rect bounds(GetContentsBounds());
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   if (MaterialDesignController::IsShelfMaterial()) {
     const int width_offset = (bounds.width() - kOverflowButtonSize) / 2;
     const int height_offset = (bounds.height() - kOverflowButtonSize) / 2;
     if (IsHorizontalAlignment(alignment)) {
       bounds = gfx::Rect(bounds.x() + width_offset, bounds.y() + height_offset,
                          kOverflowButtonSize, kOverflowButtonSize);
     } else {
@@ skipping 17 matching lines @@
       bounds =
           gfx::Rect(bounds.x() + (bounds.width() - background->width()) / 2,
                     bounds.y() + kShelfItemInset, background->width(),
                     background->height());
     }
   }
   return bounds;
 }
 
 }  // namespace ash