platform_event_source_unittest.cc 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697
  1. // Copyright 2014 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 "ui/events/platform/platform_event_source.h"
  5. #include <stddef.h>
  6. #include <stdint.h>
  7. #include <memory>
  8. #include <utility>
  9. #include <vector>
  10. #include "base/bind.h"
  11. #include "base/memory/raw_ptr.h"
  12. #include "base/run_loop.h"
  13. #include "base/task/single_thread_task_runner.h"
  14. #include "base/test/task_environment.h"
  15. #include "base/threading/thread_task_runner_handle.h"
  16. #include "testing/gtest/include/gtest/gtest.h"
  17. #include "ui/events/platform/platform_event_dispatcher.h"
  18. #include "ui/events/platform/platform_event_observer.h"
  19. #include "ui/events/platform/scoped_event_dispatcher.h"
  20. namespace ui {
  21. namespace {
  22. std::unique_ptr<PlatformEvent> CreatePlatformEvent() {
  23. std::unique_ptr<PlatformEvent> event = std::make_unique<PlatformEvent>();
  24. memset(event.get(), 0, sizeof(PlatformEvent));
  25. return event;
  26. }
  27. void RemoveDispatcher(PlatformEventDispatcher* dispatcher) {
  28. PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(dispatcher);
  29. }
  30. void RemoveDispatchers(PlatformEventDispatcher* first,
  31. PlatformEventDispatcher* second) {
  32. PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(first);
  33. PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(second);
  34. }
  35. void AddDispatcher(PlatformEventDispatcher* dispatcher) {
  36. PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(dispatcher);
  37. }
  38. } // namespace
  39. class TestPlatformEventSource : public PlatformEventSource {
  40. public:
  41. TestPlatformEventSource() = default;
  42. TestPlatformEventSource(const TestPlatformEventSource&) = delete;
  43. TestPlatformEventSource& operator=(const TestPlatformEventSource&) = delete;
  44. ~TestPlatformEventSource() override = default;
  45. uint32_t Dispatch(const PlatformEvent& event) { return DispatchEvent(event); }
  46. };
  47. class TestPlatformEventDispatcher : public PlatformEventDispatcher {
  48. public:
  49. TestPlatformEventDispatcher(int id, std::vector<int>* list)
  50. : id_(id),
  51. list_(list),
  52. post_dispatch_action_(POST_DISPATCH_NONE) {
  53. PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
  54. }
  55. TestPlatformEventDispatcher(const TestPlatformEventDispatcher&) = delete;
  56. TestPlatformEventDispatcher& operator=(const TestPlatformEventDispatcher&) =
  57. delete;
  58. ~TestPlatformEventDispatcher() override {
  59. PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
  60. }
  61. void set_post_dispatch_action(uint32_t action) {
  62. post_dispatch_action_ = action;
  63. }
  64. protected:
  65. // PlatformEventDispatcher:
  66. bool CanDispatchEvent(const PlatformEvent& event) override { return true; }
  67. uint32_t DispatchEvent(const PlatformEvent& event) override {
  68. list_->push_back(id_);
  69. return post_dispatch_action_;
  70. }
  71. private:
  72. int id_;
  73. raw_ptr<std::vector<int>> list_;
  74. uint32_t post_dispatch_action_;
  75. };
  76. class TestPlatformEventObserver : public PlatformEventObserver {
  77. public:
  78. TestPlatformEventObserver(int id, std::vector<int>* list)
  79. : id_(id), list_(list) {
  80. PlatformEventSource::GetInstance()->AddPlatformEventObserver(this);
  81. }
  82. TestPlatformEventObserver(const TestPlatformEventObserver&) = delete;
  83. TestPlatformEventObserver& operator=(const TestPlatformEventObserver&) =
  84. delete;
  85. ~TestPlatformEventObserver() override {
  86. PlatformEventSource::GetInstance()->RemovePlatformEventObserver(this);
  87. }
  88. protected:
  89. // PlatformEventObserver:
  90. void WillProcessEvent(const PlatformEvent& event) override {
  91. list_->push_back(id_);
  92. }
  93. void DidProcessEvent(const PlatformEvent& event) override {}
  94. private:
  95. int id_;
  96. raw_ptr<std::vector<int>> list_;
  97. };
  98. class PlatformEventTest : public testing::Test {
  99. public:
  100. PlatformEventTest() {}
  101. PlatformEventTest(const PlatformEventTest&) = delete;
  102. PlatformEventTest& operator=(const PlatformEventTest&) = delete;
  103. ~PlatformEventTest() override {}
  104. TestPlatformEventSource* source() { return source_.get(); }
  105. protected:
  106. // testing::Test:
  107. void SetUp() override {
  108. source_ = std::make_unique<TestPlatformEventSource>();
  109. }
  110. private:
  111. std::unique_ptr<TestPlatformEventSource> source_;
  112. };
  113. // Tests that a dispatcher receives an event.
  114. TEST_F(PlatformEventTest, DispatcherBasic) {
  115. std::vector<int> list_dispatcher;
  116. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  117. source()->Dispatch(*event);
  118. EXPECT_EQ(0u, list_dispatcher.size());
  119. {
  120. TestPlatformEventDispatcher dispatcher(1, &list_dispatcher);
  121. event = CreatePlatformEvent();
  122. source()->Dispatch(*event);
  123. ASSERT_EQ(1u, list_dispatcher.size());
  124. EXPECT_EQ(1, list_dispatcher[0]);
  125. }
  126. list_dispatcher.clear();
  127. event = CreatePlatformEvent();
  128. source()->Dispatch(*event);
  129. EXPECT_EQ(0u, list_dispatcher.size());
  130. }
  131. // Tests that dispatchers receive events in the correct order.
  132. TEST_F(PlatformEventTest, DispatcherOrder) {
  133. std::vector<int> list_dispatcher;
  134. int sequence[] = {21, 3, 6, 45};
  135. std::vector<std::unique_ptr<TestPlatformEventDispatcher>> dispatchers;
  136. for (auto id : sequence) {
  137. dispatchers.push_back(
  138. std::make_unique<TestPlatformEventDispatcher>(id, &list_dispatcher));
  139. }
  140. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  141. source()->Dispatch(*event);
  142. ASSERT_EQ(std::size(sequence), list_dispatcher.size());
  143. EXPECT_EQ(std::vector<int>(sequence, sequence + std::size(sequence)),
  144. list_dispatcher);
  145. }
  146. // Tests that if a dispatcher consumes the event, the subsequent dispatchers do
  147. // not receive the event.
  148. TEST_F(PlatformEventTest, DispatcherConsumesEventToStopDispatch) {
  149. std::vector<int> list_dispatcher;
  150. TestPlatformEventDispatcher first(12, &list_dispatcher);
  151. TestPlatformEventDispatcher second(23, &list_dispatcher);
  152. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  153. source()->Dispatch(*event);
  154. ASSERT_EQ(2u, list_dispatcher.size());
  155. EXPECT_EQ(12, list_dispatcher[0]);
  156. EXPECT_EQ(23, list_dispatcher[1]);
  157. list_dispatcher.clear();
  158. first.set_post_dispatch_action(POST_DISPATCH_STOP_PROPAGATION);
  159. event = CreatePlatformEvent();
  160. source()->Dispatch(*event);
  161. ASSERT_EQ(1u, list_dispatcher.size());
  162. EXPECT_EQ(12, list_dispatcher[0]);
  163. }
  164. // Tests that observers receive events.
  165. TEST_F(PlatformEventTest, ObserverBasic) {
  166. std::vector<int> list_observer;
  167. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  168. source()->Dispatch(*event);
  169. EXPECT_EQ(0u, list_observer.size());
  170. {
  171. TestPlatformEventObserver observer(31, &list_observer);
  172. event = CreatePlatformEvent();
  173. source()->Dispatch(*event);
  174. ASSERT_EQ(1u, list_observer.size());
  175. EXPECT_EQ(31, list_observer[0]);
  176. }
  177. list_observer.clear();
  178. event = CreatePlatformEvent();
  179. source()->Dispatch(*event);
  180. EXPECT_EQ(0u, list_observer.size());
  181. }
  182. // Tests that observers receive events in the correct order.
  183. TEST_F(PlatformEventTest, ObserverOrder) {
  184. std::vector<int> list_observer;
  185. const int sequence[] = {21, 3, 6, 45};
  186. std::vector<std::unique_ptr<TestPlatformEventObserver>> observers;
  187. for (auto id : sequence) {
  188. observers.push_back(
  189. std::make_unique<TestPlatformEventObserver>(id, &list_observer));
  190. }
  191. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  192. source()->Dispatch(*event);
  193. ASSERT_EQ(std::size(sequence), list_observer.size());
  194. EXPECT_EQ(std::vector<int>(sequence, sequence + std::size(sequence)),
  195. list_observer);
  196. }
  197. // Tests that observers and dispatchers receive events in the correct order.
  198. TEST_F(PlatformEventTest, DispatcherAndObserverOrder) {
  199. std::vector<int> list;
  200. TestPlatformEventDispatcher first_d(12, &list);
  201. TestPlatformEventObserver first_o(10, &list);
  202. TestPlatformEventDispatcher second_d(23, &list);
  203. TestPlatformEventObserver second_o(20, &list);
  204. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  205. source()->Dispatch(*event);
  206. const int expected[] = {10, 20, 12, 23};
  207. EXPECT_EQ(std::vector<int>(expected, expected + std::size(expected)), list);
  208. }
  209. // Tests that an overridden dispatcher receives events before the default
  210. // dispatchers.
  211. TEST_F(PlatformEventTest, OverriddenDispatcherBasic) {
  212. std::vector<int> list;
  213. TestPlatformEventDispatcher dispatcher(10, &list);
  214. TestPlatformEventObserver observer(15, &list);
  215. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  216. source()->Dispatch(*event);
  217. ASSERT_EQ(2u, list.size());
  218. EXPECT_EQ(15, list[0]);
  219. EXPECT_EQ(10, list[1]);
  220. list.clear();
  221. TestPlatformEventDispatcher overriding_dispatcher(20, &list);
  222. source()->RemovePlatformEventDispatcher(&overriding_dispatcher);
  223. std::unique_ptr<ScopedEventDispatcher> handle =
  224. source()->OverrideDispatcher(&overriding_dispatcher);
  225. source()->Dispatch(*event);
  226. ASSERT_EQ(2u, list.size());
  227. EXPECT_EQ(15, list[0]);
  228. EXPECT_EQ(20, list[1]);
  229. }
  230. // Tests that an overridden dispatcher can request that the default dispatchers
  231. // can dispatch the events.
  232. TEST_F(PlatformEventTest, OverriddenDispatcherInvokeDefaultDispatcher) {
  233. std::vector<int> list;
  234. TestPlatformEventDispatcher dispatcher(10, &list);
  235. TestPlatformEventObserver observer(15, &list);
  236. TestPlatformEventDispatcher overriding_dispatcher(20, &list);
  237. source()->RemovePlatformEventDispatcher(&overriding_dispatcher);
  238. std::unique_ptr<ScopedEventDispatcher> handle =
  239. source()->OverrideDispatcher(&overriding_dispatcher);
  240. overriding_dispatcher.set_post_dispatch_action(POST_DISPATCH_PERFORM_DEFAULT);
  241. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  242. source()->Dispatch(*event);
  243. // First the observer, then the overriding dispatcher, then the default
  244. // dispatcher.
  245. ASSERT_EQ(3u, list.size());
  246. EXPECT_EQ(15, list[0]);
  247. EXPECT_EQ(20, list[1]);
  248. EXPECT_EQ(10, list[2]);
  249. list.clear();
  250. // Install a second overriding dispatcher.
  251. TestPlatformEventDispatcher second_overriding(50, &list);
  252. source()->RemovePlatformEventDispatcher(&second_overriding);
  253. std::unique_ptr<ScopedEventDispatcher> second_override_handle =
  254. source()->OverrideDispatcher(&second_overriding);
  255. source()->Dispatch(*event);
  256. ASSERT_EQ(2u, list.size());
  257. EXPECT_EQ(15, list[0]);
  258. EXPECT_EQ(50, list[1]);
  259. list.clear();
  260. second_overriding.set_post_dispatch_action(POST_DISPATCH_PERFORM_DEFAULT);
  261. source()->Dispatch(*event);
  262. // First the observer, then the second overriding dispatcher, then the default
  263. // dispatcher.
  264. ASSERT_EQ(3u, list.size());
  265. EXPECT_EQ(15, list[0]);
  266. EXPECT_EQ(50, list[1]);
  267. EXPECT_EQ(10, list[2]);
  268. }
  269. // Runs a callback during an event dispatch.
  270. class RunCallbackDuringDispatch : public TestPlatformEventDispatcher {
  271. public:
  272. RunCallbackDuringDispatch(int id, std::vector<int>* list)
  273. : TestPlatformEventDispatcher(id, list) {}
  274. RunCallbackDuringDispatch(const RunCallbackDuringDispatch&) = delete;
  275. RunCallbackDuringDispatch& operator=(const RunCallbackDuringDispatch&) =
  276. delete;
  277. ~RunCallbackDuringDispatch() override {}
  278. void set_callback(base::OnceClosure callback) {
  279. callback_ = std::move(callback);
  280. }
  281. protected:
  282. // PlatformEventDispatcher:
  283. uint32_t DispatchEvent(const PlatformEvent& event) override {
  284. if (!callback_.is_null())
  285. std::move(callback_).Run();
  286. return TestPlatformEventDispatcher::DispatchEvent(event);
  287. }
  288. private:
  289. base::OnceClosure callback_;
  290. };
  291. // Test that if a dispatcher removes another dispatcher that is later in the
  292. // dispatcher list during dispatching an event, then event dispatching still
  293. // continues correctly.
  294. TEST_F(PlatformEventTest, DispatcherRemovesNextDispatcherDuringDispatch) {
  295. std::vector<int> list;
  296. TestPlatformEventDispatcher first(10, &list);
  297. RunCallbackDuringDispatch second(15, &list);
  298. TestPlatformEventDispatcher third(20, &list);
  299. TestPlatformEventDispatcher fourth(30, &list);
  300. second.set_callback(
  301. base::BindOnce(&RemoveDispatcher, base::Unretained(&third)));
  302. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  303. source()->Dispatch(*event);
  304. // |second| removes |third| from the dispatcher list during dispatch. So the
  305. // event should only reach |first|, |second|, and |fourth|.
  306. ASSERT_EQ(3u, list.size());
  307. EXPECT_EQ(10, list[0]);
  308. EXPECT_EQ(15, list[1]);
  309. EXPECT_EQ(30, list[2]);
  310. }
  311. // Tests that if a dispatcher removes itself from the dispatcher list during
  312. // dispatching an event, then event dispatching continues correctly.
  313. TEST_F(PlatformEventTest, DispatcherRemovesSelfDuringDispatch) {
  314. std::vector<int> list;
  315. TestPlatformEventDispatcher first(10, &list);
  316. RunCallbackDuringDispatch second(15, &list);
  317. TestPlatformEventDispatcher third(20, &list);
  318. second.set_callback(
  319. base::BindOnce(&RemoveDispatcher, base::Unretained(&second)));
  320. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  321. source()->Dispatch(*event);
  322. // |second| removes itself from the dispatcher list during dispatch. So the
  323. // event should reach all three dispatchers in the list.
  324. ASSERT_EQ(3u, list.size());
  325. EXPECT_EQ(10, list[0]);
  326. EXPECT_EQ(15, list[1]);
  327. EXPECT_EQ(20, list[2]);
  328. }
  329. // Tests that if a dispatcher removes itself from the dispatcher list during
  330. // dispatching an event, and this dispatcher is last in the dispatcher-list,
  331. // then event dispatching ends correctly.
  332. TEST_F(PlatformEventTest, DispatcherRemovesSelfDuringDispatchLast) {
  333. std::vector<int> list;
  334. TestPlatformEventDispatcher first(10, &list);
  335. RunCallbackDuringDispatch second(15, &list);
  336. second.set_callback(
  337. base::BindOnce(&RemoveDispatcher, base::Unretained(&second)));
  338. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  339. source()->Dispatch(*event);
  340. // |second| removes itself during dispatch. So both dispatchers will have
  341. // received the event.
  342. ASSERT_EQ(2u, list.size());
  343. EXPECT_EQ(10, list[0]);
  344. EXPECT_EQ(15, list[1]);
  345. }
  346. // Tests that if a dispatcher removes a single dispatcher that comes before it
  347. // in the dispatcher list, then dispatch continues correctly.
  348. TEST_F(PlatformEventTest, DispatcherRemovesPrevDispatcherDuringDispatch) {
  349. std::vector<int> list;
  350. TestPlatformEventDispatcher first(10, &list);
  351. RunCallbackDuringDispatch second(15, &list);
  352. TestPlatformEventDispatcher third(20, &list);
  353. second.set_callback(
  354. base::BindOnce(&RemoveDispatcher, base::Unretained(&first)));
  355. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  356. source()->Dispatch(*event);
  357. // |second| removes |first| from the dispatcher list during dispatch. The
  358. // event should reach all three dispatchers.
  359. ASSERT_EQ(3u, list.size());
  360. EXPECT_EQ(10, list[0]);
  361. EXPECT_EQ(15, list[1]);
  362. EXPECT_EQ(20, list[2]);
  363. }
  364. // Tests that if a dispatcher removes multiple dispatchers that comes before it
  365. // in the dispatcher list, then dispatch continues correctly.
  366. TEST_F(PlatformEventTest, DispatcherRemovesPrevDispatchersDuringDispatch) {
  367. std::vector<int> list;
  368. TestPlatformEventDispatcher first(10, &list);
  369. TestPlatformEventDispatcher second(12, &list);
  370. RunCallbackDuringDispatch third(15, &list);
  371. TestPlatformEventDispatcher fourth(20, &list);
  372. third.set_callback(base::BindOnce(
  373. &RemoveDispatchers, base::Unretained(&first), base::Unretained(&second)));
  374. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  375. source()->Dispatch(*event);
  376. // |third| removes |first| and |second| from the dispatcher list during
  377. // dispatch. The event should reach all three dispatchers.
  378. ASSERT_EQ(4u, list.size());
  379. EXPECT_EQ(10, list[0]);
  380. EXPECT_EQ(12, list[1]);
  381. EXPECT_EQ(15, list[2]);
  382. EXPECT_EQ(20, list[3]);
  383. }
  384. // Tests that adding a dispatcher during dispatching an event receives that
  385. // event.
  386. TEST_F(PlatformEventTest, DispatcherAddedDuringDispatchReceivesEvent) {
  387. std::vector<int> list;
  388. TestPlatformEventDispatcher first(10, &list);
  389. RunCallbackDuringDispatch second(15, &list);
  390. TestPlatformEventDispatcher third(20, &list);
  391. TestPlatformEventDispatcher fourth(30, &list);
  392. RemoveDispatchers(&third, &fourth);
  393. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  394. source()->Dispatch(*event);
  395. ASSERT_EQ(2u, list.size());
  396. EXPECT_EQ(10, list[0]);
  397. EXPECT_EQ(15, list[1]);
  398. second.set_callback(base::BindOnce(&AddDispatcher, base::Unretained(&third)));
  399. list.clear();
  400. source()->Dispatch(*event);
  401. ASSERT_EQ(3u, list.size());
  402. EXPECT_EQ(10, list[0]);
  403. EXPECT_EQ(15, list[1]);
  404. EXPECT_EQ(20, list[2]);
  405. second.set_callback(
  406. base::BindOnce(&AddDispatcher, base::Unretained(&fourth)));
  407. list.clear();
  408. source()->Dispatch(*event);
  409. ASSERT_EQ(4u, list.size());
  410. EXPECT_EQ(10, list[0]);
  411. EXPECT_EQ(15, list[1]);
  412. EXPECT_EQ(20, list[2]);
  413. EXPECT_EQ(30, list[3]);
  414. }
  415. // Provides mechanism for running tests from inside an active message-loop.
  416. class PlatformEventTestWithMessageLoop : public PlatformEventTest {
  417. public:
  418. PlatformEventTestWithMessageLoop() {}
  419. PlatformEventTestWithMessageLoop(const PlatformEventTestWithMessageLoop&) =
  420. delete;
  421. PlatformEventTestWithMessageLoop& operator=(
  422. const PlatformEventTestWithMessageLoop&) = delete;
  423. ~PlatformEventTestWithMessageLoop() override {}
  424. void Run() {
  425. task_environment_.GetMainThreadTaskRunner()->PostTask(
  426. FROM_HERE,
  427. base::BindOnce(&PlatformEventTestWithMessageLoop::RunTestImpl,
  428. base::Unretained(this)));
  429. base::RunLoop().RunUntilIdle();
  430. }
  431. protected:
  432. virtual void RunTestImpl() = 0;
  433. private:
  434. base::test::SingleThreadTaskEnvironment task_environment_{
  435. base::test::SingleThreadTaskEnvironment::MainThreadType::UI};
  436. };
  437. #define RUN_TEST_IN_MESSAGE_LOOP(name) \
  438. TEST_F(name, Run) { Run(); }
  439. // Tests that a ScopedEventDispatcher restores the previous dispatcher when
  440. // destroyed.
  441. class ScopedDispatcherRestoresAfterDestroy
  442. : public PlatformEventTestWithMessageLoop {
  443. public:
  444. // PlatformEventTestWithMessageLoop:
  445. void RunTestImpl() override {
  446. std::vector<int> list;
  447. TestPlatformEventDispatcher dispatcher(10, &list);
  448. TestPlatformEventObserver observer(15, &list);
  449. TestPlatformEventDispatcher first_overriding(20, &list);
  450. source()->RemovePlatformEventDispatcher(&first_overriding);
  451. std::unique_ptr<ScopedEventDispatcher> first_override_handle =
  452. source()->OverrideDispatcher(&first_overriding);
  453. // Install a second overriding dispatcher.
  454. TestPlatformEventDispatcher second_overriding(50, &list);
  455. source()->RemovePlatformEventDispatcher(&second_overriding);
  456. std::unique_ptr<ScopedEventDispatcher> second_override_handle =
  457. source()->OverrideDispatcher(&second_overriding);
  458. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  459. source()->Dispatch(*event);
  460. ASSERT_EQ(2u, list.size());
  461. EXPECT_EQ(15, list[0]);
  462. EXPECT_EQ(50, list[1]);
  463. list.clear();
  464. second_override_handle.reset();
  465. source()->Dispatch(*event);
  466. ASSERT_EQ(2u, list.size());
  467. EXPECT_EQ(15, list[0]);
  468. EXPECT_EQ(20, list[1]);
  469. }
  470. };
  471. RUN_TEST_IN_MESSAGE_LOOP(ScopedDispatcherRestoresAfterDestroy)
  472. // This dispatcher destroys the handle to the ScopedEventDispatcher when
  473. // dispatching an event.
  474. class DestroyScopedHandleDispatcher : public TestPlatformEventDispatcher {
  475. public:
  476. DestroyScopedHandleDispatcher(int id, std::vector<int>* list)
  477. : TestPlatformEventDispatcher(id, list) {}
  478. DestroyScopedHandleDispatcher(const DestroyScopedHandleDispatcher&) = delete;
  479. DestroyScopedHandleDispatcher& operator=(
  480. const DestroyScopedHandleDispatcher&) = delete;
  481. ~DestroyScopedHandleDispatcher() override {}
  482. void SetScopedHandle(std::unique_ptr<ScopedEventDispatcher> handler) {
  483. handler_ = std::move(handler);
  484. }
  485. void set_callback(base::OnceClosure callback) {
  486. callback_ = std::move(callback);
  487. }
  488. private:
  489. // PlatformEventDispatcher:
  490. bool CanDispatchEvent(const PlatformEvent& event) override { return true; }
  491. uint32_t DispatchEvent(const PlatformEvent& event) override {
  492. handler_.reset();
  493. uint32_t action = TestPlatformEventDispatcher::DispatchEvent(event);
  494. if (!callback_.is_null()) {
  495. std::move(callback_).Run();
  496. }
  497. return action;
  498. }
  499. std::unique_ptr<ScopedEventDispatcher> handler_;
  500. base::OnceClosure callback_;
  501. };
  502. // Tests that resetting an overridden dispatcher, and installing another
  503. // overridden dispatcher before the nested message-loop completely unwinds
  504. // function correctly.
  505. class ConsecutiveOverriddenDispatcherInTheSameMessageLoopIteration
  506. : public PlatformEventTestWithMessageLoop {
  507. public:
  508. void NestedTask(std::unique_ptr<ScopedEventDispatcher> dispatch_handle,
  509. std::vector<int>* list) {
  510. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  511. source()->Dispatch(*event);
  512. ASSERT_EQ(2u, list->size());
  513. EXPECT_EQ(15, (*list)[0]);
  514. EXPECT_EQ(20, (*list)[1]);
  515. list->clear();
  516. // Reset the override dispatcher. This should restore the default
  517. // dispatcher.
  518. dispatch_handle.reset();
  519. source()->Dispatch(*event);
  520. ASSERT_EQ(2u, list->size());
  521. EXPECT_EQ(15, (*list)[0]);
  522. EXPECT_EQ(10, (*list)[1]);
  523. list->clear();
  524. // Install another override-dispatcher.
  525. DestroyScopedHandleDispatcher second_overriding(70, list);
  526. source()->RemovePlatformEventDispatcher(&second_overriding);
  527. std::unique_ptr<ScopedEventDispatcher> second_override_handle =
  528. source()->OverrideDispatcher(&second_overriding);
  529. source()->Dispatch(*event);
  530. ASSERT_EQ(2u, list->size());
  531. EXPECT_EQ(15, (*list)[0]);
  532. EXPECT_EQ(70, (*list)[1]);
  533. list->clear();
  534. second_overriding.SetScopedHandle(std::move(second_override_handle));
  535. second_overriding.set_post_dispatch_action(POST_DISPATCH_NONE);
  536. base::RunLoop run_loop(base::RunLoop::Type::kNestableTasksAllowed);
  537. second_overriding.set_callback(run_loop.QuitClosure());
  538. base::ThreadTaskRunnerHandle::Get()->PostTask(
  539. FROM_HERE,
  540. base::BindOnce(base::IgnoreResult(&TestPlatformEventSource::Dispatch),
  541. base::Unretained(source()), *event));
  542. run_loop.Run();
  543. ASSERT_EQ(2u, list->size());
  544. EXPECT_EQ(15, (*list)[0]);
  545. EXPECT_EQ(70, (*list)[1]);
  546. list->clear();
  547. // Terminate the message-loop.
  548. run_loop_.Quit();
  549. }
  550. // PlatformEventTestWithMessageLoop:
  551. void RunTestImpl() override {
  552. std::vector<int> list;
  553. TestPlatformEventDispatcher dispatcher(10, &list);
  554. TestPlatformEventObserver observer(15, &list);
  555. TestPlatformEventDispatcher overriding(20, &list);
  556. source()->RemovePlatformEventDispatcher(&overriding);
  557. std::unique_ptr<ScopedEventDispatcher> override_handle =
  558. source()->OverrideDispatcher(&overriding);
  559. std::unique_ptr<PlatformEvent> event = CreatePlatformEvent();
  560. source()->Dispatch(*event);
  561. ASSERT_EQ(2u, list.size());
  562. EXPECT_EQ(15, list[0]);
  563. EXPECT_EQ(20, list[1]);
  564. list.clear();
  565. // Start a nested message-loop, and destroy |override_handle| in the nested
  566. // loop. That should terminate the nested loop, restore the previous
  567. // dispatchers, and return control to this function.
  568. base::ThreadTaskRunnerHandle::Get()->PostTask(
  569. FROM_HERE,
  570. base::BindOnce(
  571. &ConsecutiveOverriddenDispatcherInTheSameMessageLoopIteration::
  572. NestedTask,
  573. base::Unretained(this), std::move(override_handle),
  574. base::Unretained(&list)));
  575. run_loop_.Run();
  576. // Dispatching the event should now reach the default dispatcher.
  577. source()->Dispatch(*event);
  578. ASSERT_EQ(2u, list.size());
  579. EXPECT_EQ(15, list[0]);
  580. EXPECT_EQ(10, list[1]);
  581. }
  582. private:
  583. base::RunLoop run_loop_{base::RunLoop::Type::kNestableTasksAllowed};
  584. };
  585. RUN_TEST_IN_MESSAGE_LOOP(
  586. ConsecutiveOverriddenDispatcherInTheSameMessageLoopIteration)
  587. } // namespace ui