Tweaks to "Allow InkDropRipple to co-exist with highlight or not exist at all."

ui/views/animation/ink_drop_ripple_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.
 
 #include "ui/views/animation/ink_drop_ripple.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/views/animation/flood_fill_ink_drop_ripple.h"
 #include "ui/views/animation/ink_drop_ripple_observer.h"
 #include "ui/views/animation/ink_drop_state.h"
 #include "ui/views/animation/square_ink_drop_ripple.h"
+#include "ui/views/animation/test/empty_ink_drop_ripple_test_api.h"
 #include "ui/views/animation/test/flood_fill_ink_drop_ripple_test_api.h"
 #include "ui/views/animation/test/ink_drop_ripple_test_api.h"
 #include "ui/views/animation/test/square_ink_drop_ripple_test_api.h"
 #include "ui/views/animation/test/test_ink_drop_ripple_observer.h"
 
 namespace views {
 namespace test {
 
 const float kVisibleOpacity = 0.175f;
 
 // Represents all the derivatives of the InkDropRipple class. To be used with
 // the InkDropRippleTest fixture to test all derviatives.
 enum InkDropRippleTestTypes {
   SQUARE_INK_DROP_RIPPLE,
-  FLOOD_FILL_INK_DROP_RIPPLE
+  FLOOD_FILL_INK_DROP_RIPPLE,
+  EMPTY_INK_DROP_RIPPLE,
 };
 
 // Test fixture for all InkDropRipple class derivatives.
 //
 // To add a new derivative:
-//    1. Add a value to the InkDropRippleTestTypes enum.
-//    2. Implement set up and tear down code for the new enum value in
-//       InkDropRippleTest() and
-//      ~InkDropRippleTest().
-//    3. Add the new enum value to the INSTANTIATE_TEST_CASE_P) Values list.
+//    1.  Add a value to the InkDropRippleTestTypes enum.
+//    2.  Implement set up and tear down code for the new enum value in
+//        InkDropRippleTest() and ~InkDropRippleTest().
+//    3a. If the new InkDropRipple type has animations with a duration then add
+//        the new enum value to the INSTANTIATE_TEST_CASE_P(InkDropRippleTest)
+//        Values list.
+//    3b. If the new InkDropRipple type doesn't have animations with a duration
+//        then add the new enum value to the
+//        INSTANTIATE_TEST_CASE_P(AnimationInkDropRippleTest) Values list.
 class InkDropRippleTest
     : public testing::TestWithParam<InkDropRippleTestTypes> {
  public:
   InkDropRippleTest();
   ~InkDropRippleTest() override;
 
  protected:
   TestInkDropRippleObserver observer_;
 
   std::unique_ptr<InkDropRipple> ink_drop_ripple_;
@@ skipping 16 matching lines @@
     }
     case FLOOD_FILL_INK_DROP_RIPPLE: {
       FloodFillInkDropRipple* flood_fill_ink_drop_ripple =
           new FloodFillInkDropRipple(gfx::Rect(0, 0, 10, 10), gfx::Point(),
                                      SK_ColorBLACK, kVisibleOpacity);
       ink_drop_ripple_.reset(flood_fill_ink_drop_ripple);
       test_api_.reset(
           new FloodFillInkDropRippleTestApi(flood_fill_ink_drop_ripple));
       break;
     }
+    case EMPTY_INK_DROP_RIPPLE:
+      EmptyInkDropRipple* empty_ink_drop_ripple = new EmptyInkDropRipple();
+      ink_drop_ripple_.reset(empty_ink_drop_ripple);
+      test_api_.reset(new EmptyInkDropRippleTestApi(empty_ink_drop_ripple));
+      break;
   }
   ink_drop_ripple_->set_observer(&observer_);
   observer_.set_ink_drop_ripple(ink_drop_ripple_.get());
   test_api_->SetDisableAnimationTimers(true);
 }
 
 InkDropRippleTest::~InkDropRippleTest() {}
 
 // Note: First argument is optional and intentionally left blank.
 // (it's a prefix for the generated test cases)
 INSTANTIATE_TEST_CASE_P(,
                         InkDropRippleTest,
                         testing::Values(SQUARE_INK_DROP_RIPPLE,
+                                        FLOOD_FILL_INK_DROP_RIPPLE,
+                                        EMPTY_INK_DROP_RIPPLE));
+
+// Provides a test fixture scope for all InkDropRipple flavors that have
+// animations with a duration.
+using AnimationInkDropRippleTest = InkDropRippleTest;
+
+// Note: First argument is optional and intentionally left blank.
+// (it's a prefix for the generated test cases)
+INSTANTIATE_TEST_CASE_P(,
+                        AnimationInkDropRippleTest,
+                        testing::Values(SQUARE_INK_DROP_RIPPLE,
                                         FLOOD_FILL_INK_DROP_RIPPLE));
 
 TEST_P(InkDropRippleTest, InitialStateAfterConstruction) {
   EXPECT_EQ(views::InkDropState::HIDDEN,
             ink_drop_ripple_->target_ink_drop_state());
 }
 
 // Verify no animations are used when animating from HIDDEN to HIDDEN.
