[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 "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.
 const int kInkDropSize = 24;
-const int kInkDropLargeCornerRadius = 4;
 
 // The scale factor to compute the large ink drop size.
 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_(new InkDropStub()),
-      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 {
   std::unique_ptr<InkDropRipple> ripple(new SquareInkDropRipple(
-      CalculateLargeInkDropSize(ink_drop_size_), kInkDropLargeCornerRadius,
-      ink_drop_size_, kInkDropSmallCornerRadius, center_point,
-      GetInkDropBaseColor(), ink_drop_visible_opacity()));
+      CalculateLargeInkDropSize(gfx::Size(kInkDropSize, kInkDropSize)),
+      kInkDropLargeCornerRadius, gfx::Size(kInkDropSize, kInkDropSize),
+      kInkDropSmallCornerRadius, center_point, GetInkDropBaseColor(),
+      ink_drop_visible_opacity()));
   return ripple;
 }
 
 std::unique_ptr<InkDropHighlight>
 InkDropHostView::CreateDefaultInkDropHighlight(
     const gfx::PointF& center_point) const {
-  std::unique_ptr<InkDropHighlight> highlight(
-      new InkDropHighlight(ink_drop_size_, kInkDropSmallCornerRadius,
-                           center_point, GetInkDropBaseColor()));
-  highlight->set_explode_size(CalculateLargeInkDropSize(ink_drop_size_));
+  std::unique_ptr<InkDropHighlight> highlight(new InkDropHighlight(
+      gfx::Size(kInkDropSize, kInkDropSize), kInkDropSmallCornerRadius,
+      center_point, GetInkDropBaseColor()));
+  highlight->set_explode_size(
+      CalculateLargeInkDropSize(gfx::Size(kInkDropSize, kInkDropSize)));
   return highlight;
 }
 
 gfx::Point InkDropHostView::GetInkDropCenterBasedOnLastEvent() const {
   return last_ripple_triggering_event_
              ? last_ripple_triggering_event_->location()
              : GetLocalBounds().CenterPoint();
 }
 
 void InkDropHostView::AnimateInkDrop(InkDropState state,
@@ skipping 35 matching lines @@
 }
 
 void InkDropHostView::OnMouseEvent(ui::MouseEvent* event) {
   switch (event->type()) {
     case ui::ET_MOUSE_ENTERED:
       ink_drop_->SetHovered(true);
       break;
     case ui::ET_MOUSE_EXITED:
       ink_drop_->SetHovered(false);
       break;
+    case ui::ET_MOUSE_DRAGGED:
+      ink_drop_->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;
 }
 
 void InkDropHostView::SetInkDropMode(InkDropMode ink_drop_mode) {
   if (ink_drop_mode == InkDropMode::OFF)
     ink_drop_.reset(new InkDropStub());
   else
-    ink_drop_.reset(new InkDropImpl(this));
+    ink_drop_ = CreateInkDrop();
 
   if (ink_drop_mode != InkDropMode::ON)
     gesture_handler_.reset();
   else if (!gesture_handler_)
     gesture_handler_.reset(new InkDropGestureHandler(this));
 }
 
+std::unique_ptr<InkDropImpl> InkDropHostView::CreateDefaultInkDropImpl() {
+  std::unique_ptr<InkDropImpl> ink_drop(new InkDropImpl(this));

[sky, 2016/11/02 02:52:11]

MakeUnique.

[bruthig, 2016/11/04 18:50:36]

Done.

+  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