Added material design mouse hover feedback support.

ui/views/animation/ink_drop_animation_controller_factory_unittest.cc

 // Copyright 2015 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.
 
 #ifndef UI_VIEWS_ANIMATION_INK_DROP_ANIMATION_CONTROLLER_FACTORY_UNITTEST_H_
 #define UI_VIEWS_ANIMATION_INK_DROP_ANIMATION_CONTROLLER_FACTORY_UNITTEST_H_
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/timer/mock_timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/test/material_design_controller_test_api.h"
+#include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/views/animation/ink_drop_animation_controller.h"
 #include "ui/views/animation/ink_drop_animation_controller_factory.h"
+#include "ui/views/animation/ink_drop_animation_controller_impl.h"
 #include "ui/views/animation/ink_drop_host.h"
 #include "ui/views/animation/ink_drop_state.h"
+#include "ui/views/animation/test/test_ink_drop_consumer.h"
 #include "ui/views/animation/test/test_ink_drop_host.h"
 
 namespace views {
 
 // Macro that will execute |test_code| against all derivatives of the
 // InkDropAnimationController returned by the InkDropAnimationControllerFactory.
 #define TEST_ALL_INK_DROPS(test_name, test_code)           \
   TEST_F(InkDropAnimationControllerFactoryTest, test_name) \
   test_code TEST_F(MDInkDropAnimationControllerFactoryTest, test_name) test_code
 
 // Test fixture to test the non material design InkDropAnimationController.
 class InkDropAnimationControllerFactoryTest : public testing::Test {
  public:
   InkDropAnimationControllerFactoryTest() {}
   ~InkDropAnimationControllerFactoryTest() override {}
 
   // testing::Test:
   void SetUp() override;
   void TearDown() override;
 
  protected:
+  // Template function called during SetUp() that sets the
+  // MaterialDesignController::Mode.
+  virtual void SetMaterialMode();
+
+  // Template method called by SetUp() that can be used to configure the
+  // |ink_drop_animation_controller_| instance.
+  virtual void SetupInkDropAnimationController();
+
   // A dummy InkDropHost required to create an InkDropAnimationController.
   TestInkDropHost test_ink_drop_host_;
 
+  // A dummy InkDropConsumer required to create an InkDropAnimationController.
+  test::TestInkDropConsumer test_ink_drop_consumer_;
+
   // The InkDropAnimationController returned by the
   // InkDropAnimationControllerFactory test target.
   scoped_ptr<InkDropAnimationController> ink_drop_animation_controller_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InkDropAnimationControllerFactoryTest);
 };
 
 void InkDropAnimationControllerFactoryTest::SetUp() {
   // Any call by a previous test to MaterialDesignController::GetMode() will
   // initialize and cache the mode. This ensures that these tests will run from
   // a non-initialized state.
   ui::test::MaterialDesignControllerTestAPI::UninitializeMode();
 
+  SetMaterialMode();
+
   ink_drop_animation_controller_ =
       InkDropAnimationControllerFactory::CreateInkDropAnimationController(
-          &test_ink_drop_host_);
+          &test_ink_drop_host_, &test_ink_drop_consumer_);
+
+  SetupInkDropAnimationController();
 }
 
 void InkDropAnimationControllerFactoryTest::TearDown() {
   ui::test::MaterialDesignControllerTestAPI::UninitializeMode();
 }
 
+void InkDropAnimationControllerFactoryTest::SetMaterialMode() {
+  ui::test::MaterialDesignControllerTestAPI::SetMode(
+      ui::MaterialDesignController::NON_MATERIAL);
+}
+
+void InkDropAnimationControllerFactoryTest::SetupInkDropAnimationController() {}
+
 // Test fixture to test the material design InkDropAnimationController.
 class MDInkDropAnimationControllerFactoryTest
     : public InkDropAnimationControllerFactoryTest {
  public:
   MDInkDropAnimationControllerFactoryTest() {}
 
   // InkDropAnimationControllerFactoryTest:
   void SetUp() override;
 
+ protected:
+  // InkDropAnimationControllerFactoryTest:
+  void SetMaterialMode() override;
+  void SetupInkDropAnimationController() override;
+
  private:
+  scoped_ptr<ui::ScopedAnimationDurationScaleMode> zero_duration_mode_;
+
   DISALLOW_COPY_AND_ASSIGN(MDInkDropAnimationControllerFactoryTest);
 };
 
 void MDInkDropAnimationControllerFactoryTest::SetUp() {
-  ui::test::MaterialDesignControllerTestAPI::SetMode(
-      ui::MaterialDesignController::MATERIAL_NORMAL);
+  zero_duration_mode_.reset(new ui::ScopedAnimationDurationScaleMode(
+      ui::ScopedAnimationDurationScaleMode::ZERO_DURATION));
   InkDropAnimationControllerFactoryTest::SetUp();
 }
 
-TEST_ALL_INK_DROPS(StateIsHiddenInitially,
+void MDInkDropAnimationControllerFactoryTest::SetMaterialMode() {
+  ui::test::MaterialDesignControllerTestAPI::SetMode(
+      ui::MaterialDesignController::MATERIAL_NORMAL);
+}
+
+void MDInkDropAnimationControllerFactoryTest::
+    SetupInkDropAnimationController() {
+  InkDropAnimationControllerImpl* controller =
+      reinterpret_cast<InkDropAnimationControllerImpl*>(
+          ink_drop_animation_controller_.get());
+  controller->SetTimerForTest(new base::MockTimer(false, false));
+}
+
+TEST_ALL_INK_DROPS(InitialState,
                    {
+                     EXPECT_FALSE(ink_drop_animation_controller_->IsHovered());
                      EXPECT_EQ(
                          InkDropState::HIDDEN,
                          ink_drop_animation_controller_->GetInkDropState());
                    })
 
+TEST_ALL_INK_DROPS(SetHovered,
+                   {
+                     ink_drop_animation_controller_->SetHovered(true);
+                     EXPECT_TRUE(ink_drop_animation_controller_->IsHovered());
+
+                     ink_drop_animation_controller_->SetHovered(false);
+                     EXPECT_FALSE(ink_drop_animation_controller_->IsHovered());
+                   })
+
+TEST_ALL_INK_DROPS(HoveredStateAfterAnimateToState,
+                   {
+                     ink_drop_animation_controller_->SetHovered(true);
+                     ink_drop_animation_controller_->AnimateToState(
+                         InkDropState::QUICK_ACTION);
+
+                     EXPECT_FALSE(ink_drop_animation_controller_->IsHovered());
+                   })
+
 TEST_ALL_INK_DROPS(TypicalQuickAction,
                    {
                      ink_drop_animation_controller_->AnimateToState(
                          InkDropState::ACTION_PENDING);
                      ink_drop_animation_controller_->AnimateToState(
                          InkDropState::QUICK_ACTION);
                      EXPECT_EQ(
                          InkDropState::HIDDEN,
                          ink_drop_animation_controller_->GetInkDropState());
                    })
@@ skipping 55 matching lines @@
           InkDropState::SLOW_ACTION_PENDING);
       ink_drop_animation_controller_->AnimateToState(InkDropState::ACTIVATED);
       ink_drop_animation_controller_->AnimateToState(InkDropState::DEACTIVATED);
       EXPECT_EQ(InkDropState::HIDDEN,
                 ink_drop_animation_controller_->GetInkDropState());
     })
 
 }  // namespace views
 
 #endif  // UI_VIEWS_ANIMATION_INK_DROP_ANIMATION_CONTROLLER_FACTORY_UNITTEST_H_