-TEST_P(InkDropRippleTest, AnimateToHiddenFromInvisibleState) {
+TEST_P(AnimationInkDropRippleTest, AnimateToHiddenFromInvisibleState) {
   EXPECT_EQ(InkDropState::HIDDEN, ink_drop_ripple_->target_ink_drop_state());
 
   ink_drop_ripple_->AnimateToState(InkDropState::HIDDEN);
   EXPECT_EQ(1, observer_.last_animation_started_ordinal());
   EXPECT_EQ(2, observer_.last_animation_ended_ordinal());
   EXPECT_EQ(InkDropRipple::kHiddenOpacity, test_api_->GetCurrentOpacity());
   EXPECT_FALSE(ink_drop_ripple_->IsVisible());
 }
 
-TEST_P(InkDropRippleTest, AnimateToHiddenFromVisibleState) {
+TEST_P(AnimationInkDropRippleTest, AnimateToHiddenFromVisibleState) {
   ink_drop_ripple_->AnimateToState(InkDropState::ACTION_PENDING);
   test_api_->CompleteAnimations();
   EXPECT_EQ(1, observer_.last_animation_started_ordinal());
   EXPECT_EQ(2, observer_.last_animation_ended_ordinal());
 
   EXPECT_NE(InkDropState::HIDDEN, ink_drop_ripple_->target_ink_drop_state());
 
   ink_drop_ripple_->AnimateToState(InkDropState::HIDDEN);
   test_api_->CompleteAnimations();
 
   EXPECT_EQ(3, observer_.last_animation_started_ordinal());
   EXPECT_EQ(4, observer_.last_animation_ended_ordinal());
   EXPECT_EQ(InkDropRipple::kHiddenOpacity, test_api_->GetCurrentOpacity());
 }
 
-TEST_P(InkDropRippleTest, ActionPendingOpacity) {
+TEST_P(AnimationInkDropRippleTest, ActionPendingOpacity) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   test_api_->CompleteAnimations();
 
   EXPECT_EQ(kVisibleOpacity, test_api_->GetCurrentOpacity());
 }
 
-TEST_P(InkDropRippleTest, QuickActionOpacity) {
+TEST_P(AnimationInkDropRippleTest, QuickActionOpacity) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_TRIGGERED);
   test_api_->CompleteAnimations();
 
   EXPECT_EQ(InkDropRipple::kHiddenOpacity, test_api_->GetCurrentOpacity());
 }
 
-TEST_P(InkDropRippleTest, SlowActionPendingOpacity) {
+TEST_P(AnimationInkDropRippleTest, SlowActionPendingOpacity) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   ink_drop_ripple_->AnimateToState(
       views::InkDropState::ALTERNATE_ACTION_PENDING);
   test_api_->CompleteAnimations();
 
   EXPECT_EQ(kVisibleOpacity, test_api_->GetCurrentOpacity());
 }
 
-TEST_P(InkDropRippleTest, SlowActionOpacity) {
+TEST_P(AnimationInkDropRippleTest, SlowActionOpacity) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   ink_drop_ripple_->AnimateToState(
       views::InkDropState::ALTERNATE_ACTION_PENDING);
   ink_drop_ripple_->AnimateToState(
       views::InkDropState::ALTERNATE_ACTION_TRIGGERED);
   test_api_->CompleteAnimations();
 
   EXPECT_EQ(InkDropRipple::kHiddenOpacity, test_api_->GetCurrentOpacity());
 }
 
-TEST_P(InkDropRippleTest, ActivatedOpacity) {
+TEST_P(AnimationInkDropRippleTest, ActivatedOpacity) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTIVATED);
   test_api_->CompleteAnimations();
 
   EXPECT_EQ(kVisibleOpacity, test_api_->GetCurrentOpacity());
 }
 
