media_controller_unittest.cc 44 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371
  1. // Copyright 2018 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 "services/media_session/media_controller.h"
  5. #include <memory>
  6. #include <utility>
  7. #include <vector>
  8. #include "base/run_loop.h"
  9. #include "base/strings/utf_string_conversions.h"
  10. #include "base/test/task_environment.h"
  11. #include "base/time/time.h"
  12. #include "base/unguessable_token.h"
  13. #include "mojo/public/cpp/bindings/remote.h"
  14. #include "services/media_session/media_session_service_impl.h"
  15. #include "services/media_session/public/cpp/media_metadata.h"
  16. #include "services/media_session/public/cpp/test/mock_media_session.h"
  17. #include "services/media_session/public/cpp/test/test_media_controller.h"
  18. #include "services/media_session/public/mojom/constants.mojom.h"
  19. #include "services/media_session/public/mojom/media_session.mojom.h"
  20. #include "testing/gtest/include/gtest/gtest.h"
  21. namespace media_session {
  22. class MediaControllerTest : public testing::Test {
  23. public:
  24. MediaControllerTest() = default;
  25. MediaControllerTest(const MediaControllerTest&) = delete;
  26. MediaControllerTest& operator=(const MediaControllerTest&) = delete;
  27. void SetUp() override {
  28. // Create an instance of the MediaSessionService and bind some interfaces.
  29. service_ = std::make_unique<MediaSessionServiceImpl>();
  30. service_->BindAudioFocusManager(
  31. audio_focus_remote_.BindNewPipeAndPassReceiver());
  32. service_->BindMediaControllerManager(
  33. controller_manager_remote_.BindNewPipeAndPassReceiver());
  34. controller_manager_remote_->CreateActiveMediaController(
  35. media_controller_remote_.BindNewPipeAndPassReceiver());
  36. controller_manager_remote_.FlushForTesting();
  37. audio_focus_remote_->SetEnforcementMode(
  38. mojom::EnforcementMode::kSingleSession);
  39. audio_focus_remote_.FlushForTesting();
  40. }
  41. void TearDown() override {
  42. // Run pending tasks.
  43. base::RunLoop().RunUntilIdle();
  44. }
  45. void RequestAudioFocus(test::MockMediaSession& session,
  46. mojom::AudioFocusType type) {
  47. session.RequestAudioFocusFromService(audio_focus_remote_, type);
  48. }
  49. mojo::Remote<mojom::MediaController>& controller() {
  50. return media_controller_remote_;
  51. }
  52. mojo::Remote<mojom::MediaControllerManager>& manager() {
  53. return controller_manager_remote_;
  54. }
  55. static size_t GetImageObserverCount(const MediaController& controller) {
  56. return controller.image_observers_.size();
  57. }
  58. private:
  59. base::test::TaskEnvironment task_environment_;
  60. std::unique_ptr<MediaSessionService> service_;
  61. mojo::Remote<mojom::AudioFocusManager> audio_focus_remote_;
  62. mojo::Remote<mojom::MediaController> media_controller_remote_;
  63. mojo::Remote<mojom::MediaControllerManager> controller_manager_remote_;
  64. };
  65. TEST_F(MediaControllerTest, ActiveController_Suspend) {
  66. test::MockMediaSession media_session;
  67. media_session.SetIsControllable(true);
  68. {
  69. test::MockMediaSessionMojoObserver observer(media_session);
  70. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  71. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  72. }
  73. {
  74. test::MockMediaSessionMojoObserver observer(media_session);
  75. controller()->Suspend();
  76. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  77. }
  78. }
  79. TEST_F(MediaControllerTest, ActiveController_Multiple_Abandon_Top) {
  80. test::MockMediaSession media_session_1;
  81. test::MockMediaSession media_session_2;
  82. media_session_1.SetIsControllable(true);
  83. media_session_2.SetIsControllable(true);
  84. {
  85. test::MockMediaSessionMojoObserver observer(media_session_1);
  86. RequestAudioFocus(media_session_1, mojom::AudioFocusType::kGain);
  87. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  88. }
  89. {
  90. test::MockMediaSessionMojoObserver observer_1(media_session_1);
  91. test::MockMediaSessionMojoObserver observer_2(media_session_2);
  92. RequestAudioFocus(media_session_2, mojom::AudioFocusType::kGain);
  93. observer_1.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  94. observer_2.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  95. }
  96. media_session_2.AbandonAudioFocusFromClient();
  97. {
  98. test::MockMediaSessionMojoObserver observer(media_session_1);
  99. controller()->Resume();
  100. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  101. }
  102. }
  103. TEST_F(MediaControllerTest,
  104. ActiveController_Multiple_Abandon_UnderNonControllable) {
  105. test::MockMediaSession media_session_1;
  106. test::MockMediaSession media_session_2;
  107. test::MockMediaSession media_session_3;
  108. media_session_1.SetIsControllable(true);
  109. media_session_2.SetIsControllable(true);
  110. {
  111. test::MockMediaSessionMojoObserver observer(media_session_1);
  112. RequestAudioFocus(media_session_1, mojom::AudioFocusType::kGain);
  113. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  114. }
  115. {
  116. test::MockMediaSessionMojoObserver observer_1(media_session_1);
  117. test::MockMediaSessionMojoObserver observer_2(media_session_2);
  118. RequestAudioFocus(media_session_2, mojom::AudioFocusType::kGain);
  119. observer_1.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  120. observer_2.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  121. }
  122. {
  123. test::MockMediaSessionMojoObserver observer_2(media_session_2);
  124. test::MockMediaSessionMojoObserver observer_3(media_session_3);
  125. RequestAudioFocus(media_session_3, mojom::AudioFocusType::kGain);
  126. observer_2.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  127. observer_3.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  128. }
  129. media_session_2.AbandonAudioFocusFromClient();
  130. {
  131. test::MockMediaSessionMojoObserver observer(media_session_1);
  132. controller()->Resume();
  133. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  134. }
  135. }
  136. TEST_F(MediaControllerTest, ActiveController_Multiple_Controllable) {
  137. test::MockMediaSession media_session_1;
  138. test::MockMediaSession media_session_2;
  139. media_session_1.SetIsControllable(true);
  140. media_session_2.SetIsControllable(true);
  141. {
  142. test::MockMediaSessionMojoObserver observer(media_session_1);
  143. RequestAudioFocus(media_session_1, mojom::AudioFocusType::kGain);
  144. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  145. }
  146. {
  147. test::MockMediaSessionMojoObserver observer_1(media_session_1);
  148. test::MockMediaSessionMojoObserver observer_2(media_session_2);
  149. RequestAudioFocus(media_session_2, mojom::AudioFocusType::kGain);
  150. observer_1.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  151. observer_2.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  152. }
  153. {
  154. test::MockMediaSessionMojoObserver observer(media_session_2);
  155. controller()->Suspend();
  156. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  157. }
  158. }
  159. TEST_F(MediaControllerTest, ActiveController_Multiple_NonControllable) {
  160. test::MockMediaSession media_session_1;
  161. test::MockMediaSession media_session_2;
  162. media_session_1.SetIsControllable(true);
  163. {
  164. test::MockMediaSessionMojoObserver observer(media_session_1);
  165. RequestAudioFocus(media_session_1, mojom::AudioFocusType::kGain);
  166. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  167. }
  168. EXPECT_EQ(2, media_session_1.add_observer_count());
  169. {
  170. test::MockMediaSessionMojoObserver observer_1(media_session_1);
  171. test::MockMediaSessionMojoObserver observer_2(media_session_2);
  172. RequestAudioFocus(media_session_2, mojom::AudioFocusType::kGain);
  173. observer_1.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  174. observer_2.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  175. }
  176. // The top session has changed but the controller is still bound to
  177. // |media_session_1|. We should make sure we do not add an observer if we
  178. // already have one.
  179. EXPECT_EQ(3, media_session_1.add_observer_count());
  180. {
  181. test::MockMediaSessionMojoObserver observer(media_session_1);
  182. controller()->Resume();
  183. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  184. }
  185. EXPECT_EQ(4, media_session_1.add_observer_count());
  186. }
  187. TEST_F(MediaControllerTest, ActiveController_Multiple_UpdateControllable) {
  188. test::MockMediaSession media_session_1;
  189. test::MockMediaSession media_session_2;
  190. media_session_1.SetIsControllable(true);
  191. media_session_2.SetIsControllable(true);
  192. EXPECT_EQ(0, media_session_1.add_observer_count());
  193. EXPECT_EQ(0, media_session_2.add_observer_count());
  194. {
  195. test::MockMediaSessionMojoObserver observer(media_session_1);
  196. RequestAudioFocus(media_session_1, mojom::AudioFocusType::kGain);
  197. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  198. }
  199. EXPECT_EQ(2, media_session_1.add_observer_count());
  200. EXPECT_EQ(0, media_session_2.add_observer_count());
  201. {
  202. test::MockMediaSessionMojoObserver observer(media_session_2);
  203. RequestAudioFocus(media_session_2, mojom::AudioFocusType::kGainTransient);
  204. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  205. }
  206. EXPECT_EQ(2, media_session_1.add_observer_count());
  207. EXPECT_EQ(2, media_session_2.add_observer_count());
  208. media_session_2.SetIsControllable(false);
  209. media_session_2.FlushForTesting();
  210. EXPECT_EQ(3, media_session_1.add_observer_count());
  211. EXPECT_EQ(2, media_session_2.add_observer_count());
  212. media_session_1.SetIsControllable(false);
  213. media_session_1.FlushForTesting();
  214. EXPECT_EQ(3, media_session_1.add_observer_count());
  215. EXPECT_EQ(2, media_session_2.add_observer_count());
  216. }
  217. TEST_F(MediaControllerTest, ActiveController_Suspend_Noop) {
  218. controller()->Suspend();
  219. }
  220. TEST_F(MediaControllerTest, ActiveController_Suspend_Noop_Abandoned) {
  221. test::MockMediaSession media_session;
  222. media_session.SetIsControllable(true);
  223. {
  224. test::MockMediaSessionMojoObserver observer(media_session);
  225. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  226. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  227. }
  228. media_session.AbandonAudioFocusFromClient();
  229. controller()->Suspend();
  230. {
  231. test::MockMediaSessionMojoObserver observer(media_session);
  232. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  233. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  234. }
  235. }
  236. TEST_F(MediaControllerTest, ActiveController_SuspendResume) {
  237. test::MockMediaSession media_session;
  238. media_session.SetIsControllable(true);
  239. {
  240. test::MockMediaSessionMojoObserver observer(media_session);
  241. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  242. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  243. }
  244. {
  245. test::MockMediaSessionMojoObserver observer(media_session);
  246. controller()->Suspend();
  247. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  248. }
  249. {
  250. test::MockMediaSessionMojoObserver observer(media_session);
  251. controller()->Resume();
  252. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  253. }
  254. }
  255. TEST_F(MediaControllerTest, ActiveController_ToggleSuspendResume_Playing) {
  256. test::MockMediaSession media_session;
  257. media_session.SetIsControllable(true);
  258. {
  259. test::MockMediaSessionMojoObserver observer(media_session);
  260. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  261. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  262. }
  263. {
  264. test::MockMediaSessionMojoObserver observer(media_session);
  265. controller()->ToggleSuspendResume();
  266. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  267. }
  268. }
  269. TEST_F(MediaControllerTest, ActiveController_ToggleSuspendResume_Ducked) {
  270. test::MockMediaSession media_session;
  271. media_session.SetIsControllable(true);
  272. {
  273. test::MockMediaSessionMojoObserver observer(media_session);
  274. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  275. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  276. }
  277. {
  278. test::MockMediaSessionMojoObserver observer(media_session);
  279. media_session.StartDucking();
  280. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kDucking);
  281. }
  282. {
  283. test::MockMediaSessionMojoObserver observer(media_session);
  284. controller()->ToggleSuspendResume();
  285. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  286. }
  287. }
  288. TEST_F(MediaControllerTest, ActiveController_ToggleSuspendResume_Inactive) {
  289. test::MockMediaSession media_session;
  290. media_session.SetIsControllable(true);
  291. {
  292. test::MockMediaSessionMojoObserver observer(media_session);
  293. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  294. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  295. }
  296. {
  297. test::MockMediaSessionMojoObserver observer(media_session);
  298. media_session.Stop(mojom::MediaSession::SuspendType::kUI);
  299. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kInactive);
  300. }
  301. {
  302. test::MockMediaSessionMojoObserver observer(media_session);
  303. controller()->ToggleSuspendResume();
  304. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  305. }
  306. }
  307. TEST_F(MediaControllerTest, ActiveController_ToggleSuspendResume_Paused) {
  308. test::MockMediaSession media_session;
  309. media_session.SetIsControllable(true);
  310. {
  311. test::MockMediaSessionMojoObserver observer(media_session);
  312. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  313. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  314. }
  315. {
  316. test::MockMediaSessionMojoObserver observer(media_session);
  317. controller()->Suspend();
  318. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  319. }
  320. {
  321. test::MockMediaSessionMojoObserver observer(media_session);
  322. controller()->ToggleSuspendResume();
  323. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  324. }
  325. }
  326. TEST_F(MediaControllerTest, ActiveController_Observer_StateTransition) {
  327. test::MockMediaSession media_session_1;
  328. test::MockMediaSession media_session_2;
  329. media_session_1.SetIsControllable(true);
  330. media_session_2.SetIsControllable(true);
  331. {
  332. test::MockMediaSessionMojoObserver observer(media_session_1);
  333. RequestAudioFocus(media_session_1, mojom::AudioFocusType::kGain);
  334. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  335. }
  336. {
  337. test::TestMediaControllerObserver observer(controller());
  338. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  339. }
  340. {
  341. test::TestMediaControllerObserver observer(controller());
  342. controller()->Suspend();
  343. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kSuspended);
  344. }
  345. {
  346. test::TestMediaControllerObserver observer(controller());
  347. RequestAudioFocus(media_session_2, mojom::AudioFocusType::kGain);
  348. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  349. }
  350. {
  351. test::MockMediaSessionMojoObserver observer(media_session_1);
  352. media_session_1.StartDucking();
  353. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kDucking);
  354. }
  355. {
  356. test::TestMediaControllerObserver observer(controller());
  357. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  358. }
  359. }
  360. TEST_F(MediaControllerTest, ActiveController_PreviousTrack) {
  361. test::MockMediaSession media_session;
  362. media_session.SetIsControllable(true);
  363. EXPECT_EQ(0, media_session.prev_track_count());
  364. {
  365. test::MockMediaSessionMojoObserver observer(media_session);
  366. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  367. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  368. EXPECT_EQ(0, media_session.prev_track_count());
  369. }
  370. controller()->PreviousTrack();
  371. controller().FlushForTesting();
  372. EXPECT_EQ(1, media_session.prev_track_count());
  373. }
  374. TEST_F(MediaControllerTest, ActiveController_NextTrack) {
  375. test::MockMediaSession media_session;
  376. media_session.SetIsControllable(true);
  377. EXPECT_EQ(0, media_session.next_track_count());
  378. {
  379. test::MockMediaSessionMojoObserver observer(media_session);
  380. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  381. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  382. EXPECT_EQ(0, media_session.next_track_count());
  383. }
  384. controller()->NextTrack();
  385. controller().FlushForTesting();
  386. EXPECT_EQ(1, media_session.next_track_count());
  387. }
  388. TEST_F(MediaControllerTest, ActiveController_Seek) {
  389. test::MockMediaSession media_session;
  390. media_session.SetIsControllable(true);
  391. EXPECT_EQ(0, media_session.seek_count());
  392. {
  393. test::MockMediaSessionMojoObserver observer(media_session);
  394. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  395. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  396. EXPECT_EQ(0, media_session.seek_count());
  397. }
  398. controller()->Seek(base::Seconds(mojom::kDefaultSeekTimeSeconds));
  399. controller().FlushForTesting();
  400. EXPECT_EQ(1, media_session.seek_count());
  401. }
  402. TEST_F(MediaControllerTest, ActiveController_SeekTo) {
  403. test::MockMediaSession media_session;
  404. media_session.SetIsControllable(true);
  405. EXPECT_EQ(0, media_session.seek_to_count());
  406. {
  407. test::MockMediaSessionMojoObserver observer(media_session);
  408. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  409. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  410. EXPECT_EQ(0, media_session.seek_to_count());
  411. }
  412. controller()->SeekTo(base::Seconds(mojom::kDefaultSeekTimeSeconds));
  413. controller().FlushForTesting();
  414. EXPECT_EQ(1, media_session.seek_to_count());
  415. }
  416. TEST_F(MediaControllerTest, ActiveController_ScrubTo) {
  417. test::MockMediaSession media_session;
  418. media_session.SetIsControllable(true);
  419. EXPECT_FALSE(media_session.is_scrubbing());
  420. EXPECT_EQ(0, media_session.seek_to_count());
  421. {
  422. test::MockMediaSessionMojoObserver observer(media_session);
  423. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  424. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  425. EXPECT_FALSE(media_session.is_scrubbing());
  426. EXPECT_EQ(0, media_session.seek_to_count());
  427. }
  428. controller()->ScrubTo(base::Seconds(mojom::kDefaultSeekTimeSeconds));
  429. controller().FlushForTesting();
  430. EXPECT_TRUE(media_session.is_scrubbing());
  431. EXPECT_EQ(0, media_session.seek_to_count());
  432. controller()->ScrubTo(base::Seconds(mojom::kDefaultSeekTimeSeconds));
  433. controller().FlushForTesting();
  434. EXPECT_TRUE(media_session.is_scrubbing());
  435. EXPECT_EQ(0, media_session.seek_to_count());
  436. controller()->SeekTo(base::Seconds(mojom::kDefaultSeekTimeSeconds));
  437. controller().FlushForTesting();
  438. EXPECT_FALSE(media_session.is_scrubbing());
  439. EXPECT_EQ(1, media_session.seek_to_count());
  440. }
  441. TEST_F(MediaControllerTest, ActiveController_Metadata_Observer_Abandoned) {
  442. MediaMetadata metadata;
  443. metadata.title = u"title";
  444. metadata.artist = u"artist";
  445. metadata.album = u"album";
  446. test::MockMediaSession media_session;
  447. media_session.SetIsControllable(true);
  448. absl::optional<MediaMetadata> test_metadata(metadata);
  449. {
  450. test::MockMediaSessionMojoObserver observer(media_session);
  451. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  452. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  453. }
  454. media_session.SimulateMetadataChanged(test_metadata);
  455. media_session.AbandonAudioFocusFromClient();
  456. {
  457. test::TestMediaControllerObserver observer(controller());
  458. observer.WaitForEmptyMetadata();
  459. }
  460. }
  461. TEST_F(MediaControllerTest, ActiveController_Metadata_Observer_Empty) {
  462. test::MockMediaSession media_session;
  463. media_session.SetIsControllable(true);
  464. absl::optional<MediaMetadata> test_metadata;
  465. {
  466. test::MockMediaSessionMojoObserver observer(media_session);
  467. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  468. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  469. }
  470. {
  471. test::TestMediaControllerObserver observer(controller());
  472. media_session.SimulateMetadataChanged(test_metadata);
  473. observer.WaitForEmptyMetadata();
  474. }
  475. }
  476. TEST_F(MediaControllerTest, ActiveController_Metadata_Observer_WithInfo) {
  477. MediaMetadata metadata;
  478. metadata.title = u"title";
  479. metadata.artist = u"artist";
  480. metadata.album = u"album";
  481. test::MockMediaSession media_session;
  482. media_session.SetIsControllable(true);
  483. absl::optional<MediaMetadata> test_metadata(metadata);
  484. {
  485. test::MockMediaSessionMojoObserver observer(media_session);
  486. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  487. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  488. }
  489. {
  490. test::TestMediaControllerObserver observer(controller());
  491. media_session.SimulateMetadataChanged(test_metadata);
  492. observer.WaitForExpectedMetadata(metadata);
  493. }
  494. }
  495. TEST_F(MediaControllerTest, ActiveController_Metadata_AddObserver_Empty) {
  496. test::MockMediaSession media_session;
  497. media_session.SetIsControllable(true);
  498. absl::optional<MediaMetadata> test_metadata;
  499. {
  500. test::MockMediaSessionMojoObserver observer(media_session);
  501. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  502. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  503. }
  504. media_session.SimulateMetadataChanged(test_metadata);
  505. {
  506. test::TestMediaControllerObserver observer(controller());
  507. observer.WaitForEmptyMetadata();
  508. }
  509. }
  510. TEST_F(MediaControllerTest, ActiveController_Metadata_AddObserver_WithInfo) {
  511. MediaMetadata metadata;
  512. metadata.title = u"title";
  513. metadata.artist = u"artist";
  514. metadata.album = u"album";
  515. test::MockMediaSession media_session;
  516. media_session.SetIsControllable(true);
  517. absl::optional<MediaMetadata> test_metadata(metadata);
  518. {
  519. test::MockMediaSessionMojoObserver observer(media_session);
  520. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  521. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  522. }
  523. media_session.SimulateMetadataChanged(test_metadata);
  524. {
  525. test::TestMediaControllerObserver observer(controller());
  526. observer.WaitForExpectedMetadata(metadata);
  527. }
  528. }
  529. TEST_F(MediaControllerTest, ActiveController_Stop) {
  530. test::MockMediaSession media_session;
  531. media_session.SetIsControllable(true);
  532. {
  533. test::MockMediaSessionMojoObserver observer(media_session);
  534. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  535. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  536. }
  537. {
  538. test::MockMediaSessionMojoObserver observer(media_session);
  539. controller()->Stop();
  540. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kInactive);
  541. }
  542. }
  543. TEST_F(MediaControllerTest, BoundController_Routing) {
  544. test::MockMediaSession media_session_1;
  545. test::MockMediaSession media_session_2;
  546. media_session_1.SetIsControllable(true);
  547. media_session_2.SetIsControllable(true);
  548. {
  549. test::MockMediaSessionMojoObserver observer(media_session_1);
  550. RequestAudioFocus(media_session_1, mojom::AudioFocusType::kGain);
  551. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  552. }
  553. mojo::Remote<mojom::MediaController> controller;
  554. manager()->CreateMediaControllerForSession(
  555. controller.BindNewPipeAndPassReceiver(), media_session_1.request_id());
  556. manager().FlushForTesting();
  557. EXPECT_EQ(0, media_session_1.next_track_count());
  558. controller->NextTrack();
  559. controller.FlushForTesting();
  560. EXPECT_EQ(1, media_session_1.next_track_count());
  561. {
  562. test::MockMediaSessionMojoObserver observer(media_session_2);
  563. RequestAudioFocus(media_session_2, mojom::AudioFocusType::kGain);
  564. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  565. }
  566. EXPECT_EQ(1, media_session_1.next_track_count());
  567. EXPECT_EQ(0, media_session_2.next_track_count());
  568. controller->NextTrack();
  569. controller.FlushForTesting();
  570. EXPECT_EQ(2, media_session_1.next_track_count());
  571. EXPECT_EQ(0, media_session_2.next_track_count());
  572. }
  573. TEST_F(MediaControllerTest, BoundController_BadRequestId) {
  574. test::MockMediaSession media_session;
  575. media_session.SetIsControllable(true);
  576. {
  577. test::MockMediaSessionMojoObserver observer(media_session);
  578. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  579. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  580. }
  581. mojo::Remote<mojom::MediaController> controller;
  582. manager()->CreateMediaControllerForSession(
  583. controller.BindNewPipeAndPassReceiver(),
  584. base::UnguessableToken::Create());
  585. manager().FlushForTesting();
  586. EXPECT_EQ(0, media_session.next_track_count());
  587. controller->NextTrack();
  588. controller.FlushForTesting();
  589. EXPECT_EQ(0, media_session.next_track_count());
  590. }
  591. TEST_F(MediaControllerTest, BoundController_DropOnAbandon) {
  592. test::MockMediaSession media_session;
  593. media_session.SetIsControllable(true);
  594. {
  595. test::MockMediaSessionMojoObserver observer(media_session);
  596. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  597. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  598. }
  599. mojo::Remote<mojom::MediaController> controller;
  600. manager()->CreateMediaControllerForSession(
  601. controller.BindNewPipeAndPassReceiver(), media_session.request_id());
  602. manager().FlushForTesting();
  603. EXPECT_EQ(0, media_session.next_track_count());
  604. controller->NextTrack();
  605. controller.FlushForTesting();
  606. EXPECT_EQ(1, media_session.next_track_count());
  607. media_session.AbandonAudioFocusFromClient();
  608. EXPECT_EQ(1, media_session.next_track_count());
  609. controller->NextTrack();
  610. controller.FlushForTesting();
  611. EXPECT_EQ(1, media_session.next_track_count());
  612. }
  613. TEST_F(MediaControllerTest, ActiveController_Actions_AddObserver_Empty) {
  614. test::MockMediaSession media_session;
  615. media_session.SetIsControllable(true);
  616. {
  617. test::MockMediaSessionMojoObserver observer(media_session);
  618. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  619. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  620. }
  621. {
  622. test::TestMediaControllerObserver observer(controller());
  623. observer.WaitForEmptyActions();
  624. }
  625. }
  626. TEST_F(MediaControllerTest, ActiveController_Actions_AddObserver_WithInfo) {
  627. test::MockMediaSession media_session;
  628. media_session.SetIsControllable(true);
  629. {
  630. test::MockMediaSessionMojoObserver observer(media_session);
  631. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  632. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  633. }
  634. media_session.EnableAction(mojom::MediaSessionAction::kPlay);
  635. {
  636. test::TestMediaControllerObserver observer(controller());
  637. std::set<mojom::MediaSessionAction> expected_actions;
  638. expected_actions.insert(mojom::MediaSessionAction::kPlay);
  639. observer.WaitForExpectedActions(expected_actions);
  640. }
  641. }
  642. TEST_F(MediaControllerTest, ActiveController_Actions_Observer_Empty) {
  643. test::MockMediaSession media_session;
  644. media_session.EnableAction(mojom::MediaSessionAction::kPlay);
  645. media_session.SetIsControllable(true);
  646. {
  647. test::MockMediaSessionMojoObserver observer(media_session);
  648. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  649. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  650. }
  651. {
  652. test::TestMediaControllerObserver observer(controller());
  653. media_session.DisableAction(mojom::MediaSessionAction::kPlay);
  654. observer.WaitForEmptyActions();
  655. }
  656. }
  657. TEST_F(MediaControllerTest, ActiveController_Actions_Observer_WithInfo) {
  658. test::MockMediaSession media_session;
  659. media_session.SetIsControllable(true);
  660. {
  661. test::MockMediaSessionMojoObserver observer(media_session);
  662. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  663. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  664. }
  665. {
  666. test::TestMediaControllerObserver observer(controller());
  667. media_session.EnableAction(mojom::MediaSessionAction::kPlay);
  668. std::set<mojom::MediaSessionAction> expected_actions;
  669. expected_actions.insert(mojom::MediaSessionAction::kPlay);
  670. observer.WaitForExpectedActions(expected_actions);
  671. }
  672. }
  673. TEST_F(MediaControllerTest, ActiveController_Actions_Observer_Abandoned) {
  674. test::MockMediaSession media_session;
  675. media_session.EnableAction(mojom::MediaSessionAction::kPlay);
  676. media_session.SetIsControllable(true);
  677. {
  678. test::MockMediaSessionMojoObserver observer(media_session);
  679. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  680. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  681. }
  682. media_session.AbandonAudioFocusFromClient();
  683. {
  684. test::TestMediaControllerObserver observer(controller());
  685. observer.WaitForEmptyActions();
  686. }
  687. }
  688. TEST_F(MediaControllerTest, ActiveController_Position_Observer_Empty) {
  689. test::MockMediaSession media_session;
  690. media_session.SetIsControllable(true);
  691. absl::optional<MediaPosition> test_position;
  692. {
  693. test::MockMediaSessionMojoObserver observer(media_session);
  694. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  695. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  696. }
  697. {
  698. test::TestMediaControllerObserver observer(controller());
  699. media_session.SimulatePositionChanged(test_position);
  700. observer.WaitForEmptyPosition();
  701. }
  702. }
  703. TEST_F(MediaControllerTest, ActiveController_Position_Observer_WithInfo) {
  704. MediaPosition position(
  705. /*playback_rate=*/1,
  706. /*duration=*/base::Seconds(600),
  707. /*position=*/base::Seconds(300),
  708. /*end_of_media=*/false);
  709. test::MockMediaSession media_session;
  710. media_session.SetIsControllable(true);
  711. absl::optional<MediaPosition> test_position(position);
  712. {
  713. test::MockMediaSessionMojoObserver observer(media_session);
  714. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  715. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  716. }
  717. {
  718. test::TestMediaControllerObserver observer(controller());
  719. media_session.SimulatePositionChanged(test_position);
  720. observer.WaitForNonEmptyPosition();
  721. }
  722. }
  723. TEST_F(MediaControllerTest, ActiveController_Position_AddObserver_Empty) {
  724. test::MockMediaSession media_session;
  725. media_session.SetIsControllable(true);
  726. absl::optional<MediaPosition> test_position;
  727. {
  728. test::MockMediaSessionMojoObserver observer(media_session);
  729. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  730. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  731. }
  732. media_session.SimulatePositionChanged(test_position);
  733. {
  734. test::TestMediaControllerObserver observer(controller());
  735. observer.WaitForEmptyPosition();
  736. }
  737. }
  738. TEST_F(MediaControllerTest, ActiveController_Position_AddObserver_WithInfo) {
  739. MediaPosition position(
  740. /*playback_rate=*/1,
  741. /*duration=*/base::Seconds(600),
  742. /*position=*/base::Seconds(300),
  743. /*end_of_media=*/false);
  744. test::MockMediaSession media_session;
  745. media_session.SetIsControllable(true);
  746. absl::optional<MediaPosition> test_position(position);
  747. {
  748. test::MockMediaSessionMojoObserver observer(media_session);
  749. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  750. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  751. }
  752. media_session.SimulatePositionChanged(test_position);
  753. {
  754. test::TestMediaControllerObserver observer(controller());
  755. observer.WaitForNonEmptyPosition();
  756. }
  757. }
  758. TEST_F(MediaControllerTest, ActiveController_Position_Observer_Abandoned) {
  759. MediaPosition position(
  760. /*playback_rate=*/1,
  761. /*duration=*/base::Seconds(600),
  762. /*position=*/base::Seconds(300),
  763. /*end_of_media=*/false);
  764. test::MockMediaSession media_session;
  765. media_session.SetIsControllable(true);
  766. absl::optional<MediaPosition> test_position(position);
  767. {
  768. test::MockMediaSessionMojoObserver observer(media_session);
  769. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  770. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  771. }
  772. media_session.SimulatePositionChanged(test_position);
  773. media_session.AbandonAudioFocusFromClient();
  774. {
  775. test::TestMediaControllerObserver observer(controller());
  776. observer.WaitForEmptyPosition();
  777. }
  778. }
  779. TEST_F(MediaControllerTest, ActiveController_Observer_Abandoned) {
  780. test::MockMediaSession media_session;
  781. media_session.SetIsControllable(true);
  782. {
  783. test::MockMediaSessionMojoObserver observer(media_session);
  784. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  785. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  786. }
  787. {
  788. test::TestMediaControllerObserver observer(controller());
  789. media_session.AbandonAudioFocusFromClient();
  790. // We should see empty info, metadata, actions, and position flushed since
  791. // the active controller is no longer bound to a media session.
  792. observer.WaitForEmptyInfo();
  793. observer.WaitForEmptyMetadata();
  794. observer.WaitForEmptyActions();
  795. observer.WaitForEmptyPosition();
  796. }
  797. }
  798. TEST_F(MediaControllerTest, ActiveController_AddObserver_Abandoned) {
  799. test::MockMediaSession media_session;
  800. media_session.SetIsControllable(true);
  801. {
  802. test::MockMediaSessionMojoObserver observer(media_session);
  803. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  804. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  805. }
  806. media_session.AbandonAudioFocusFromClient();
  807. {
  808. test::TestMediaControllerObserver observer(controller());
  809. // We should see empty info, metadata, actions, and position since the
  810. // active controller is no longer bound to a media session.
  811. observer.WaitForEmptyInfo();
  812. observer.WaitForEmptyMetadata();
  813. observer.WaitForEmptyActions();
  814. observer.WaitForEmptyPosition();
  815. }
  816. }
  817. TEST_F(MediaControllerTest, ClearImageObserverOnError) {
  818. MediaController controller;
  819. mojo::Remote<mojom::MediaController> controller_remote;
  820. controller.BindToInterface(controller_remote.BindNewPipeAndPassReceiver());
  821. EXPECT_EQ(0u, GetImageObserverCount(controller));
  822. {
  823. test::TestMediaControllerImageObserver observer(controller_remote, 0, 0);
  824. EXPECT_EQ(1u, GetImageObserverCount(controller));
  825. }
  826. EXPECT_EQ(1u, GetImageObserverCount(controller));
  827. base::RunLoop().RunUntilIdle();
  828. EXPECT_EQ(0u, GetImageObserverCount(controller));
  829. }
  830. TEST_F(MediaControllerTest, ActiveController_SimulateImagesChanged) {
  831. test::MockMediaSession media_session;
  832. media_session.SetIsControllable(true);
  833. {
  834. test::MockMediaSessionMojoObserver observer(media_session);
  835. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  836. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  837. }
  838. std::vector<MediaImage> images;
  839. MediaImage image;
  840. image.src = GURL("https://www.google.com");
  841. images.push_back(image);
  842. {
  843. test::TestMediaControllerImageObserver observer(controller(), 0, 0);
  844. // By default, the image is empty but no notification should be received.
  845. EXPECT_TRUE(media_session.last_image_src().is_empty());
  846. // Check that we receive the correct image and that it was requested from
  847. // |media_session| by the controller.
  848. media_session.SetImagesOfType(mojom::MediaSessionImageType::kArtwork,
  849. images);
  850. observer.WaitForExpectedImageOfType(mojom::MediaSessionImageType::kArtwork,
  851. false);
  852. EXPECT_EQ(image.src, media_session.last_image_src());
  853. // Check that we flush the observer with an empty image. Since the image is
  854. // empty the last downloaded image by |media_session| should still be the
  855. // previous image.
  856. media_session.SetImagesOfType(mojom::MediaSessionImageType::kArtwork,
  857. std::vector<MediaImage>());
  858. observer.WaitForExpectedImageOfType(mojom::MediaSessionImageType::kArtwork,
  859. true);
  860. EXPECT_EQ(image.src, media_session.last_image_src());
  861. }
  862. }
  863. TEST_F(MediaControllerTest,
  864. ActiveController_SimulateImagesChanged_ToggleControllable) {
  865. test::MockMediaSession media_session;
  866. media_session.SetIsControllable(true);
  867. {
  868. test::MockMediaSessionMojoObserver observer(media_session);
  869. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  870. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  871. }
  872. std::vector<MediaImage> images;
  873. MediaImage image;
  874. image.src = GURL("https://www.google.com");
  875. images.push_back(image);
  876. media_session.SetImagesOfType(mojom::MediaSessionImageType::kArtwork, images);
  877. {
  878. test::TestMediaControllerImageObserver observer(controller(), 0, 0);
  879. observer.WaitForExpectedImageOfType(mojom::MediaSessionImageType::kArtwork,
  880. false);
  881. EXPECT_EQ(image.src, media_session.last_image_src());
  882. // When the |media_session| becomes uncontrollable it is unbound from the
  883. // media controller and we should flush the observer with an empty image.
  884. media_session.SetIsControllable(false);
  885. observer.WaitForExpectedImageOfType(mojom::MediaSessionImageType::kArtwork,
  886. true);
  887. // When the |media_session| becomes controllable again it will be bound to
  888. // the media controller and we should flush the observer with the current
  889. // images.
  890. media_session.SetIsControllable(true);
  891. observer.WaitForExpectedImageOfType(mojom::MediaSessionImageType::kArtwork,
  892. false);
  893. EXPECT_EQ(image.src, media_session.last_image_src());
  894. }
  895. }
  896. TEST_F(MediaControllerTest,
  897. ActiveController_SimulateImagesChanged_TypeChanged) {
  898. test::MockMediaSession media_session;
  899. media_session.SetIsControllable(true);
  900. {
  901. test::MockMediaSessionMojoObserver observer(media_session);
  902. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  903. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  904. }
  905. std::vector<MediaImage> images;
  906. MediaImage image;
  907. image.src = GURL("https://www.google.com");
  908. images.push_back(image);
  909. media_session.SetImagesOfType(mojom::MediaSessionImageType::kArtwork, images);
  910. {
  911. test::TestMediaControllerImageObserver observer(controller(), 0, 0);
  912. observer.WaitForExpectedImageOfType(mojom::MediaSessionImageType::kArtwork,
  913. false);
  914. EXPECT_EQ(image.src, media_session.last_image_src());
  915. // If we clear all the images associated with the media session we should
  916. // flush all the observers.
  917. media_session.ClearAllImages();
  918. observer.WaitForExpectedImageOfType(mojom::MediaSessionImageType::kArtwork,
  919. true);
  920. EXPECT_EQ(image.src, media_session.last_image_src());
  921. }
  922. }
  923. TEST_F(MediaControllerTest,
  924. ActiveController_SimulateImagesChanged_MinSizeCutoff) {
  925. test::MockMediaSession media_session;
  926. media_session.SetIsControllable(true);
  927. {
  928. test::MockMediaSessionMojoObserver observer(media_session);
  929. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  930. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  931. }
  932. std::vector<MediaImage> images;
  933. MediaImage image1;
  934. image1.src = GURL("https://www.google.com");
  935. image1.sizes.push_back(gfx::Size(1, 1));
  936. media_session.SetImagesOfType(mojom::MediaSessionImageType::kArtwork,
  937. {image1});
  938. {
  939. test::TestMediaControllerImageObserver observer(controller(), 5, 10);
  940. // The observer requires an image that is at least 5px but the only image
  941. // we have is 1px so the observer will not be notified.
  942. EXPECT_TRUE(media_session.last_image_src().is_empty());
  943. MediaImage image2;
  944. image2.src = GURL("https://www.example.com");
  945. image2.sizes.push_back(gfx::Size(10, 10));
  946. // Update the media session with two images, one that is too small and one
  947. // that is the right size. We should receive the second image through the
  948. // observer.
  949. media_session.SetImagesOfType(mojom::MediaSessionImageType::kArtwork,
  950. {image1, image2});
  951. observer.WaitForExpectedImageOfType(mojom::MediaSessionImageType::kArtwork,
  952. false);
  953. EXPECT_EQ(image2.src, media_session.last_image_src());
  954. // Use the first set of images again.
  955. media_session.SetImagesOfType(mojom::MediaSessionImageType::kArtwork,
  956. {image1});
  957. // The observer requires as image that is at least 5px and should now be
  958. // notified that the image was cleared.
  959. observer.WaitForExpectedImageOfType(mojom::MediaSessionImageType::kArtwork,
  960. true);
  961. }
  962. }
  963. TEST_F(MediaControllerTest,
  964. ActiveController_SimulateImagesChanged_DesiredSize) {
  965. test::MockMediaSession media_session;
  966. media_session.SetIsControllable(true);
  967. {
  968. test::MockMediaSessionMojoObserver observer(media_session);
  969. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  970. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  971. }
  972. std::vector<MediaImage> images;
  973. MediaImage image1;
  974. image1.src = GURL("https://www.google.com");
  975. image1.sizes.push_back(gfx::Size(10, 10));
  976. images.push_back(image1);
  977. MediaImage image2;
  978. image2.src = GURL("https://www.example.com");
  979. image2.sizes.push_back(gfx::Size(9, 9));
  980. images.push_back(image2);
  981. media_session.SetImagesOfType(mojom::MediaSessionImageType::kArtwork, images);
  982. {
  983. test::TestMediaControllerImageObserver observer(controller(), 5, 10);
  984. // The media session has two images, but the first one is closer to the 10px
  985. // desired size that the observer has specified. Therefore, the observer
  986. // should receive that image.
  987. media_session.SetImagesOfType(mojom::MediaSessionImageType::kArtwork,
  988. images);
  989. observer.WaitForExpectedImageOfType(mojom::MediaSessionImageType::kArtwork,
  990. false);
  991. EXPECT_EQ(image1.src, media_session.last_image_src());
  992. }
  993. }
  994. TEST_F(MediaControllerTest, ActiveController_Observer_SessionChanged) {
  995. test::MockMediaSession media_session_1;
  996. test::MockMediaSession media_session_2;
  997. media_session_1.SetIsControllable(true);
  998. media_session_2.SetIsControllable(true);
  999. {
  1000. test::TestMediaControllerObserver observer(controller());
  1001. observer.WaitForSession(absl::nullopt);
  1002. }
  1003. {
  1004. test::MockMediaSessionMojoObserver observer(media_session_1);
  1005. RequestAudioFocus(media_session_1, mojom::AudioFocusType::kGain);
  1006. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  1007. }
  1008. {
  1009. test::TestMediaControllerObserver observer(controller());
  1010. observer.WaitForSession(media_session_1.request_id());
  1011. }
  1012. {
  1013. test::TestMediaControllerObserver observer(controller());
  1014. RequestAudioFocus(media_session_2, mojom::AudioFocusType::kGain);
  1015. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  1016. }
  1017. {
  1018. test::TestMediaControllerObserver observer(controller());
  1019. observer.WaitForSession(media_session_2.request_id());
  1020. }
  1021. {
  1022. test::TestMediaControllerObserver observer(controller());
  1023. media_session_2.AbandonAudioFocusFromClient();
  1024. observer.WaitForSession(media_session_1.request_id());
  1025. }
  1026. {
  1027. test::TestMediaControllerObserver observer(controller());
  1028. media_session_1.SetIsControllable(false);
  1029. observer.WaitForSession(absl::nullopt);
  1030. }
  1031. }
  1032. TEST_F(MediaControllerTest, BoundController_Observer_SessionChanged) {
  1033. test::MockMediaSession media_session;
  1034. {
  1035. test::MockMediaSessionMojoObserver observer(media_session);
  1036. RequestAudioFocus(media_session, mojom::AudioFocusType::kGain);
  1037. observer.WaitForState(mojom::MediaSessionInfo::SessionState::kActive);
  1038. }
  1039. mojo::Remote<mojom::MediaController> controller;
  1040. manager()->CreateMediaControllerForSession(
  1041. controller.BindNewPipeAndPassReceiver(), media_session.request_id());
  1042. manager().FlushForTesting();
  1043. {
  1044. test::TestMediaControllerObserver observer(controller);
  1045. observer.WaitForSession(media_session.request_id());
  1046. }
  1047. }
  1048. TEST_F(MediaControllerTest, Manager_SuspendAllSessions) {
  1049. test::MockMediaSession media_session_1;
  1050. test::MockMediaSession media_session_2;
  1051. {
  1052. test::MockMediaSessionMojoObserver observer(media_session_1);
  1053. RequestAudioFocus(media_session_1, mojom::AudioFocusType::kGain);
  1054. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  1055. }
  1056. {
  1057. test::MockMediaSessionMojoObserver observer(media_session_2);
  1058. RequestAudioFocus(media_session_2,
  1059. mojom::AudioFocusType::kGainTransientMayDuck);
  1060. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPlaying);
  1061. }
  1062. manager()->SuspendAllSessions();
  1063. {
  1064. test::MockMediaSessionMojoObserver observer(media_session_1);
  1065. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  1066. }
  1067. {
  1068. test::MockMediaSessionMojoObserver observer(media_session_2);
  1069. observer.WaitForPlaybackState(mojom::MediaPlaybackState::kPaused);
  1070. }
  1071. }
  1072. } // namespace media_session