Moved ButtonInkDropDelegate logic into InkDropHostView and deleted InkDropDelegates.

chrome/browser/ui/views/location_bar/content_setting_image_view.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 "chrome/browser/ui/views/location_bar/content_setting_image_view.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/content_settings/content_setting_bubble_model.h"
 #include "chrome/browser/ui/content_settings/content_setting_image_model.h"
 #include "chrome/browser/ui/views/content_setting_bubble_contents.h"
 #include "chrome/browser/ui/views/location_bar/location_bar_view.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/color_utils.h"
-#include "ui/views/animation/button_ink_drop_delegate.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 // Time spent with animation fully open.
 const int kStayOpenTimeMS = 3200;
 }
 
 
 // static
 const int ContentSettingImageView::kOpenTimeMS = 150;
 const int ContentSettingImageView::kAnimationDurationMS =
     (kOpenTimeMS * 2) + kStayOpenTimeMS;
 
 ContentSettingImageView::ContentSettingImageView(
     ContentSettingImageModel* image_model,
     LocationBarView* parent,
     const gfx::FontList& font_list,
     SkColor parent_background_color)
     : IconLabelBubbleView(0, font_list, parent_background_color, false),
       parent_(parent),
       content_setting_image_model_(image_model),
       slide_animator_(this),
       pause_animation_(false),
       pause_animation_state_(0.0),
       bubble_view_(nullptr),
       suppress_mouse_released_action_(false) {
-  set_ink_drop_delegate(
-      base::WrapUnique(new views::ButtonInkDropDelegate(this, this)));
+  SetHasInkDrop(true);
   if (!ui::MaterialDesignController::IsModeMaterial()) {
     static const int kBackgroundImages[] =
         IMAGE_GRID(IDR_OMNIBOX_CONTENT_SETTING_BUBBLE);
     SetBackgroundImageGrid(kBackgroundImages);
   }
 
   image()->SetHorizontalAlignment(base::i18n::IsRTL()
                                       ? views::ImageView::TRAILING
                                       : views::ImageView::LEADING);
   image()->set_interactive(true);
@@ skipping 27 matching lines @@
   // If the content usage or blockage should be indicated to the user, start the
   // animation and record that the icon has been shown.
   if (!content_setting_image_model_->ShouldRunAnimation(web_contents))
     return;
 
   // We just ignore this blockage if we're already showing some other string to
   // the user.  If this becomes a problem, we could design some sort of queueing
   // mechanism to show one after the other, but it doesn't seem important now.
   int string_id = content_setting_image_model_->explanatory_string_id();
   if (string_id && !label()->visible()) {
-    ink_drop_delegate()->OnAction(views::InkDropState::HIDDEN);
+    AnimateInkDrop(views::InkDropState::HIDDEN);
     SetLabel(l10n_util::GetStringUTF16(string_id));
     label()->SetVisible(true);
     slide_animator_.Show();
   }
 
   content_setting_image_model_->SetAnimationHasRun(web_contents);
 }
 
 const char* ContentSettingImageView::GetClassName() const {
   return "ContentSettingsImageView";
 }
 
 void ContentSettingImageView::OnBoundsChanged(
     const gfx::Rect& previous_bounds) {
   if (bubble_view_)
     bubble_view_->OnAnchorBoundsChanged();
 }
 
 bool ContentSettingImageView::OnMousePressed(const ui::MouseEvent& event) {
   // If the bubble is showing then don't reshow it when the mouse is released.
   suppress_mouse_released_action_ = bubble_view_ != nullptr;
   if (!suppress_mouse_released_action_ && !label()->visible())
-    ink_drop_delegate()->OnAction(views::InkDropState::ACTION_PENDING);
+    AnimateInkDrop(views::InkDropState::ACTION_PENDING);
 
   // We want to show the bubble on mouse release; that is the standard behavior
   // for buttons.
   return true;
 }
 
 void ContentSettingImageView::OnMouseReleased(const ui::MouseEvent& event) {
   // If this is the second click on this view then the bubble was showing on the
   // mouse pressed event and is hidden now. Prevent the bubble from reshowing by
   // doing nothing here.
   if (suppress_mouse_released_action_) {
     suppress_mouse_released_action_ = false;
     return;
   }
   const bool activated = HitTestPoint(event.location());
   if (!label()->visible() && !activated)
-    ink_drop_delegate()->OnAction(views::InkDropState::HIDDEN);
+    AnimateInkDrop(views::InkDropState::HIDDEN);
   if (activated)
     OnActivate();
 }
 
 void ContentSettingImageView::OnGestureEvent(ui::GestureEvent* event) {
   if (event->type() == ui::ET_GESTURE_TAP)
     OnActivate();
   if ((event->type() == ui::ET_GESTURE_TAP) ||
       (event->type() == ui::ET_GESTURE_TAP_DOWN))
     event->SetHandled();
@@ skipping 73 matching lines @@
                 web_contents, this, views::BubbleBorder::TOP_RIGHT);
     views::Widget* bubble_widget =
         views::BubbleDialogDelegateView::CreateBubble(bubble_view_);
     bubble_widget->AddObserver(this);
     // This is triggered by an input event. If the user clicks the icon while
     // it's not animating, the icon will be placed in an active state, so the
     // bubble doesn't need an arrow. If the user clicks during an animation,
     // the animation simply pauses and no other visible state change occurs, so
     // show the arrow in this case.
     if (ui::MaterialDesignController::IsModeMaterial() && !pause_animation_) {
-      ink_drop_delegate()->OnAction(views::InkDropState::ACTIVATED);
+      AnimateInkDrop(views::InkDropState::ACTIVATED);
       bubble_view_->SetArrowPaintType(views::BubbleBorder::PAINT_TRANSPARENT);
     }
     bubble_widget->Show();
   }
 
   return true;
 }
 
 void ContentSettingImageView::AnimationEnded(const gfx::Animation* animation) {
   slide_animator_.Reset();
@@ skipping 27 matching lines @@
     slide_animator_.Reset(pause_animation_state_);
     pause_animation_ = false;
     slide_animator_.Show();
   }
 }
 
 void ContentSettingImageView::OnWidgetVisibilityChanged(views::Widget* widget,
                                                         bool visible) {
   // |widget| is a bubble that has just got shown / hidden.
   if (!visible && !label()->visible())
-    ink_drop_delegate()->OnAction(views::InkDropState::DEACTIVATED);
+    AnimateInkDrop(views::InkDropState::DEACTIVATED);
 }
 
 void ContentSettingImageView::UpdateImage() {
   SetImage(content_setting_image_model_->GetIcon(GetTextColor()).AsImageSkia());
   image()->SetTooltipText(content_setting_image_model_->get_tooltip());
 }