-TEST_P(InkDropRippleTest, DeactivatedOpacity) {
+TEST_P(AnimationInkDropRippleTest, DeactivatedOpacity) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTIVATED);
   ink_drop_ripple_->AnimateToState(views::InkDropState::DEACTIVATED);
   test_api_->CompleteAnimations();
 
   EXPECT_EQ(InkDropRipple::kHiddenOpacity, test_api_->GetCurrentOpacity());
 }
 
 // Verify animations are aborted during deletion and the
 // InkDropRippleObservers are notified.
-TEST_P(InkDropRippleTest, AnimationsAbortedDuringDeletion) {
+TEST_P(AnimationInkDropRippleTest, AnimationsAbortedDuringDeletion) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   ink_drop_ripple_.reset();
   EXPECT_EQ(1, observer_.last_animation_started_ordinal());
   EXPECT_EQ(2, observer_.last_animation_ended_ordinal());
   EXPECT_EQ(views::InkDropState::ACTION_PENDING,
             observer_.last_animation_ended_context());
   EXPECT_EQ(InkDropAnimationEndedReason::PRE_EMPTED,
             observer_.last_animation_ended_reason());
 }
 
 TEST_P(InkDropRippleTest, VerifyObserversAreNotified) {
   ink_drop_ripple_->AnimateToState(InkDropState::ACTION_PENDING);
 
+  test_api_->CompleteAnimations();
+
+  EXPECT_EQ(1, observer_.last_animation_started_ordinal());
+  EXPECT_EQ(InkDropState::ACTION_PENDING,
+            observer_.last_animation_started_context());
+
+  EXPECT_EQ(2, observer_.last_animation_ended_ordinal());
+  EXPECT_EQ(InkDropState::ACTION_PENDING,
+            observer_.last_animation_ended_context());
+}
+
+TEST_P(AnimationInkDropRippleTest,
+       VerifyAnimationEndedIsNotifiedAfterAnimations) {
+  ink_drop_ripple_->AnimateToState(InkDropState::ACTION_PENDING);
+
   EXPECT_TRUE(test_api_->HasActiveAnimations());
   EXPECT_EQ(1, observer_.last_animation_started_ordinal());
   EXPECT_TRUE(observer_.AnimationHasNotEnded());
   EXPECT_EQ(InkDropState::ACTION_PENDING,
             observer_.last_animation_started_context());
 
   test_api_->CompleteAnimations();
 
   EXPECT_FALSE(test_api_->HasActiveAnimations());
   EXPECT_EQ(1, observer_.last_animation_started_ordinal());
   EXPECT_EQ(2, observer_.last_animation_ended_ordinal());
   EXPECT_EQ(InkDropState::ACTION_PENDING,
             observer_.last_animation_ended_context());
 }
 
 TEST_P(InkDropRippleTest, VerifyObserversAreNotifiedOfSuccessfulAnimations) {
   ink_drop_ripple_->AnimateToState(InkDropState::ACTION_PENDING);
   test_api_->CompleteAnimations();
 
   EXPECT_EQ(2, observer_.last_animation_ended_ordinal());
   EXPECT_EQ(InkDropAnimationEndedReason::SUCCESS,
             observer_.last_animation_ended_reason());
 }
 
