[ash-md] Added different highlighting modes to the InkDropImpl.

ui/views/animation/ink_drop_host_view.cc

 // Copyright 2016 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/animation/ink_drop_host_view.h"
 
+#include "base/memory/ptr_util.h"
 #include "ui/events/event.h"
 #include "ui/events/scoped_target_handler.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/views/animation/ink_drop.h"
 #include "ui/views/animation/ink_drop_highlight.h"
 #include "ui/views/animation/ink_drop_impl.h"
 #include "ui/views/animation/ink_drop_stub.h"
 #include "ui/views/animation/square_ink_drop_ripple.h"
 
 namespace views {
 namespace {
 
-// Default sizes for ink drop effects.
+// Size used for the default SquareInkDropRipple.
 const int kInkDropSize = 24;
-const int kInkDropLargeCornerRadius = 4;
 
-// The scale factor to compute the large ink drop size.
+// The scale factor to compute the large size of the default
+// SquareInkDropRipple.
 const float kLargeInkDropScale = 1.333f;
 
 // Default opacity of the ink drop when it is visible.
 const float kInkDropVisibleOpacity = 0.175f;
 
-gfx::Size CalculateLargeInkDropSize(const gfx::Size small_size) {
-  return gfx::ScaleToCeiledSize(gfx::Size(small_size), kLargeInkDropScale);
-}
-
 }  // namespace
 
 // static
 const int InkDropHostView::kInkDropSmallCornerRadius = 2;
+const int InkDropHostView::kInkDropLargeCornerRadius = 4;
 
 // An EventHandler that is guaranteed to be invoked and is not prone to
 // InkDropHostView descendents who do not call
 // InkDropHostView::OnGestureEvent().  Only one instance of this class can exist
 // at any given time for each ink drop host view.
 //
 // TODO(bruthig): Consider getting rid of this class.
 class InkDropHostView::InkDropGestureHandler : public ui::EventHandler {
  public:
   explicit InkDropGestureHandler(InkDropHostView* host_view)
@@ skipping 51 matching lines @@
  private:
   // Allows |this| to handle all GestureEvents on |host_view_|.
   std::unique_ptr<ui::ScopedTargetHandler> target_handler_;
 
   // The host view to cache ui::Events to when animating the ink drop.
   InkDropHostView* host_view_;
 
   DISALLOW_COPY_AND_ASSIGN(InkDropGestureHandler);
 };
 
+// static
+
+gfx::Size InkDropHostView::CalculateLargeInkDropSize(
+    const gfx::Size& small_size) {
+  return gfx::ScaleToCeiledSize(gfx::Size(small_size), kLargeInkDropScale);
+}
+
 InkDropHostView::InkDropHostView()
     : ink_drop_mode_(InkDropMode::OFF),
       ink_drop_(nullptr),
-      ink_drop_size_(kInkDropSize, kInkDropSize),
       ink_drop_visible_opacity_(kInkDropVisibleOpacity),
       old_paint_to_layer_(false),
       destroying_(false) {}
 
 InkDropHostView::~InkDropHostView() {
   // TODO(bruthig): Improve InkDropImpl to be safer about calling back to
   // potentially destroyed InkDropHosts and remove |destroying_|.
   destroying_ = true;
 }
 
 void InkDropHostView::AddInkDropLayer(ui::Layer* ink_drop_layer) {
   old_paint_to_layer_ = layer() != nullptr;
   SetPaintToLayer(true);
   layer()->SetFillsBoundsOpaquely(false);
   layer()->Add(ink_drop_layer);
   layer()->StackAtBottom(ink_drop_layer);
 }
 
 void InkDropHostView::RemoveInkDropLayer(ui::Layer* ink_drop_layer) {
   // No need to do anything when called during shutdown, and if a derived
   // class has overridden Add/RemoveInkDropLayer, running this implementation
   // would be wrong.
   if (destroying_)
     return;
   layer()->Remove(ink_drop_layer);
   SetPaintToLayer(old_paint_to_layer_);
 }
 
+std::unique_ptr<InkDrop> InkDropHostView::CreateInkDrop() {
+  return CreateDefaultInkDropImpl();
+}
+
 std::unique_ptr<InkDropRipple> InkDropHostView::CreateInkDropRipple() const {
   return CreateDefaultInkDropRipple(GetLocalBounds().CenterPoint());
 }
 
 std::unique_ptr<InkDropHighlight> InkDropHostView::CreateInkDropHighlight()
     const {
   return CreateDefaultInkDropHighlight(
       gfx::RectF(GetLocalBounds()).CenterPoint());
 }
 
 std::unique_ptr<InkDropRipple> InkDropHostView::CreateDefaultInkDropRipple(
     const gfx::Point& center_point) const {
+  const gfx::Size small_size(kInkDropSize, kInkDropSize);
   std::unique_ptr<InkDropRipple> ripple(new SquareInkDropRipple(
-      CalculateLargeInkDropSize(ink_drop_size_), kInkDropLargeCornerRadius,
-      ink_drop_size_, kInkDropSmallCornerRadius, center_point,
+      CalculateLargeInkDropSize(small_size), kInkDropLargeCornerRadius,
+      small_size, kInkDropSmallCornerRadius, center_point,
       GetInkDropBaseColor(), ink_drop_visible_opacity()));
   return ripple;
 }
 
 std::unique_ptr<InkDropHighlight>
 InkDropHostView::CreateDefaultInkDropHighlight(
     const gfx::PointF& center_point) const {
+  const gfx::Size small_size(kInkDropSize, kInkDropSize);
   std::unique_ptr<InkDropHighlight> highlight(
-      new InkDropHighlight(ink_drop_size_, kInkDropSmallCornerRadius,
-                           center_point, GetInkDropBaseColor()));
-  highlight->set_explode_size(CalculateLargeInkDropSize(ink_drop_size_));
+      new InkDropHighlight(small_size, kInkDropSmallCornerRadius, center_point,
+                           GetInkDropBaseColor()));
+  highlight->set_explode_size(CalculateLargeInkDropSize(small_size));
   return highlight;
 }
 
 void InkDropHostView::SetInkDropMode(InkDropMode ink_drop_mode) {
   ink_drop_mode_ = ink_drop_mode;
   ink_drop_ = nullptr;
 
   if (ink_drop_mode_ != InkDropMode::ON)
     gesture_handler_ = nullptr;
   else if (!gesture_handler_)
@@ skipping 27 matching lines @@
 void InkDropHostView::VisibilityChanged(View* starting_from, bool is_visible) {
   View::VisibilityChanged(starting_from, is_visible);
   if (GetWidget() && !is_visible) {
     GetInkDrop()->AnimateToState(InkDropState::HIDDEN);
     GetInkDrop()->SetHovered(false);
   }
 }
 
 void InkDropHostView::OnFocus() {
   views::View::OnFocus();
-  if (ShouldShowInkDropForFocus())
-    GetInkDrop()->SetFocused(true);
+  GetInkDrop()->SetFocused(true);
 }
 
 void InkDropHostView::OnBlur() {
   views::View::OnBlur();
-  if (ShouldShowInkDropForFocus())
-    GetInkDrop()->SetFocused(false);
+  GetInkDrop()->SetFocused(false);
 }
 
 void InkDropHostView::OnMouseEvent(ui::MouseEvent* event) {
   switch (event->type()) {
     case ui::ET_MOUSE_ENTERED:
       GetInkDrop()->SetHovered(true);
       break;
     case ui::ET_MOUSE_EXITED:
       GetInkDrop()->SetHovered(false);
       break;
+    case ui::ET_MOUSE_DRAGGED:
+      GetInkDrop()->SetHovered(GetLocalBounds().Contains(event->location()));
+      break;
     default:
       break;
   }
   View::OnMouseEvent(event);
 }
 
 SkColor InkDropHostView::GetInkDropBaseColor() const {
   NOTREACHED();
   return gfx::kPlaceholderColor;
 }
 
-bool InkDropHostView::ShouldShowInkDropForFocus() const {
-  return false;
-}
-
 InkDrop* InkDropHostView::GetInkDrop() {
   if (!ink_drop_) {
     if (ink_drop_mode_ == InkDropMode::OFF)
       ink_drop_ = base::MakeUnique<InkDropStub>();
     else
-      ink_drop_ = base::MakeUnique<InkDropImpl>(this);
+      ink_drop_ = CreateInkDrop();
   }
   return ink_drop_.get();
 }
 
+std::unique_ptr<InkDropImpl> InkDropHostView::CreateDefaultInkDropImpl() {
+  std::unique_ptr<InkDropImpl> ink_drop = base::MakeUnique<InkDropImpl>(this);
+  ink_drop->SetAutoHighlightMode(
+      views::InkDropImpl::AutoHighlightMode::HIDE_ON_RIPPLE);
+  return ink_drop;
+}
+
+std::unique_ptr<InkDropImpl>
+InkDropHostView::CreateDefaultFloodFillInkDropImpl() {
+  std::unique_ptr<views::InkDropImpl> ink_drop =
+      InkDropHostView::CreateDefaultInkDropImpl();
+  ink_drop->SetAutoHighlightMode(
+      views::InkDropImpl::AutoHighlightMode::SHOW_ON_RIPPLE);
+  return ink_drop;
+}
+
 }  // namespace views