ink_drop_impl_unittest.cc 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631
  1. // Copyright 2015 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include <memory>
  5. #include "ui/views/animation/ink_drop_impl.h"
  6. #include "base/bind.h"
  7. #include "base/test/gtest_util.h"
  8. #include "base/test/test_simple_task_runner.h"
  9. #include "base/threading/thread_task_runner_handle.h"
  10. #include "testing/gtest/include/gtest/gtest.h"
  11. #include "ui/compositor/layer.h"
  12. #include "ui/compositor/scoped_animation_duration_scale_mode.h"
  13. #include "ui/gfx/animation/animation.h"
  14. #include "ui/gfx/animation/animation_test_api.h"
  15. #include "ui/views/animation/ink_drop.h"
  16. #include "ui/views/animation/ink_drop_ripple.h"
  17. #include "ui/views/animation/test/ink_drop_impl_test_api.h"
  18. #include "ui/views/animation/test/test_ink_drop_host.h"
  19. #include "ui/views/test/views_test_base.h"
  20. namespace views {
  21. // NOTE: The InkDropImpl class is also tested by the InkDropFactoryTest tests.
  22. class InkDropImplTest : public testing::Test {
  23. public:
  24. explicit InkDropImplTest(InkDropImpl::AutoHighlightMode auto_highlight_mode =
  25. InkDropImpl::AutoHighlightMode::NONE);
  26. InkDropImplTest(const InkDropImplTest&) = delete;
  27. InkDropImplTest& operator=(const InkDropImplTest&) = delete;
  28. ~InkDropImplTest() override;
  29. protected:
  30. TestInkDropHost* ink_drop_host() { return &ink_drop_host_; }
  31. const TestInkDropHost* ink_drop_host() const { return &ink_drop_host_; }
  32. InkDropImpl* ink_drop() {
  33. return static_cast<InkDropImpl*>(
  34. InkDrop::Get(ink_drop_host())->GetInkDrop());
  35. }
  36. InkDropRipple* ink_drop_ripple() {
  37. return ink_drop()->ink_drop_ripple_.get();
  38. }
  39. InkDropHighlight* ink_drop_highlight() {
  40. return ink_drop()->highlight_.get();
  41. }
  42. test::InkDropImplTestApi* test_api() { return test_api_.get(); }
  43. // Runs all the pending tasks in |task_runner_|. This can be used to progress
  44. // timers. e.g. HideHighlightOnRippleHiddenState's
  45. // |highlight_after_ripple_timer_|.
  46. void RunPendingTasks();
  47. // Returns true if the ink drop layers have been added to |ink_drop_host_|.
  48. bool AreLayersAddedToHost() const;
  49. // Destroys the |ink_drop_| and associated |test_api_|.
  50. void DestroyInkDrop();
  51. // Used to control the tasks scheduled by the InkDropImpl's Timer.
  52. scoped_refptr<base::TestSimpleTaskRunner> task_runner_ =
  53. base::MakeRefCounted<base::TestSimpleTaskRunner>();
  54. // Required by base::Timer's.
  55. std::unique_ptr<base::ThreadTaskRunnerHandle> thread_task_runner_handle_ =
  56. std::make_unique<base::ThreadTaskRunnerHandle>(task_runner_);
  57. private:
  58. TestInkDropHost ink_drop_host_;
  59. // Allows privileged access to the the |ink_drop_highlight_|.
  60. std::unique_ptr<test::InkDropImplTestApi> test_api_;
  61. std::unique_ptr<base::AutoReset<gfx::Animation::RichAnimationRenderMode>>
  62. animation_mode_reset_ = gfx::AnimationTestApi::SetRichAnimationRenderMode(
  63. gfx::Animation::RichAnimationRenderMode::FORCE_DISABLED);
  64. };
  65. InkDropImplTest::InkDropImplTest(
  66. InkDropImpl::AutoHighlightMode auto_highlight_mode)
  67. : ink_drop_host_(auto_highlight_mode) {
  68. InkDrop::Get(ink_drop_host())->SetMode(views::InkDropHost::InkDropMode::ON);
  69. test_api_ = std::make_unique<test::InkDropImplTestApi>(ink_drop());
  70. ink_drop_host()->set_disable_timers_for_test(true);
  71. }
  72. InkDropImplTest::~InkDropImplTest() = default;
  73. void InkDropImplTest::RunPendingTasks() {
  74. task_runner_->RunPendingTasks();
  75. EXPECT_FALSE(task_runner_->HasPendingTask());
  76. }
  77. bool InkDropImplTest::AreLayersAddedToHost() const {
  78. return ink_drop_host()->num_ink_drop_layers() >= 1;
  79. }
  80. void InkDropImplTest::DestroyInkDrop() {
  81. test_api_.reset();
  82. InkDrop::Get(ink_drop_host())->SetMode(views::InkDropHost::InkDropMode::OFF);
  83. }
  84. // AutoHighlightMode parameterized test fixture.
  85. class InkDropImplAutoHighlightTest
  86. : public InkDropImplTest,
  87. public testing::WithParamInterface<
  88. testing::tuple<InkDropImpl::AutoHighlightMode>> {
  89. public:
  90. InkDropImplAutoHighlightTest();
  91. InkDropImplAutoHighlightTest(const InkDropImplAutoHighlightTest&) = delete;
  92. InkDropImplAutoHighlightTest& operator=(const InkDropImplAutoHighlightTest&) =
  93. delete;
  94. ~InkDropImplAutoHighlightTest() override;
  95. };
  96. InkDropImplAutoHighlightTest::InkDropImplAutoHighlightTest()
  97. : InkDropImplTest(testing::get<0>(GetParam())) {}
  98. InkDropImplAutoHighlightTest::~InkDropImplAutoHighlightTest() = default;
  99. ////////////////////////////////////////////////////////////////////////////////
  100. //
  101. // InkDropImpl tests
  102. //
  103. TEST_F(InkDropImplTest, ShouldHighlight) {
  104. ink_drop()->SetShowHighlightOnHover(false);
  105. ink_drop()->SetHovered(false);
  106. ink_drop()->SetShowHighlightOnFocus(false);
  107. ink_drop()->SetFocused(false);
  108. EXPECT_FALSE(test_api()->ShouldHighlight());
  109. ink_drop()->SetShowHighlightOnHover(true);
  110. ink_drop()->SetHovered(false);
  111. ink_drop()->SetShowHighlightOnFocus(false);
  112. ink_drop()->SetFocused(false);
  113. EXPECT_FALSE(test_api()->ShouldHighlight());
  114. ink_drop()->SetShowHighlightOnHover(false);
  115. ink_drop()->SetHovered(true);
  116. ink_drop()->SetShowHighlightOnFocus(false);
  117. ink_drop()->SetFocused(false);
  118. EXPECT_FALSE(test_api()->ShouldHighlight());
  119. ink_drop()->SetShowHighlightOnHover(false);
  120. ink_drop()->SetHovered(false);
  121. ink_drop()->SetShowHighlightOnFocus(true);
  122. ink_drop()->SetFocused(false);
  123. EXPECT_FALSE(test_api()->ShouldHighlight());
  124. ink_drop()->SetShowHighlightOnHover(false);
  125. ink_drop()->SetHovered(false);
  126. ink_drop()->SetShowHighlightOnFocus(false);
  127. ink_drop()->SetFocused(true);
  128. EXPECT_FALSE(test_api()->ShouldHighlight());
  129. ink_drop()->SetShowHighlightOnHover(true);
  130. ink_drop()->SetHovered(true);
  131. ink_drop()->SetShowHighlightOnFocus(false);
  132. ink_drop()->SetFocused(false);
  133. EXPECT_TRUE(test_api()->ShouldHighlight());
  134. ink_drop()->SetShowHighlightOnHover(false);
  135. ink_drop()->SetHovered(false);
  136. ink_drop()->SetShowHighlightOnFocus(true);
  137. ink_drop()->SetFocused(true);
  138. EXPECT_TRUE(test_api()->ShouldHighlight());
  139. test_api()->SetShouldHighlight(false);
  140. EXPECT_FALSE(test_api()->ShouldHighlight());
  141. test_api()->SetShouldHighlight(true);
  142. EXPECT_TRUE(test_api()->ShouldHighlight());
  143. }
  144. TEST_F(InkDropImplTest,
  145. VerifyInkDropLayersRemovedWhenPresentDuringDestruction) {
  146. test_api()->SetShouldHighlight(true);
  147. ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
  148. EXPECT_TRUE(AreLayersAddedToHost());
  149. DestroyInkDrop();
  150. EXPECT_FALSE(AreLayersAddedToHost());
  151. }
  152. // Test that (re-)hiding or un-hovering a hidden ink drop doesn't add layers.
  153. TEST_F(InkDropImplTest, AlwaysHiddenInkDropHasNoLayers) {
  154. EXPECT_FALSE(AreLayersAddedToHost());
  155. ink_drop()->AnimateToState(InkDropState::HIDDEN);
  156. EXPECT_FALSE(AreLayersAddedToHost());
  157. ink_drop()->SetHovered(false);
  158. EXPECT_FALSE(AreLayersAddedToHost());
  159. }
  160. TEST_F(InkDropImplTest, LayersRemovedFromHostAfterHighlight) {
  161. EXPECT_FALSE(AreLayersAddedToHost());
  162. test_api()->SetShouldHighlight(true);
  163. EXPECT_TRUE(AreLayersAddedToHost());
  164. test_api()->CompleteAnimations();
  165. test_api()->SetShouldHighlight(false);
  166. test_api()->CompleteAnimations();
  167. EXPECT_FALSE(AreLayersAddedToHost());
  168. }
  169. TEST_F(InkDropImplTest, LayersRemovedFromHostAfterInkDrop) {
  170. // TODO(bruthig): Re-enable! For some reason these tests fail on some win
  171. // trunk builds. See crbug.com/731811.
  172. if (!gfx::Animation::ShouldRenderRichAnimation())
  173. return;
  174. EXPECT_FALSE(AreLayersAddedToHost());
  175. ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
  176. EXPECT_TRUE(AreLayersAddedToHost());
  177. test_api()->CompleteAnimations();
  178. ink_drop()->AnimateToState(InkDropState::HIDDEN);
  179. EXPECT_TRUE(AreLayersAddedToHost());
  180. test_api()->CompleteAnimations();
  181. EXPECT_FALSE(AreLayersAddedToHost());
  182. }
  183. TEST_F(InkDropImplTest, LayersArentRemovedWhenPreemptingFadeOut) {
  184. EXPECT_FALSE(AreLayersAddedToHost());
  185. test_api()->SetShouldHighlight(true);
  186. EXPECT_TRUE(AreLayersAddedToHost());
  187. test_api()->CompleteAnimations();
  188. ink_drop()->SetHovered(false);
  189. EXPECT_TRUE(AreLayersAddedToHost());
  190. ink_drop()->SetHovered(true);
  191. EXPECT_TRUE(AreLayersAddedToHost());
  192. }
  193. TEST_F(InkDropImplTest,
  194. SettingHighlightStateDuringStateExitIsntAllowedDeathTest) {
  195. ::testing::FLAGS_gtest_death_test_style = "threadsafe";
  196. test::InkDropImplTestApi::SetStateOnExitHighlightState::Install(
  197. test_api()->state_factory());
  198. EXPECT_DCHECK_DEATH(
  199. test::InkDropImplTestApi::AccessFactoryOnExitHighlightState::Install(
  200. test_api()->state_factory()));
  201. // Need to set the |highlight_state_| directly because the
  202. // SetStateOnExitHighlightState will recursively try to set it during tear
  203. // down and cause a stack overflow.
  204. test_api()->SetHighlightState(nullptr);
  205. }
  206. // Verifies there are no use after free errors.
  207. TEST_F(InkDropImplTest,
  208. TearingDownHighlightStateThatAccessesTheStateFactoryIsSafe) {
  209. test::InkDropImplTestApi::AccessFactoryOnExitHighlightState::Install(
  210. test_api()->state_factory());
  211. test::InkDropImplTestApi::AccessFactoryOnExitHighlightState::Install(
  212. test_api()->state_factory());
  213. }
  214. // Tests that if during destruction, a ripple animation is successfully ended,
  215. // no crash happens (see https://crbug.com/663579).
  216. TEST_F(InkDropImplTest, SuccessfulAnimationEndedDuringDestruction) {
  217. // Start a ripple animation with non-zero duration.
  218. ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
  219. {
  220. // Start another ripple animation with zero duration that would be queued
  221. // until the previous one is finished/aborted.
  222. ui::ScopedAnimationDurationScaleMode duration_mode(
  223. ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);
  224. ink_drop()->AnimateToState(InkDropState::ACTION_TRIGGERED);
  225. }
  226. // Abort the first animation, so that the queued animation is started (and
  227. // finished immediately since it has zero duration). No crash should happen.
  228. DestroyInkDrop();
  229. }
  230. // Make sure the InkDropRipple and InkDropHighlight get recreated when the host
  231. // size changes (https:://crbug.com/899104).
  232. TEST_F(InkDropImplTest, RippleAndHighlightRecreatedOnSizeChange) {
  233. test_api()->SetShouldHighlight(true);
  234. ink_drop()->AnimateToState(InkDropState::ACTIVATED);
  235. EXPECT_EQ(1, ink_drop_host()->num_ink_drop_ripples_created());
  236. EXPECT_EQ(1, ink_drop_host()->num_ink_drop_highlights_created());
  237. EXPECT_EQ(ink_drop_host()->last_ink_drop_ripple(), ink_drop_ripple());
  238. EXPECT_EQ(ink_drop_host()->last_ink_drop_highlight(), ink_drop_highlight());
  239. const gfx::Rect bounds(5, 6, 7, 8);
  240. ink_drop_host()->SetBoundsRect(bounds);
  241. EXPECT_EQ(2, ink_drop_host()->num_ink_drop_ripples_created());
  242. EXPECT_EQ(2, ink_drop_host()->num_ink_drop_highlights_created());
  243. EXPECT_EQ(ink_drop_host()->last_ink_drop_ripple(), ink_drop_ripple());
  244. EXPECT_EQ(ink_drop_host()->last_ink_drop_highlight(), ink_drop_highlight());
  245. EXPECT_EQ(bounds.size(), ink_drop_ripple()->GetRootLayer()->size());
  246. EXPECT_EQ(bounds.size(), ink_drop_highlight()->layer()->size());
  247. }
  248. // Verifies that the host's GetHighlighted() method reflects the ink drop's
  249. // highlight state, and when the state changes the ink drop notifies the host.
  250. TEST_F(InkDropImplTest, HostTracksHighlightState) {
  251. bool callback_called = false;
  252. auto subscription =
  253. InkDrop::Get(ink_drop_host())
  254. ->AddHighlightedChangedCallback(base::BindRepeating(
  255. [](bool* called) { *called = true; }, &callback_called));
  256. EXPECT_FALSE(InkDrop::Get(ink_drop_host())->GetHighlighted());
  257. test_api()->SetShouldHighlight(true);
  258. EXPECT_TRUE(callback_called);
  259. EXPECT_TRUE(InkDrop::Get(ink_drop_host())->GetHighlighted());
  260. callback_called = false;
  261. test_api()->SetShouldHighlight(false);
  262. EXPECT_TRUE(callback_called);
  263. EXPECT_FALSE(InkDrop::Get(ink_drop_host())->GetHighlighted());
  264. }
  265. ////////////////////////////////////////////////////////////////////////////////
  266. //
  267. // Common AutoHighlightMode tests
  268. //
  269. using InkDropImplCommonAutoHighlightTest = InkDropImplAutoHighlightTest;
  270. // Note: First argument is optional and intentionally left blank.
  271. // (it's a prefix for the generated test cases)
  272. INSTANTIATE_TEST_SUITE_P(
  273. All,
  274. InkDropImplCommonAutoHighlightTest,
  275. testing::Values(InkDropImpl::AutoHighlightMode::NONE,
  276. InkDropImpl::AutoHighlightMode::HIDE_ON_RIPPLE,
  277. InkDropImpl::AutoHighlightMode::SHOW_ON_RIPPLE));
  278. // Verifies InkDropImplTestApi::SetShouldHighlight() works as expected.
  279. TEST_P(InkDropImplCommonAutoHighlightTest,
  280. ShouldHighlightCausesHighlightToBeVisible) {
  281. test_api()->SetShouldHighlight(true);
  282. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  283. test_api()->SetShouldHighlight(false);
  284. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  285. }
  286. TEST_P(InkDropImplCommonAutoHighlightTest,
  287. HighlightVisibilityForFocusAndHoverStates) {
  288. ink_drop()->SetShowHighlightOnHover(true);
  289. ink_drop()->SetShowHighlightOnFocus(true);
  290. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  291. ink_drop()->SetFocused(true);
  292. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  293. ink_drop()->SetHovered(false);
  294. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  295. ink_drop()->SetHovered(true);
  296. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  297. ink_drop()->SetFocused(false);
  298. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  299. ink_drop()->SetHovered(false);
  300. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  301. }
  302. ////////////////////////////////////////////////////////////////////////////////
  303. //
  304. // InkDropImpl::AutoHighlightMode::NONE specific tests
  305. //
  306. using InkDropImplNoAutoHighlightTest = InkDropImplAutoHighlightTest;
  307. // Note: First argument is optional and intentionally left blank.
  308. // (it's a prefix for the generated test cases)
  309. INSTANTIATE_TEST_SUITE_P(All,
  310. InkDropImplNoAutoHighlightTest,
  311. testing::Values(InkDropImpl::AutoHighlightMode::NONE));
  312. TEST_P(InkDropImplNoAutoHighlightTest, VisibleHighlightDuringRippleAnimations) {
  313. test_api()->SetShouldHighlight(true);
  314. ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
  315. test_api()->CompleteAnimations();
  316. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  317. ink_drop()->AnimateToState(InkDropState::HIDDEN);
  318. test_api()->CompleteAnimations();
  319. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  320. }
  321. TEST_P(InkDropImplNoAutoHighlightTest, HiddenHighlightDuringRippleAnimations) {
  322. test_api()->SetShouldHighlight(false);
  323. ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
  324. test_api()->CompleteAnimations();
  325. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  326. ink_drop()->AnimateToState(InkDropState::HIDDEN);
  327. test_api()->CompleteAnimations();
  328. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  329. }
  330. ////////////////////////////////////////////////////////////////////////////////
  331. //
  332. // InkDropImpl::AutoHighlightMode::HIDE_ON_RIPPLE specific tests
  333. //
  334. using InkDropImplHideAutoHighlightTest = InkDropImplAutoHighlightTest;
  335. // Note: First argument is optional and intentionally left blank.
  336. // (it's a prefix for the generated test cases)
  337. INSTANTIATE_TEST_SUITE_P(
  338. All,
  339. InkDropImplHideAutoHighlightTest,
  340. testing::Values(InkDropImpl::AutoHighlightMode::HIDE_ON_RIPPLE));
  341. TEST_P(InkDropImplHideAutoHighlightTest,
  342. VisibleHighlightDuringRippleAnimations) {
  343. test_api()->SetShouldHighlight(true);
  344. ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
  345. test_api()->CompleteAnimations();
  346. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  347. ink_drop()->AnimateToState(InkDropState::HIDDEN);
  348. test_api()->CompleteAnimations();
  349. RunPendingTasks();
  350. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  351. }
  352. TEST_P(InkDropImplHideAutoHighlightTest,
  353. HiddenHighlightDuringRippleAnimations) {
  354. test_api()->SetShouldHighlight(false);
  355. ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
  356. test_api()->CompleteAnimations();
  357. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  358. ink_drop()->AnimateToState(InkDropState::HIDDEN);
  359. test_api()->CompleteAnimations();
  360. RunPendingTasks();
  361. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  362. }
  363. TEST_P(InkDropImplHideAutoHighlightTest, HighlightIsHiddenOnSnapToActivated) {
  364. test_api()->SetShouldHighlight(true);
  365. ink_drop()->SnapToActivated();
  366. test_api()->CompleteAnimations();
  367. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  368. ink_drop()->AnimateToState(InkDropState::HIDDEN);
  369. test_api()->CompleteAnimations();
  370. RunPendingTasks();
  371. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  372. }
  373. TEST_P(InkDropImplHideAutoHighlightTest,
  374. HighlightDoesntFadeInAfterAnimationIfHighlightNotSet) {
  375. test_api()->SetShouldHighlight(true);
  376. ink_drop()->AnimateToState(InkDropState::ACTION_TRIGGERED);
  377. test_api()->CompleteAnimations();
  378. test_api()->SetShouldHighlight(false);
  379. ink_drop()->AnimateToState(InkDropState::HIDDEN);
  380. test_api()->CompleteAnimations();
  381. RunPendingTasks();
  382. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  383. }
  384. TEST_P(InkDropImplHideAutoHighlightTest,
  385. HighlightFadesInAfterAnimationIfHovered) {
  386. ink_drop()->SetShowHighlightOnHover(true);
  387. ink_drop()->SetHovered(true);
  388. ink_drop()->AnimateToState(InkDropState::ACTION_TRIGGERED);
  389. test_api()->CompleteAnimations();
  390. ink_drop()->AnimateToState(InkDropState::HIDDEN);
  391. test_api()->CompleteAnimations();
  392. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  393. EXPECT_TRUE(task_runner_->HasPendingTask());
  394. RunPendingTasks();
  395. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  396. }
  397. TEST_P(InkDropImplHideAutoHighlightTest,
  398. HighlightSnapsInAfterAnimationWhenHostIsFocused) {
  399. ink_drop()->SetShowHighlightOnFocus(true);
  400. ink_drop()->SetFocused(true);
  401. ink_drop()->AnimateToState(InkDropState::ACTION_TRIGGERED);
  402. test_api()->CompleteAnimations();
  403. ink_drop()->AnimateToState(InkDropState::HIDDEN);
  404. test_api()->CompleteAnimations();
  405. EXPECT_FALSE(task_runner_->HasPendingTask());
  406. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  407. }
  408. TEST_P(InkDropImplHideAutoHighlightTest, DeactivatedAnimatesWhenNotFocused) {
  409. // TODO(bruthig): Re-enable! For some reason these tests fail on some win
  410. // trunk builds. See crbug.com/731811.
  411. if (!gfx::Animation::ShouldRenderRichAnimation())
  412. return;
  413. test_api()->SetShouldHighlight(false);
  414. ink_drop()->AnimateToState(InkDropState::ACTIVATED);
  415. test_api()->CompleteAnimations();
  416. ink_drop()->AnimateToState(InkDropState::DEACTIVATED);
  417. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  418. EXPECT_TRUE(test_api()->HasActiveAnimations());
  419. }
  420. TEST_P(InkDropImplHideAutoHighlightTest,
  421. DeactivatedAnimationSkippedWhenFocused) {
  422. ink_drop()->SetShowHighlightOnFocus(true);
  423. ink_drop()->SetFocused(true);
  424. ink_drop()->AnimateToState(InkDropState::ACTIVATED);
  425. test_api()->CompleteAnimations();
  426. ink_drop()->AnimateToState(InkDropState::DEACTIVATED);
  427. EXPECT_TRUE(AreLayersAddedToHost());
  428. test_api()->CompleteAnimations();
  429. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  430. EXPECT_EQ(InkDropState::HIDDEN, ink_drop()->GetTargetInkDropState());
  431. }
  432. TEST_P(InkDropImplHideAutoHighlightTest,
  433. FocusAndHoverChangesDontShowHighlightWhenRippleIsVisible) {
  434. test_api()->SetShouldHighlight(true);
  435. ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
  436. test_api()->CompleteAnimations();
  437. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  438. ink_drop()->SetHovered(false);
  439. ink_drop()->SetFocused(false);
  440. ink_drop()->SetHovered(true);
  441. ink_drop()->SetFocused(true);
  442. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  443. EXPECT_TRUE(test_api()->ShouldHighlight());
  444. }
  445. // Verifies there is no crash when animations are started during the destruction
  446. // of the InkDropRipple. See https://crbug.com/663335.
  447. TEST_P(InkDropImplHideAutoHighlightTest, NoCrashDuringRippleTearDown) {
  448. ink_drop()->SetShowHighlightOnFocus(true);
  449. ink_drop()->SetFocused(true);
  450. ink_drop()->AnimateToState(InkDropState::ACTIVATED);
  451. ink_drop()->AnimateToState(InkDropState::DEACTIVATED);
  452. ink_drop()->AnimateToState(InkDropState::DEACTIVATED);
  453. DestroyInkDrop();
  454. }
  455. ////////////////////////////////////////////////////////////////////////////////
  456. //
  457. // InkDropImpl::AutoHighlightMode::SHOW_ON_RIPPLE specific tests
  458. //
  459. using InkDropImplShowAutoHighlightTest = InkDropImplAutoHighlightTest;
  460. // Note: First argument is optional and intentionally left blank.
  461. // (it's a prefix for the generated test cases)
  462. INSTANTIATE_TEST_SUITE_P(
  463. All,
  464. InkDropImplShowAutoHighlightTest,
  465. testing::Values(InkDropImpl::AutoHighlightMode::SHOW_ON_RIPPLE));
  466. TEST_P(InkDropImplShowAutoHighlightTest,
  467. VisibleHighlightDuringRippleAnimations) {
  468. test_api()->SetShouldHighlight(true);
  469. ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
  470. test_api()->CompleteAnimations();
  471. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  472. ink_drop()->AnimateToState(InkDropState::HIDDEN);
  473. test_api()->CompleteAnimations();
  474. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  475. }
  476. TEST_P(InkDropImplShowAutoHighlightTest,
  477. HiddenHighlightDuringRippleAnimations) {
  478. test_api()->SetShouldHighlight(false);
  479. ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
  480. test_api()->CompleteAnimations();
  481. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  482. ink_drop()->AnimateToState(InkDropState::HIDDEN);
  483. test_api()->CompleteAnimations();
  484. EXPECT_FALSE(test_api()->IsHighlightFadingInOrVisible());
  485. }
  486. TEST_P(InkDropImplShowAutoHighlightTest,
  487. FocusAndHoverChangesDontHideHighlightWhenRippleIsVisible) {
  488. test_api()->SetShouldHighlight(true);
  489. ink_drop()->AnimateToState(InkDropState::ACTION_PENDING);
  490. test_api()->CompleteAnimations();
  491. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  492. ink_drop()->SetHovered(false);
  493. ink_drop()->SetFocused(false);
  494. EXPECT_TRUE(test_api()->IsHighlightFadingInOrVisible());
  495. EXPECT_FALSE(test_api()->ShouldHighlight());
  496. }
  497. } // namespace views