-TEST_P(InkDropRippleTest, VerifyObserversAreNotifiedOfPreemptedAnimations) {
+TEST_P(AnimationInkDropRippleTest,
+       VerifyObserversAreNotifiedOfPreemptedAnimations) {
   ink_drop_ripple_->AnimateToState(InkDropState::ACTION_PENDING);
   ink_drop_ripple_->AnimateToState(InkDropState::ALTERNATE_ACTION_PENDING);
 
   EXPECT_EQ(2, observer_.last_animation_ended_ordinal());
   EXPECT_EQ(InkDropAnimationEndedReason::PRE_EMPTED,
             observer_.last_animation_ended_reason());
 }
 
 TEST_P(InkDropRippleTest, InkDropStatesPersistWhenCallingAnimateToState) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTIVATED);
   EXPECT_EQ(views::InkDropState::ACTIVATED,
             ink_drop_ripple_->target_ink_drop_state());
 }
 
-TEST_P(InkDropRippleTest, HideImmediatelyWithoutActiveAnimations) {
+TEST_P(AnimationInkDropRippleTest, HideImmediatelyWithoutActiveAnimations) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   test_api_->CompleteAnimations();
   EXPECT_EQ(1, observer_.last_animation_started_ordinal());
   EXPECT_EQ(2, observer_.last_animation_ended_ordinal());
 
   EXPECT_FALSE(test_api_->HasActiveAnimations());
   EXPECT_NE(InkDropState::HIDDEN, ink_drop_ripple_->target_ink_drop_state());
 
   ink_drop_ripple_->HideImmediately();
 
   EXPECT_FALSE(test_api_->HasActiveAnimations());
   EXPECT_EQ(views::InkDropState::HIDDEN,
             ink_drop_ripple_->target_ink_drop_state());
   EXPECT_EQ(1, observer_.last_animation_started_ordinal());
   EXPECT_EQ(2, observer_.last_animation_ended_ordinal());
 
   EXPECT_EQ(InkDropRipple::kHiddenOpacity, test_api_->GetCurrentOpacity());
   EXPECT_FALSE(ink_drop_ripple_->IsVisible());
 }
 
 // Verifies all active animations are aborted and the InkDropState is set to
 // HIDDEN after invoking HideImmediately().
-TEST_P(InkDropRippleTest, HideImmediatelyWithActiveAnimations) {
+TEST_P(AnimationInkDropRippleTest, HideImmediatelyWithActiveAnimations) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   EXPECT_TRUE(test_api_->HasActiveAnimations());
   EXPECT_NE(InkDropState::HIDDEN, ink_drop_ripple_->target_ink_drop_state());
   EXPECT_EQ(1, observer_.last_animation_started_ordinal());
 
   ink_drop_ripple_->HideImmediately();
 
   EXPECT_FALSE(test_api_->HasActiveAnimations());
   EXPECT_EQ(views::InkDropState::HIDDEN,
             ink_drop_ripple_->target_ink_drop_state());
   EXPECT_EQ(1, observer_.last_animation_started_ordinal());
   EXPECT_EQ(2, observer_.last_animation_ended_ordinal());
   EXPECT_EQ(InkDropState::ACTION_PENDING,
             observer_.last_animation_ended_context());
   EXPECT_EQ(InkDropAnimationEndedReason::PRE_EMPTED,
             observer_.last_animation_ended_reason());
 
   EXPECT_EQ(InkDropRipple::kHiddenOpacity, test_api_->GetCurrentOpacity());
   EXPECT_FALSE(ink_drop_ripple_->IsVisible());
 }
 
