Moved ButtonInkDropDelegate logic into InkDropHostView and deleted InkDropDelegates.

ui/views/controls/button/menu_button_unittest.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 "ui/views/controls/button/menu_button.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/events/test/event_generator.h"
-#include "ui/views/animation/test/test_ink_drop_delegate.h"
+#include "ui/views/animation/test/ink_drop_host_view_test_api.h"
+#include "ui/views/animation/test/test_ink_drop.h"
 #include "ui/views/controls/button/menu_button_listener.h"
 #include "ui/views/drag_controller.h"
 #include "ui/views/test/views_test_base.h"
 
 #if defined(USE_AURA)
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/wm/public/drag_drop_client.h"
 #endif
 
 using base::ASCIIToUTF16;
 
 namespace views {
-class InkDropDelegate;
 
-namespace test {
+using test::InkDropHostViewTestApi;
+using test::TestInkDrop;
 
 // A MenuButton subclass that provides access to some MenuButton internals.
 class TestMenuButton : public MenuButton {
  public:
   explicit TestMenuButton(MenuButtonListener* menu_button_listener)
       : MenuButton(base::string16(ASCIIToUTF16("button")),
                    menu_button_listener,
                    false) {}
 
   ~TestMenuButton() override {}
 
-  // Accessors to protected MenuButton methods.
-  void set_ink_drop_delegate(
-      std::unique_ptr<InkDropDelegate> ink_drop_delegate) {
-    InkDropHostView::set_ink_drop_delegate(std::move(ink_drop_delegate));
+  void SetInkDrop(std::unique_ptr<InkDrop> ink_drop) {
+    InkDropHostViewTestApi(this).SetInkDrop(std::move(ink_drop));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestMenuButton);
 };
 
 class MenuButtonTest : public ViewsTestBase {
  public:
-  MenuButtonTest() : widget_(nullptr), button_(nullptr) {}
+  MenuButtonTest() : widget_(nullptr), button_(nullptr), ink_drop_(nullptr) {}
   ~MenuButtonTest() override {}
 
   void TearDown() override {
     generator_.reset();
     if (widget_ && !widget_->IsClosed())
       widget_->Close();
 
     ViewsTestBase::TearDown();
   }
 
   Widget* widget() { return widget_; }
   TestMenuButton* button() { return button_; }
   ui::test::EventGenerator* generator() { return generator_.get(); }
 
  protected:
+  TestInkDrop* ink_drop() { return ink_drop_; }
+
   // Creates a MenuButton with no button listener.
   void CreateMenuButtonWithNoListener() { CreateMenuButton(nullptr); }
 
   // Creates a MenuButton with a MenuButtonListener. In this case, when the
   // MenuButton is pushed, it notifies the MenuButtonListener to open a
   // drop-down menu.
   void CreateMenuButtonWithMenuButtonListener(
       MenuButtonListener* menu_button_listener) {
     CreateMenuButton(menu_button_listener);
   }
 
+  void AttachInkDrop() {
+    ink_drop_ = new test::TestInkDrop();
+    test::InkDropHostViewTestApi(button_).SetInkDrop(
+        base::WrapUnique(ink_drop_));
+  }
+
  private:
   void CreateMenuButton(MenuButtonListener* menu_button_listener) {
     CreateWidget();
     generator_.reset(new ui::test::EventGenerator(GetContext(),
         widget_->GetNativeWindow()));
     // Set initial mouse location in a consistent way so that the menu button we
     // are about to create initializes its hover state in a consistent manner.
     generator_->set_current_location(gfx::Point(10, 10));
 
     button_ = new TestMenuButton(menu_button_listener);
@@ skipping 10 matching lines @@
     Widget::InitParams params =
         CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
     params.bounds = gfx::Rect(0, 0, 200, 200);
     widget_->Init(params);
   }
 
   Widget* widget_;
   TestMenuButton* button_;
   std::unique_ptr<ui::test::EventGenerator> generator_;
 
+  // Weak ptr, |button_| owns the instance.
+  TestInkDrop* ink_drop_;
+
   DISALLOW_COPY_AND_ASSIGN(MenuButtonTest);
 };
 
 class TestButtonListener : public ButtonListener {
  public:
   TestButtonListener()
       : last_sender_(nullptr),
         last_sender_state_(Button::STATE_NORMAL),
         last_event_type_(ui::ET_UNKNOWN) {}
   ~TestButtonListener() override {}
@@ skipping 305 matching lines @@
   generator()->PressLeftButton();
   EXPECT_EQ(nullptr, menu_button_listener.last_source());
 
   generator()->ReleaseLeftButton();
   EXPECT_EQ(button(), menu_button_listener.last_source());
   EXPECT_EQ(Button::STATE_HOVERED, menu_button_listener.last_source_state());
 }
 
 TEST_F(MenuButtonTest, InkDropStateForMenuButtonActivationsWithoutListener) {
   CreateMenuButtonWithNoListener();
-  TestInkDropDelegate* ink_drop_delegate = new TestInkDropDelegate();
-  ink_drop_delegate->OnAction(InkDropState::ACTION_PENDING);
-  button()->set_ink_drop_delegate(base::WrapUnique(ink_drop_delegate));
+  AttachInkDrop();
+  ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
   button()->Activate(nullptr);
 
-  EXPECT_EQ(InkDropState::HIDDEN, ink_drop_delegate->GetTargetInkDropState());
+  EXPECT_EQ(InkDropState::HIDDEN, ink_drop()->GetTargetInkDropState());
 }
 
 TEST_F(MenuButtonTest,
        InkDropStateForMenuButtonActivationsWithListenerThatDoesntAcquireALock) {
   TestMenuButtonListener menu_button_listener;
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
-  TestInkDropDelegate* ink_drop_delegate = new TestInkDropDelegate();
-  button()->set_ink_drop_delegate(base::WrapUnique(ink_drop_delegate));
+  AttachInkDrop();
   button()->Activate(nullptr);
 
   EXPECT_EQ(InkDropState::ACTION_TRIGGERED,
-            ink_drop_delegate->GetTargetInkDropState());
+            ink_drop()->GetTargetInkDropState());
 }
 
 TEST_F(
     MenuButtonTest,
     InkDropStateForMenuButtonActivationsWithListenerThatDontReleaseAllLocks) {
   PressStateMenuButtonListener menu_button_listener(false);
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
+  AttachInkDrop();
   menu_button_listener.set_menu_button(button());
-  TestInkDropDelegate* ink_drop_delegate = new TestInkDropDelegate();
-  button()->set_ink_drop_delegate(base::WrapUnique(ink_drop_delegate));
   button()->Activate(nullptr);
 
-  EXPECT_EQ(InkDropState::ACTIVATED,
-            ink_drop_delegate->GetTargetInkDropState());
+  EXPECT_EQ(InkDropState::ACTIVATED, ink_drop()->GetTargetInkDropState());
 }
 
 TEST_F(MenuButtonTest,
        InkDropStateForMenuButtonActivationsWithListenerThatReleaseAllLocks) {
   PressStateMenuButtonListener menu_button_listener(true);
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
   menu_button_listener.set_menu_button(button());
-  TestInkDropDelegate* ink_drop_delegate = new TestInkDropDelegate();
-  button()->set_ink_drop_delegate(base::WrapUnique(ink_drop_delegate));
+  AttachInkDrop();
   button()->Activate(nullptr);
 
-  EXPECT_EQ(InkDropState::DEACTIVATED,
-            ink_drop_delegate->GetTargetInkDropState());
+  EXPECT_EQ(InkDropState::DEACTIVATED, ink_drop()->GetTargetInkDropState());
 }
 
 TEST_F(MenuButtonTest, InkDropStateForMenuButtonsWithPressedLocks) {
   CreateMenuButtonWithNoListener();
-  TestInkDropDelegate* ink_drop_delegate = new TestInkDropDelegate();
-  button()->set_ink_drop_delegate(base::WrapUnique(ink_drop_delegate));
+  AttachInkDrop();
 
   std::unique_ptr<MenuButton::PressedLock> pressed_lock1(
       new MenuButton::PressedLock(button()));
 
-  EXPECT_EQ(InkDropState::ACTIVATED,
-            ink_drop_delegate->GetTargetInkDropState());
+  EXPECT_EQ(InkDropState::ACTIVATED, ink_drop()->GetTargetInkDropState());
 
   std::unique_ptr<MenuButton::PressedLock> pressed_lock2(
       new MenuButton::PressedLock(button()));
 
-  EXPECT_EQ(InkDropState::ACTIVATED,
-            ink_drop_delegate->GetTargetInkDropState());
+  EXPECT_EQ(InkDropState::ACTIVATED, ink_drop()->GetTargetInkDropState());
 
   pressed_lock1.reset();
-  EXPECT_EQ(InkDropState::ACTIVATED,
-            ink_drop_delegate->GetTargetInkDropState());
+  EXPECT_EQ(InkDropState::ACTIVATED, ink_drop()->GetTargetInkDropState());
 
   pressed_lock2.reset();
-  EXPECT_EQ(InkDropState::DEACTIVATED,
-            ink_drop_delegate->GetTargetInkDropState());
+  EXPECT_EQ(InkDropState::DEACTIVATED, ink_drop()->GetTargetInkDropState());
 }
 
 // Verifies only one ink drop animation is triggered when multiple PressedLocks
 // are attached to a MenuButton.
 TEST_F(MenuButtonTest, OneInkDropAnimationForReentrantPressedLocks) {
   CreateMenuButtonWithNoListener();
-  TestInkDropDelegate* ink_drop_delegate = new TestInkDropDelegate();
-  button()->set_ink_drop_delegate(base::WrapUnique(ink_drop_delegate));
+  AttachInkDrop();
 
   std::unique_ptr<MenuButton::PressedLock> pressed_lock1(
       new MenuButton::PressedLock(button()));
 
-  EXPECT_EQ(InkDropState::ACTIVATED,
-            ink_drop_delegate->GetTargetInkDropState());
-  ink_drop_delegate->OnAction(InkDropState::ACTION_PENDING);
+  EXPECT_EQ(InkDropState::ACTIVATED, ink_drop()->GetTargetInkDropState());
+  ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
 
   std::unique_ptr<MenuButton::PressedLock> pressed_lock2(
       new MenuButton::PressedLock(button()));
 
-  EXPECT_EQ(InkDropState::ACTION_PENDING,
-            ink_drop_delegate->GetTargetInkDropState());
+  EXPECT_EQ(InkDropState::ACTION_PENDING, ink_drop()->GetTargetInkDropState());
 }
 
 // Verifies the InkDropState is left as ACTIVATED if a PressedLock is active
 // before another Activation occurs.
 TEST_F(MenuButtonTest,
        InkDropStateForMenuButtonWithPressedLockBeforeActivation) {
   TestMenuButtonListener menu_button_listener;
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
-  TestInkDropDelegate* ink_drop_delegate = new TestInkDropDelegate();
-  button()->set_ink_drop_delegate(base::WrapUnique(ink_drop_delegate));
+  AttachInkDrop();
   MenuButton::PressedLock lock(button());
 
   button()->Activate(nullptr);
 
-  EXPECT_EQ(InkDropState::ACTIVATED,
-            ink_drop_delegate->GetTargetInkDropState());
+  EXPECT_EQ(InkDropState::ACTIVATED, ink_drop()->GetTargetInkDropState());
 }
 
 #if defined(USE_AURA)
 
 // Tests that the MenuButton does not become pressed if it can be dragged, and a
 // DragDropClient is processing the events.
 TEST_F(MenuButtonTest, DraggableMenuButtonDoesNotActivateOnDrag) {
   TestMenuButtonListener menu_button_listener;
   CreateMenuButtonWithMenuButtonListener(&menu_button_listener);
   TestDragController drag_controller;
@@ skipping 57 matching lines @@
 
   generator()->MoveTouch(gfx::Point(10, 30));
   generator()->ReleaseTouch();
   EXPECT_EQ(Button::STATE_NORMAL, button()->state());
   EXPECT_EQ(nullptr, menu_button_listener.last_source());
 }
 
 #endif  // !defined(OS_MACOSX) || defined(USE_AURA)
 
 }  // namespace views
-}  // namespace test