-TEST_P(InkDropRippleTest, SnapToActivatedWithoutActiveAnimations) {
+TEST_P(AnimationInkDropRippleTest, SnapToActivatedWithoutActiveAnimations) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   test_api_->CompleteAnimations();
   EXPECT_EQ(1, observer_.last_animation_started_ordinal());
   EXPECT_EQ(2, observer_.last_animation_ended_ordinal());
 
   EXPECT_FALSE(test_api_->HasActiveAnimations());
   EXPECT_NE(InkDropState::ACTIVATED, ink_drop_ripple_->target_ink_drop_state());
 
   ink_drop_ripple_->SnapToActivated();
 
   EXPECT_FALSE(test_api_->HasActiveAnimations());
   EXPECT_EQ(views::InkDropState::ACTIVATED,
             ink_drop_ripple_->target_ink_drop_state());
   EXPECT_EQ(3, observer_.last_animation_started_ordinal());
   EXPECT_EQ(4, observer_.last_animation_ended_ordinal());
 
   EXPECT_EQ(kVisibleOpacity, test_api_->GetCurrentOpacity());
   EXPECT_TRUE(ink_drop_ripple_->IsVisible());
 }
 
 // Verifies all active animations are aborted and the InkDropState is set to
 // ACTIVATED after invoking SnapToActivated().
-TEST_P(InkDropRippleTest, SnapToActivatedWithActiveAnimations) {
+TEST_P(AnimationInkDropRippleTest, SnapToActivatedWithActiveAnimations) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   EXPECT_TRUE(test_api_->HasActiveAnimations());
   EXPECT_NE(InkDropState::ACTIVATED, ink_drop_ripple_->target_ink_drop_state());
   EXPECT_EQ(1, observer_.last_animation_started_ordinal());
 
   ink_drop_ripple_->SnapToActivated();
 
   EXPECT_FALSE(test_api_->HasActiveAnimations());
   EXPECT_EQ(views::InkDropState::ACTIVATED,
             ink_drop_ripple_->target_ink_drop_state());
   EXPECT_EQ(3, observer_.last_animation_started_ordinal());
   EXPECT_EQ(4, observer_.last_animation_ended_ordinal());
   EXPECT_EQ(InkDropState::ACTIVATED, observer_.last_animation_ended_context());
   EXPECT_EQ(InkDropAnimationEndedReason::SUCCESS,
             observer_.last_animation_ended_reason());
 
   EXPECT_EQ(kVisibleOpacity, test_api_->GetCurrentOpacity());
   EXPECT_TRUE(ink_drop_ripple_->IsVisible());
 }
 
-TEST_P(InkDropRippleTest, AnimateToVisibleFromHidden) {
+TEST_P(AnimationInkDropRippleTest, AnimateToVisibleFromHidden) {
   EXPECT_EQ(InkDropState::HIDDEN, ink_drop_ripple_->target_ink_drop_state());
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   EXPECT_TRUE(ink_drop_ripple_->IsVisible());
 }
 
 // Verifies that the value of InkDropRipple::target_ink_drop_state() returns
 // the most recent value passed to AnimateToState() when notifying observers
 // that an animation has started within the AnimateToState() function call.
-TEST_P(InkDropRippleTest, TargetInkDropStateOnAnimationStarted) {
+TEST_P(AnimationInkDropRippleTest, TargetInkDropStateOnAnimationStarted) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   ink_drop_ripple_->AnimateToState(views::InkDropState::HIDDEN);
 
   EXPECT_EQ(3, observer_.last_animation_started_ordinal());
   EXPECT_EQ(views::InkDropState::HIDDEN,
             observer_.target_state_at_last_animation_started());
 }
 
 // Verifies that the value of InkDropRipple::target_ink_drop_state() returns
 // the most recent value passed to AnimateToState() when notifying observers
 // that an animation has ended within the AnimateToState() function call.
-TEST_P(InkDropRippleTest, TargetInkDropStateOnAnimationEnded) {
+TEST_P(AnimationInkDropRippleTest, TargetInkDropStateOnAnimationEnded) {
   ink_drop_ripple_->AnimateToState(views::InkDropState::ACTION_PENDING);
   ink_drop_ripple_->AnimateToState(views::InkDropState::HIDDEN);
 
   EXPECT_EQ(2, observer_.last_animation_ended_ordinal());
   EXPECT_EQ(views::InkDropState::HIDDEN,
             observer_.target_state_at_last_animation_ended());
 }
 
 }  // namespace test
 }  // namespace views