OLD | NEW |
---|---|
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/media/android/media_session.h" | 5 #include "content/browser/media/android/media_session.h" |
6 | 6 |
7 #include <list> | 7 #include <list> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "content/browser/media/android/media_session_observer.h" | 10 #include "content/browser/media/android/media_session_observer.h" |
11 #include "content/common/content_export.h" | |
mlamouri (slow - plz ping)
2015/06/24 16:15:02
Why do you need that?
whywhat
2015/06/24 18:36:15
Left over from the experimentation I did with the
| |
12 #include "content/public/browser/web_contents.h" | |
13 #include "content/public/browser/web_contents_delegate.h" | |
11 #include "content/public/test/content_browser_test.h" | 14 #include "content/public/test/content_browser_test.h" |
12 #include "content/shell/browser/shell.h" | 15 #include "content/shell/browser/shell.h" |
13 | 16 |
14 namespace content { | 17 using content::WebContents; |
mlamouri (slow - plz ping)
2015/06/24 16:15:02
Maybe you could keep the namespace content and hav
whywhat
2015/06/24 18:36:15
I don't know I'd rather not :)
| |
18 using content::WebContentsDelegate; | |
19 using content::MediaSession; | |
20 using content::MediaSessionObserver; | |
21 | |
22 namespace { | |
15 | 23 |
16 class MockMediaSessionObserver : public MediaSessionObserver { | 24 class MockMediaSessionObserver : public MediaSessionObserver { |
17 public: | 25 public: |
18 MockMediaSessionObserver() | 26 MockMediaSessionObserver() |
19 : received_resume_calls_(0), | 27 : received_resume_calls_(0), |
20 received_suspend_calls_(0) { | 28 received_suspend_calls_(0) { |
21 } | 29 } |
22 | 30 |
23 ~MockMediaSessionObserver() override = default; | 31 ~MockMediaSessionObserver() override = default; |
24 | 32 |
25 // Implements MediaSessionObserver. | 33 // Implements MediaSessionObserver. |
26 void OnSuspend(int player_id) override { | 34 void OnSuspend(int player_id) override { |
27 DCHECK(player_id >= 0); | 35 DCHECK(player_id >= 0); |
28 DCHECK(players_.size() > static_cast<size_t>(player_id)); | 36 DCHECK(players_.size() > static_cast<size_t>(player_id)); |
29 | 37 |
30 ++received_suspend_calls_; | 38 ++received_suspend_calls_; |
31 players_[player_id] = false; | 39 players_[player_id] = false; |
32 } | 40 } |
41 | |
33 void OnResume(int player_id) override { | 42 void OnResume(int player_id) override { |
34 DCHECK(player_id >= 0); | 43 DCHECK(player_id >= 0); |
35 DCHECK(players_.size() > static_cast<size_t>(player_id)); | 44 DCHECK(players_.size() > static_cast<size_t>(player_id)); |
36 | 45 |
37 ++received_resume_calls_; | 46 ++received_resume_calls_; |
38 players_[player_id] = true; | 47 players_[player_id] = true; |
39 } | 48 } |
40 | 49 |
41 int StartNewPlayer() { | 50 int StartNewPlayer() { |
42 players_.push_back(true); | 51 players_.push_back(true); |
(...skipping 20 matching lines...) Expand all Loading... | |
63 | 72 |
64 private: | 73 private: |
65 // Basic representation of the players. The position in the vector is the | 74 // Basic representation of the players. The position in the vector is the |
66 // player_id. The value of the vector is the playing status. | 75 // player_id. The value of the vector is the playing status. |
67 std::vector<bool> players_; | 76 std::vector<bool> players_; |
68 | 77 |
69 int received_resume_calls_; | 78 int received_resume_calls_; |
70 int received_suspend_calls_; | 79 int received_suspend_calls_; |
71 }; | 80 }; |
72 | 81 |
73 class MediaSessionBrowserTest : public ContentBrowserTest { | 82 class MockWebContentsDelegate : public WebContentsDelegate { |
83 public: | |
84 explicit MockWebContentsDelegate(WebContents* web_contents); | |
85 | |
86 void ShowMediaControls(WebContents* web_contents) override; | |
87 | |
88 void HideMediaControls(WebContents* web_contents) override; | |
mlamouri (slow - plz ping)
2015/06/24 16:15:02
I guess these will need to change slightly.
whywhat
2015/06/24 18:36:15
Indeed.
| |
89 | |
90 int show_counter() const; | |
91 int hide_counter() const; | |
92 | |
93 private: | |
94 WebContents* web_contents_; | |
95 int show_counter_; | |
96 int hide_counter_; | |
97 | |
98 DISALLOW_COPY_AND_ASSIGN(MockWebContentsDelegate); | |
99 }; | |
100 | |
101 MockWebContentsDelegate::MockWebContentsDelegate(WebContents* web_contents) | |
102 : web_contents_(web_contents), | |
103 show_counter_(0), | |
104 hide_counter_(0) { | |
105 } | |
106 | |
107 void MockWebContentsDelegate::ShowMediaControls(WebContents* web_contents) { | |
108 EXPECT_EQ(web_contents_, web_contents); | |
109 ++show_counter_; | |
110 } | |
111 | |
112 void MockWebContentsDelegate::HideMediaControls(WebContents* web_contents) { | |
113 EXPECT_EQ(web_contents_, web_contents); | |
114 ++hide_counter_; | |
115 } | |
116 | |
117 int MockWebContentsDelegate::show_counter() const { | |
118 return show_counter_; | |
119 } | |
120 | |
121 int MockWebContentsDelegate::hide_counter() const { | |
122 return hide_counter_; | |
123 } | |
124 | |
125 } // namespace | |
126 | |
127 class MediaSessionBrowserTest : public content::ContentBrowserTest { | |
74 protected: | 128 protected: |
75 MediaSessionBrowserTest() = default; | 129 MediaSessionBrowserTest() = default; |
76 | 130 |
77 void DisableNativeBackend(MediaSession* media_session) { | 131 void SetUpOnMainThread() override { |
78 media_session->ResetJavaRefForTest(); | 132 ContentBrowserTest::SetUpOnMainThread(); |
133 | |
134 mock_web_contents_delegate_.reset( | |
135 new MockWebContentsDelegate(shell()->web_contents())); | |
136 previous_delegate_ = shell()->web_contents()->GetDelegate(); | |
mlamouri (slow - plz ping)
2015/06/24 16:15:02
Do you really need to save it? Isn't the WebConten
whywhat
2015/06/24 18:36:15
Have no idea, better safe than sorry?
| |
137 shell()->web_contents()->SetDelegate(mock_web_contents_delegate_.get()); | |
138 media_session_ = MediaSession::Get(shell()->web_contents()); | |
139 media_session_->ResetJavaRefForTest(); | |
140 ASSERT_TRUE(media_session_); | |
79 } | 141 } |
80 | 142 |
81 void StartNewPlayer(MediaSession* media_session, | 143 void TearDownOnMainThread() override { |
82 MockMediaSessionObserver* media_session_observer, | 144 media_session_->RemoveAllPlayersForTest(); |
145 media_session_ = nullptr; | |
146 | |
147 shell()->web_contents()->SetDelegate(previous_delegate_); | |
148 | |
149 ContentBrowserTest::TearDownOnMainThread(); | |
150 } | |
151 | |
152 void StartNewPlayer(MockMediaSessionObserver* media_session_observer, | |
83 MediaSession::Type type) { | 153 MediaSession::Type type) { |
84 bool result = media_session->AddPlayer( | 154 bool result = AddPlayer( |
85 media_session_observer, | 155 media_session_observer, media_session_observer->StartNewPlayer(), type); |
86 media_session_observer->StartNewPlayer(), | |
87 type); | |
88 EXPECT_TRUE(result); | 156 EXPECT_TRUE(result); |
89 } | 157 } |
90 | 158 |
91 void SuspendSession(MediaSession* media_session) { | 159 bool AddPlayer(MockMediaSessionObserver* media_session_observer, |
92 media_session->OnSuspend(true); | 160 int player_id, |
161 MediaSession::Type type) { | |
162 return media_session_->AddPlayer(media_session_observer, player_id, type); | |
93 } | 163 } |
94 | 164 |
95 void ResumeSession(MediaSession* media_session) { | 165 void RemovePlayer( |
96 media_session->OnResume(); | 166 MockMediaSessionObserver* media_session_observer, int player_id) { |
167 media_session_->RemovePlayer(media_session_observer, player_id); | |
97 } | 168 } |
98 | 169 |
99 bool HasAudioFocus(MediaSession* media_session) { | 170 void RemovePlayers( |
100 return media_session->IsActiveForTest(); | 171 MockMediaSessionObserver* media_session_observer) { |
172 media_session_->RemovePlayers(media_session_observer); | |
101 } | 173 } |
102 | 174 |
103 MediaSession::Type GetSessionType(MediaSession* media_session) { | 175 void SuspendSession(bool isTemporary) { |
104 return media_session->audio_focus_type_for_test(); | 176 media_session_->OnSuspend(NULL, NULL, isTemporary); |
mlamouri (slow - plz ping)
2015/06/24 16:15:02
s/NULL/nullptr/g
whywhat
2015/06/24 18:36:16
Done.
| |
105 } | 177 } |
106 | 178 |
107 private: | 179 void ResumeSession() { |
180 media_session_->OnResume(NULL, NULL); | |
mlamouri (slow - plz ping)
2015/06/24 16:15:02
nit: s/NULL/nullptr/g
whywhat
2015/06/24 18:36:15
Done.
| |
181 } | |
182 | |
183 bool HasAudioFocus() { | |
184 return media_session_->IsActiveForTest(); | |
185 } | |
186 | |
187 MediaSession::Type GetSessionType() { | |
188 return media_session_->audio_focus_type_for_test(); | |
189 } | |
190 | |
191 const MockWebContentsDelegate* mock_web_contents_delegate() { | |
192 return mock_web_contents_delegate_.get(); | |
193 } | |
194 | |
195 protected: | |
196 scoped_ptr<MockWebContentsDelegate> mock_web_contents_delegate_; | |
197 | |
198 MediaSession* media_session_; | |
199 | |
200 WebContentsDelegate* previous_delegate_; | |
201 | |
108 DISALLOW_COPY_AND_ASSIGN(MediaSessionBrowserTest); | 202 DISALLOW_COPY_AND_ASSIGN(MediaSessionBrowserTest); |
109 }; | 203 }; |
110 | 204 |
111 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 205 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
112 PlayersFromSameObserverDoNotStopEachOtherInSameSession) { | 206 PlayersFromSameObserverDoNotStopEachOtherInSameSession) { |
113 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
114 ASSERT_TRUE(media_session); | |
115 DisableNativeBackend(media_session); | |
116 | |
117 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 207 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
118 new MockMediaSessionObserver); | 208 new MockMediaSessionObserver); |
119 | 209 |
120 StartNewPlayer(media_session, media_session_observer.get(), | 210 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
121 MediaSession::Type::Content); | 211 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
122 StartNewPlayer(media_session, media_session_observer.get(), | 212 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
123 MediaSession::Type::Content); | |
124 StartNewPlayer(media_session, media_session_observer.get(), | |
125 MediaSession::Type::Content); | |
126 | 213 |
127 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 214 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
128 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 215 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
129 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 216 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
130 | |
131 media_session->RemovePlayers(media_session_observer.get()); | |
132 } | 217 } |
133 | 218 |
134 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 219 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
135 PlayersFromManyObserverDoNotStopEachOtherInSameSession) { | 220 PlayersFromManyObserverDoNotStopEachOtherInSameSession) { |
136 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
137 ASSERT_TRUE(media_session); | |
138 DisableNativeBackend(media_session); | |
139 | |
140 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( | 221 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( |
141 new MockMediaSessionObserver); | 222 new MockMediaSessionObserver); |
142 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( | 223 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( |
143 new MockMediaSessionObserver); | 224 new MockMediaSessionObserver); |
144 scoped_ptr<MockMediaSessionObserver> media_session_observer_3( | 225 scoped_ptr<MockMediaSessionObserver> media_session_observer_3( |
145 new MockMediaSessionObserver); | 226 new MockMediaSessionObserver); |
146 | 227 |
147 StartNewPlayer(media_session, media_session_observer_1.get(), | 228 StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content); |
148 MediaSession::Type::Content); | 229 |
149 StartNewPlayer(media_session, media_session_observer_2.get(), | 230 StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content); |
150 MediaSession::Type::Content); | 231 StartNewPlayer(media_session_observer_3.get(), MediaSession::Type::Content); |
151 StartNewPlayer(media_session, media_session_observer_3.get(), | |
152 MediaSession::Type::Content); | |
153 | 232 |
154 EXPECT_TRUE(media_session_observer_1->IsPlaying(0)); | 233 EXPECT_TRUE(media_session_observer_1->IsPlaying(0)); |
155 EXPECT_TRUE(media_session_observer_2->IsPlaying(0)); | 234 EXPECT_TRUE(media_session_observer_2->IsPlaying(0)); |
156 EXPECT_TRUE(media_session_observer_3->IsPlaying(0)); | 235 EXPECT_TRUE(media_session_observer_3->IsPlaying(0)); |
157 | |
158 media_session->RemovePlayers(media_session_observer_1.get()); | |
159 media_session->RemovePlayers(media_session_observer_2.get()); | |
160 media_session->RemovePlayers(media_session_observer_3.get()); | |
161 } | 236 } |
162 | 237 |
163 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 238 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
164 SuspendedMediaSessionStopsPlayers) { | 239 SuspendedMediaSessionStopsPlayers) { |
165 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
166 ASSERT_TRUE(media_session); | |
167 DisableNativeBackend(media_session); | |
168 | |
169 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 240 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
170 new MockMediaSessionObserver); | 241 new MockMediaSessionObserver); |
171 | 242 |
172 StartNewPlayer(media_session, media_session_observer.get(), | 243 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
173 MediaSession::Type::Content); | 244 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
174 StartNewPlayer(media_session, media_session_observer.get(), | 245 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
175 MediaSession::Type::Content); | |
176 StartNewPlayer(media_session, media_session_observer.get(), | |
177 MediaSession::Type::Content); | |
178 | 246 |
179 SuspendSession(media_session); | 247 SuspendSession(true); |
180 | 248 |
181 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 249 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
182 EXPECT_FALSE(media_session_observer->IsPlaying(1)); | 250 EXPECT_FALSE(media_session_observer->IsPlaying(1)); |
183 EXPECT_FALSE(media_session_observer->IsPlaying(2)); | 251 EXPECT_FALSE(media_session_observer->IsPlaying(2)); |
184 | |
185 media_session->RemovePlayers(media_session_observer.get()); | |
186 } | 252 } |
187 | 253 |
188 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 254 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
189 ResumedMediaSessionRestartsPlayers) { | 255 ResumedMediaSessionRestartsPlayers) { |
190 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
191 ASSERT_TRUE(media_session); | |
192 DisableNativeBackend(media_session); | |
193 | |
194 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 256 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
195 new MockMediaSessionObserver); | 257 new MockMediaSessionObserver); |
196 | 258 |
197 StartNewPlayer(media_session, media_session_observer.get(), | 259 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
198 MediaSession::Type::Content); | 260 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
199 StartNewPlayer(media_session, media_session_observer.get(), | 261 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
200 MediaSession::Type::Content); | |
201 StartNewPlayer(media_session, media_session_observer.get(), | |
202 MediaSession::Type::Content); | |
203 | 262 |
204 SuspendSession(media_session); | 263 SuspendSession(true); |
205 ResumeSession(media_session); | 264 ResumeSession(); |
206 | 265 |
207 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 266 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
208 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 267 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
209 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 268 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
210 | |
211 media_session->RemovePlayers(media_session_observer.get()); | |
212 } | 269 } |
213 | 270 |
214 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 271 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
215 StartedPlayerOnSuspendedSessionPlaysAlone) { | 272 StartedPlayerOnSuspendedSessionPlaysAlone) { |
216 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
217 ASSERT_TRUE(media_session); | |
218 DisableNativeBackend(media_session); | |
219 | |
220 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 273 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
221 new MockMediaSessionObserver); | 274 new MockMediaSessionObserver); |
222 | 275 |
223 StartNewPlayer(media_session, media_session_observer.get(), | 276 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
224 MediaSession::Type::Content); | |
225 | 277 |
226 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 278 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
227 | 279 |
228 SuspendSession(media_session); | 280 SuspendSession(true); |
229 | 281 |
230 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 282 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
231 | 283 |
232 StartNewPlayer(media_session, media_session_observer.get(), | 284 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
233 MediaSession::Type::Content); | |
234 | 285 |
235 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 286 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
236 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 287 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
237 | 288 |
238 StartNewPlayer(media_session, media_session_observer.get(), | 289 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
239 MediaSession::Type::Content); | |
240 | 290 |
241 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 291 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
242 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 292 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
243 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 293 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
244 | |
245 media_session->RemovePlayers(media_session_observer.get()); | |
246 } | 294 } |
247 | 295 |
248 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, AudioFocusInitialState) { | 296 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, AudioFocusInitialState) { |
249 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | 297 EXPECT_FALSE(HasAudioFocus()); |
250 ASSERT_TRUE(media_session); | |
251 DisableNativeBackend(media_session); | |
252 | |
253 EXPECT_FALSE(HasAudioFocus(media_session)); | |
254 } | 298 } |
255 | 299 |
256 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StartPlayerGivesFocus) { | 300 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, StartPlayerGivesFocus) { |
257 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
258 ASSERT_TRUE(media_session); | |
259 DisableNativeBackend(media_session); | |
260 | |
261 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 301 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
262 new MockMediaSessionObserver); | 302 new MockMediaSessionObserver); |
263 | 303 |
264 StartNewPlayer(media_session, media_session_observer.get(), | 304 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
265 MediaSession::Type::Content); | |
266 | 305 |
267 EXPECT_TRUE(HasAudioFocus(media_session)); | 306 EXPECT_TRUE(HasAudioFocus()); |
268 | |
269 media_session->RemovePlayers(media_session_observer.get()); | |
270 } | 307 } |
271 | 308 |
272 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, SuspendGivesAwayAudioFocus) { | 309 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, SuspendGivesAwayAudioFocus) { |
273 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
274 ASSERT_TRUE(media_session); | |
275 DisableNativeBackend(media_session); | |
276 | |
277 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 310 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
278 new MockMediaSessionObserver); | 311 new MockMediaSessionObserver); |
279 | 312 |
280 StartNewPlayer(media_session, media_session_observer.get(), | 313 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
281 MediaSession::Type::Content); | |
282 | 314 |
283 SuspendSession(media_session); | 315 SuspendSession(true); |
284 | 316 |
285 EXPECT_FALSE(HasAudioFocus(media_session)); | 317 EXPECT_FALSE(HasAudioFocus()); |
286 | |
287 media_session->RemovePlayers(media_session_observer.get()); | |
288 } | 318 } |
289 | 319 |
290 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeGivesBackAudioFocus) { | 320 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumeGivesBackAudioFocus) { |
291 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
292 ASSERT_TRUE(media_session); | |
293 DisableNativeBackend(media_session); | |
294 | |
295 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 321 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
296 new MockMediaSessionObserver); | 322 new MockMediaSessionObserver); |
297 | 323 |
298 StartNewPlayer(media_session, media_session_observer.get(), | 324 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
299 MediaSession::Type::Content); | |
300 | 325 |
301 SuspendSession(media_session); | 326 SuspendSession(true); |
302 ResumeSession(media_session); | 327 ResumeSession(); |
303 | 328 |
304 EXPECT_TRUE(HasAudioFocus(media_session)); | 329 EXPECT_TRUE(HasAudioFocus()); |
305 | |
306 media_session->RemovePlayers(media_session_observer.get()); | |
307 } | 330 } |
308 | 331 |
309 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 332 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
310 RemovingLastPlayerDropsAudioFocus_1) { | 333 RemovingLastPlayerDropsAudioFocus) { |
311 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
312 ASSERT_TRUE(media_session); | |
313 DisableNativeBackend(media_session); | |
314 | |
315 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 334 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
316 new MockMediaSessionObserver); | 335 new MockMediaSessionObserver); |
317 | 336 |
318 StartNewPlayer(media_session, media_session_observer.get(), | 337 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
319 MediaSession::Type::Content); | 338 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
320 StartNewPlayer(media_session, media_session_observer.get(), | 339 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
321 MediaSession::Type::Content); | |
322 StartNewPlayer(media_session, media_session_observer.get(), | |
323 MediaSession::Type::Content); | |
324 | 340 |
325 media_session->RemovePlayer(media_session_observer.get(), 0); | 341 RemovePlayer(media_session_observer.get(), 0); |
326 EXPECT_TRUE(HasAudioFocus(media_session)); | 342 EXPECT_TRUE(HasAudioFocus()); |
327 media_session->RemovePlayer(media_session_observer.get(), 1); | 343 RemovePlayer(media_session_observer.get(), 1); |
328 EXPECT_TRUE(HasAudioFocus(media_session)); | 344 EXPECT_TRUE(HasAudioFocus()); |
329 media_session->RemovePlayer(media_session_observer.get(), 2); | 345 RemovePlayer(media_session_observer.get(), 2); |
330 EXPECT_FALSE(HasAudioFocus(media_session)); | 346 EXPECT_FALSE(HasAudioFocus()); |
331 } | 347 } |
332 | 348 |
333 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 349 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
334 RemovingLastPlayerDropsAudioFocus_2) { | 350 RemovingLastPlayerFromManyObserversDropsAudioFocus) { |
335 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
336 ASSERT_TRUE(media_session); | |
337 DisableNativeBackend(media_session); | |
338 | |
339 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( | 351 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( |
340 new MockMediaSessionObserver); | 352 new MockMediaSessionObserver); |
341 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( | 353 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( |
342 new MockMediaSessionObserver); | 354 new MockMediaSessionObserver); |
343 scoped_ptr<MockMediaSessionObserver> media_session_observer_3( | 355 scoped_ptr<MockMediaSessionObserver> media_session_observer_3( |
344 new MockMediaSessionObserver); | 356 new MockMediaSessionObserver); |
345 | 357 |
346 StartNewPlayer(media_session, media_session_observer_1.get(), | 358 StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content); |
347 MediaSession::Type::Content); | 359 StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content); |
348 StartNewPlayer(media_session, media_session_observer_2.get(), | 360 StartNewPlayer(media_session_observer_3.get(), MediaSession::Type::Content); |
349 MediaSession::Type::Content); | 361 |
350 StartNewPlayer(media_session, media_session_observer_3.get(), | 362 RemovePlayer(media_session_observer_1.get(), 0); |
351 MediaSession::Type::Content); | 363 EXPECT_TRUE(HasAudioFocus()); |
352 | 364 RemovePlayer(media_session_observer_2.get(), 0); |
353 media_session->RemovePlayer(media_session_observer_1.get(), 0); | 365 EXPECT_TRUE(HasAudioFocus()); |
354 EXPECT_TRUE(HasAudioFocus(media_session)); | 366 RemovePlayer(media_session_observer_3.get(), 0); |
355 media_session->RemovePlayer(media_session_observer_2.get(), 0); | 367 EXPECT_FALSE(HasAudioFocus()); |
356 EXPECT_TRUE(HasAudioFocus(media_session)); | 368 } |
357 media_session->RemovePlayer(media_session_observer_3.get(), 0); | 369 |
358 EXPECT_FALSE(HasAudioFocus(media_session)); | 370 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
359 } | 371 RemovingAllPlayersFromObserversDropsAudioFocus) { |
360 | |
361 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | |
362 RemovingLastPlayerDropsAudioFocus_3) { | |
363 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
364 ASSERT_TRUE(media_session); | |
365 DisableNativeBackend(media_session); | |
366 | |
367 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( | 372 scoped_ptr<MockMediaSessionObserver> media_session_observer_1( |
368 new MockMediaSessionObserver); | 373 new MockMediaSessionObserver); |
369 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( | 374 scoped_ptr<MockMediaSessionObserver> media_session_observer_2( |
370 new MockMediaSessionObserver); | 375 new MockMediaSessionObserver); |
371 | 376 |
372 StartNewPlayer(media_session, media_session_observer_1.get(), | 377 StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content); |
373 MediaSession::Type::Content); | 378 StartNewPlayer(media_session_observer_1.get(), MediaSession::Type::Content); |
374 StartNewPlayer(media_session, media_session_observer_1.get(), | 379 StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content); |
375 MediaSession::Type::Content); | 380 StartNewPlayer(media_session_observer_2.get(), MediaSession::Type::Content); |
376 StartNewPlayer(media_session, media_session_observer_2.get(), | 381 |
377 MediaSession::Type::Content); | 382 RemovePlayers(media_session_observer_1.get()); |
378 StartNewPlayer(media_session, media_session_observer_2.get(), | 383 EXPECT_TRUE(HasAudioFocus()); |
379 MediaSession::Type::Content); | 384 RemovePlayers(media_session_observer_2.get()); |
380 | 385 EXPECT_FALSE(HasAudioFocus()); |
381 media_session->RemovePlayers(media_session_observer_1.get()); | |
382 EXPECT_TRUE(HasAudioFocus(media_session)); | |
383 media_session->RemovePlayers(media_session_observer_2.get()); | |
384 EXPECT_FALSE(HasAudioFocus(media_session)); | |
385 } | 386 } |
386 | 387 |
387 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumePlayGivesAudioFocus) { | 388 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ResumePlayGivesAudioFocus) { |
388 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | 389 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
389 ASSERT_TRUE(media_session); | 390 new MockMediaSessionObserver); |
390 DisableNativeBackend(media_session); | 391 |
391 | 392 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
392 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 393 |
393 new MockMediaSessionObserver); | 394 RemovePlayer(media_session_observer.get(), 0); |
394 | 395 EXPECT_FALSE(HasAudioFocus()); |
395 StartNewPlayer(media_session, media_session_observer.get(), | 396 |
396 MediaSession::Type::Content); | 397 EXPECT_TRUE(AddPlayer( |
397 | 398 media_session_observer.get(), 0, MediaSession::Type::Content)); |
398 media_session->RemovePlayer(media_session_observer.get(), 0); | 399 EXPECT_TRUE(HasAudioFocus()); |
399 EXPECT_FALSE(HasAudioFocus(media_session)); | 400 } |
400 | 401 |
401 EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 0, | 402 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
402 MediaSession::Type::Content)); | 403 ResumeSuspendAreSentOnlyOncePerPlayers) { |
403 EXPECT_TRUE(HasAudioFocus(media_session)); | 404 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
404 | 405 new MockMediaSessionObserver); |
405 media_session->RemovePlayers(media_session_observer.get()); | 406 |
406 } | 407 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
407 | 408 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
408 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 409 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
409 ResumeSuspendAreSentOnlyOncePerPlayers_1) { | |
410 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
411 ASSERT_TRUE(media_session); | |
412 DisableNativeBackend(media_session); | |
413 | |
414 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
415 new MockMediaSessionObserver); | |
416 | |
417 StartNewPlayer(media_session, media_session_observer.get(), | |
418 MediaSession::Type::Content); | |
419 StartNewPlayer(media_session, media_session_observer.get(), | |
420 MediaSession::Type::Content); | |
421 StartNewPlayer(media_session, media_session_observer.get(), | |
422 MediaSession::Type::Content); | |
423 | 410 |
424 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); | 411 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); |
425 EXPECT_EQ(0, media_session_observer->received_resume_calls()); | 412 EXPECT_EQ(0, media_session_observer->received_resume_calls()); |
426 | 413 |
427 SuspendSession(media_session); | 414 SuspendSession(true); |
428 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); | 415 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); |
429 | 416 |
430 ResumeSession(media_session); | 417 ResumeSession(); |
431 EXPECT_EQ(3, media_session_observer->received_resume_calls()); | 418 EXPECT_EQ(3, media_session_observer->received_resume_calls()); |
432 | 419 } |
433 media_session->RemovePlayers(media_session_observer.get()); | 420 |
434 } | 421 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
435 | 422 ResumeSuspendAreSentOnlyOncePerPlayersAddedTwice) { |
436 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 423 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
437 ResumeSuspendAreSentOnlyOncePerPlayers_2) { | 424 new MockMediaSessionObserver); |
438 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | 425 |
439 ASSERT_TRUE(media_session); | 426 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
440 DisableNativeBackend(media_session); | 427 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
441 | 428 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
442 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
443 new MockMediaSessionObserver); | |
444 | |
445 StartNewPlayer(media_session, media_session_observer.get(), | |
446 MediaSession::Type::Content); | |
447 StartNewPlayer(media_session, media_session_observer.get(), | |
448 MediaSession::Type::Content); | |
449 StartNewPlayer(media_session, media_session_observer.get(), | |
450 MediaSession::Type::Content); | |
451 | 429 |
452 // Adding the three players above again. | 430 // Adding the three players above again. |
453 EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 0, | 431 EXPECT_TRUE(AddPlayer( |
454 MediaSession::Type::Content)); | 432 media_session_observer.get(), 0, MediaSession::Type::Content)); |
455 EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 1, | 433 EXPECT_TRUE(AddPlayer( |
456 MediaSession::Type::Content)); | 434 media_session_observer.get(), 1, MediaSession::Type::Content)); |
457 EXPECT_TRUE(media_session->AddPlayer(media_session_observer.get(), 2, | 435 EXPECT_TRUE(AddPlayer( |
458 MediaSession::Type::Content)); | 436 media_session_observer.get(), 2, MediaSession::Type::Content)); |
459 | 437 |
460 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); | 438 EXPECT_EQ(0, media_session_observer->received_suspend_calls()); |
461 EXPECT_EQ(0, media_session_observer->received_resume_calls()); | 439 EXPECT_EQ(0, media_session_observer->received_resume_calls()); |
462 | 440 |
463 SuspendSession(media_session); | 441 SuspendSession(true); |
464 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); | 442 EXPECT_EQ(3, media_session_observer->received_suspend_calls()); |
465 | 443 |
466 ResumeSession(media_session); | 444 ResumeSession(); |
467 EXPECT_EQ(3, media_session_observer->received_resume_calls()); | 445 EXPECT_EQ(3, media_session_observer->received_resume_calls()); |
468 | |
469 media_session->RemovePlayers(media_session_observer.get()); | |
470 } | 446 } |
471 | 447 |
472 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | 448 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, |
473 RemovingTheSamePlayerTwiceIsANoop) { | 449 RemovingTheSamePlayerTwiceIsANoop) { |
474 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | 450 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
475 ASSERT_TRUE(media_session); | 451 new MockMediaSessionObserver); |
476 DisableNativeBackend(media_session); | 452 |
477 | 453 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
478 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 454 |
479 new MockMediaSessionObserver); | 455 RemovePlayer(media_session_observer.get(), 0); |
480 | 456 RemovePlayer(media_session_observer.get(), 0); |
481 StartNewPlayer(media_session, media_session_observer.get(), | |
482 MediaSession::Type::Content); | |
483 | |
484 media_session->RemovePlayer(media_session_observer.get(), 0); | |
485 media_session->RemovePlayer(media_session_observer.get(), 0); | |
486 | |
487 media_session->RemovePlayers(media_session_observer.get()); | |
488 } | 457 } |
489 | 458 |
490 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, MediaSessionType) { | 459 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, MediaSessionType) { |
491 MediaSession* media_session = MediaSession::Get(shell()->web_contents()); | |
492 ASSERT_TRUE(media_session); | |
493 DisableNativeBackend(media_session); | |
494 | |
495 scoped_ptr<MockMediaSessionObserver> media_session_observer( | 460 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
496 new MockMediaSessionObserver); | 461 new MockMediaSessionObserver); |
497 | 462 |
498 // Starting a player with a given type should set the session to that type. | 463 // Starting a player with a given type should set the session to that type. |
499 StartNewPlayer(media_session, media_session_observer.get(), | 464 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); |
500 MediaSession::Type::Transient); | 465 EXPECT_EQ(MediaSession::Type::Transient, GetSessionType()); |
501 EXPECT_EQ(MediaSession::Type::Transient, GetSessionType(media_session)); | |
502 | 466 |
503 // Adding a player of the same type should have no effect on the type. | 467 // Adding a player of the same type should have no effect on the type. |
504 StartNewPlayer(media_session, media_session_observer.get(), | 468 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); |
505 MediaSession::Type::Transient); | 469 EXPECT_EQ(MediaSession::Type::Transient, GetSessionType()); |
506 EXPECT_EQ(MediaSession::Type::Transient, GetSessionType(media_session)); | |
507 | 470 |
508 // Adding a player of Content type should override the current type. | 471 // Adding a player of Content type should override the current type. |
509 StartNewPlayer(media_session, media_session_observer.get(), | 472 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); |
510 MediaSession::Type::Content); | 473 EXPECT_EQ(MediaSession::Type::Content, GetSessionType()); |
511 EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session)); | |
512 | 474 |
513 // Adding a player of the Transient type should have no effect on the type. | 475 // Adding a player of the Transient type should have no effect on the type. |
514 StartNewPlayer(media_session, media_session_observer.get(), | 476 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); |
515 MediaSession::Type::Transient); | 477 EXPECT_EQ(MediaSession::Type::Content, GetSessionType()); |
516 EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session)); | |
517 | 478 |
518 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 479 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
519 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 480 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
520 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 481 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
521 EXPECT_TRUE(media_session_observer->IsPlaying(3)); | 482 EXPECT_TRUE(media_session_observer->IsPlaying(3)); |
522 | 483 |
523 SuspendSession(media_session); | 484 SuspendSession(true); |
524 | 485 |
525 EXPECT_FALSE(media_session_observer->IsPlaying(0)); | 486 EXPECT_FALSE(media_session_observer->IsPlaying(0)); |
526 EXPECT_FALSE(media_session_observer->IsPlaying(1)); | 487 EXPECT_FALSE(media_session_observer->IsPlaying(1)); |
527 EXPECT_FALSE(media_session_observer->IsPlaying(2)); | 488 EXPECT_FALSE(media_session_observer->IsPlaying(2)); |
528 EXPECT_FALSE(media_session_observer->IsPlaying(3)); | 489 EXPECT_FALSE(media_session_observer->IsPlaying(3)); |
529 | 490 |
530 EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session)); | 491 EXPECT_EQ(MediaSession::Type::Content, GetSessionType()); |
531 | 492 |
532 ResumeSession(media_session); | 493 ResumeSession(); |
533 | 494 |
534 EXPECT_TRUE(media_session_observer->IsPlaying(0)); | 495 EXPECT_TRUE(media_session_observer->IsPlaying(0)); |
535 EXPECT_TRUE(media_session_observer->IsPlaying(1)); | 496 EXPECT_TRUE(media_session_observer->IsPlaying(1)); |
536 EXPECT_TRUE(media_session_observer->IsPlaying(2)); | 497 EXPECT_TRUE(media_session_observer->IsPlaying(2)); |
537 EXPECT_TRUE(media_session_observer->IsPlaying(3)); | 498 EXPECT_TRUE(media_session_observer->IsPlaying(3)); |
538 | 499 |
539 EXPECT_EQ(MediaSession::Type::Content, GetSessionType(media_session)); | 500 EXPECT_EQ(MediaSession::Type::Content, GetSessionType()); |
540 | 501 } |
541 media_session->RemovePlayers(media_session_observer.get()); | 502 |
542 } | 503 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsShowForContent) { |
543 | 504 scoped_ptr<MockMediaSessionObserver> media_session_observer( |
544 } // namespace content | 505 new MockMediaSessionObserver); |
506 | |
507 // Starting a player with a content type should show the media controls. | |
508 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
509 | |
510 EXPECT_EQ(1, mock_web_contents_delegate()->show_counter()); | |
511 } | |
512 | |
513 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsNoShowForTransient) { | |
514 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
515 new MockMediaSessionObserver); | |
516 | |
517 // Starting a player with a content type should show the media controls. | |
518 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | |
519 | |
520 EXPECT_EQ(0, mock_web_contents_delegate()->show_counter()); | |
521 } | |
522 | |
523 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsHideWhenStopped) { | |
524 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
525 new MockMediaSessionObserver); | |
526 | |
527 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
528 | |
529 RemovePlayers(media_session_observer.get()); | |
530 | |
531 EXPECT_EQ(1, mock_web_contents_delegate()->hide_counter()); | |
532 } | |
533 | |
534 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsShownAcceptTransient) { | |
535 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
536 new MockMediaSessionObserver); | |
537 | |
538 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
539 | |
540 // Transient player join the session without affecting the controls. | |
541 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | |
542 | |
543 EXPECT_EQ(1, mock_web_contents_delegate()->show_counter()); | |
544 EXPECT_EQ(0, mock_web_contents_delegate()->hide_counter()); | |
545 } | |
546 | |
547 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | |
548 ControlsShownAfterContentAdded) { | |
549 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
550 new MockMediaSessionObserver); | |
551 | |
552 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | |
553 | |
554 EXPECT_EQ(0, mock_web_contents_delegate()->show_counter()); | |
555 | |
556 // The controls are shown when the content player is added. | |
557 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
558 | |
559 EXPECT_EQ(1, mock_web_contents_delegate()->show_counter()); | |
560 } | |
561 | |
562 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | |
563 ControlsStayIfOnlyOnePlayerHasBeenPaused) { | |
564 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
565 new MockMediaSessionObserver); | |
566 | |
567 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
568 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | |
569 | |
570 // Removing only content player doesn't hide the controls since the session | |
571 // is still active. | |
572 RemovePlayer(media_session_observer.get(), 0); | |
573 | |
574 EXPECT_EQ(0, mock_web_contents_delegate()->hide_counter()); | |
575 } | |
576 | |
577 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | |
578 ControlsHideWhenTheLastPlayerIsStopped) { | |
579 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
580 new MockMediaSessionObserver); | |
581 | |
582 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
583 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
584 | |
585 RemovePlayer(media_session_observer.get(), 0); | |
586 | |
587 EXPECT_EQ(0, mock_web_contents_delegate()->hide_counter()); | |
588 | |
589 RemovePlayer(media_session_observer.get(), 1); | |
590 | |
591 EXPECT_EQ(1, mock_web_contents_delegate()->hide_counter()); | |
592 } | |
593 | |
594 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | |
595 ControlsHideWhenTheAllPlayersAreRemoved) { | |
mlamouri (slow - plz ping)
2015/06/24 16:15:02
nit: ControlsHideWhenAllThePlayersAreRemoved
whywhat
2015/06/24 18:36:15
Done.
| |
596 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
597 new MockMediaSessionObserver); | |
598 | |
599 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
600 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
601 | |
602 EXPECT_EQ(0, mock_web_contents_delegate()->hide_counter()); | |
603 | |
604 RemovePlayers(media_session_observer.get()); | |
605 | |
606 EXPECT_EQ(1, mock_web_contents_delegate()->hide_counter()); | |
607 } | |
608 | |
609 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | |
610 SuspendTemporaryUpdatesControls) { | |
611 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
612 new MockMediaSessionObserver); | |
613 | |
614 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
615 | |
616 EXPECT_EQ(1, mock_web_contents_delegate()->show_counter()); | |
617 | |
618 SuspendSession(true); | |
619 | |
620 EXPECT_EQ(2, mock_web_contents_delegate()->show_counter()); | |
621 // Temporary suspend doesn't hide controls. | |
622 EXPECT_EQ(0, mock_web_contents_delegate()->hide_counter()); | |
623 } | |
624 | |
625 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, ControlsUpdatedWhenResumed) { | |
626 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
627 new MockMediaSessionObserver); | |
628 | |
629 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
630 SuspendSession(true); | |
631 ResumeSession(); | |
632 | |
633 EXPECT_EQ(3, mock_web_contents_delegate()->show_counter()); | |
634 } | |
635 | |
636 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | |
637 ControlsHideWhenSessionSuspendedPermanently) { | |
638 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
639 new MockMediaSessionObserver); | |
640 | |
641 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
642 | |
643 SuspendSession(false); | |
644 | |
645 EXPECT_EQ(1, mock_web_contents_delegate()->hide_counter()); | |
646 } | |
647 | |
648 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | |
649 ControlsHideWhenSessionChangesFromContentToTransient) { | |
650 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
651 new MockMediaSessionObserver); | |
652 | |
653 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
654 SuspendSession(true); | |
655 | |
656 // This should reset the session and change it to a transient, so | |
657 // hide the controls. | |
658 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Transient); | |
659 | |
660 EXPECT_EQ(2, mock_web_contents_delegate()->show_counter()); | |
661 EXPECT_EQ(1, mock_web_contents_delegate()->hide_counter()); | |
662 } | |
663 | |
664 IN_PROC_BROWSER_TEST_F(MediaSessionBrowserTest, | |
665 ControlsUpdatedWhenNewPlayerResetsSession) { | |
666 scoped_ptr<MockMediaSessionObserver> media_session_observer( | |
667 new MockMediaSessionObserver); | |
668 | |
669 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
670 SuspendSession(true); | |
671 | |
672 // This should reset the session and update the controls. | |
673 StartNewPlayer(media_session_observer.get(), MediaSession::Type::Content); | |
674 | |
675 EXPECT_EQ(3, mock_web_contents_delegate()->show_counter()); | |
676 } | |
mlamouri (slow - plz ping)
2015/06/24 16:15:02
Can you add a test that call AddPlayer() on an alr
whywhat
2015/06/24 18:36:15
Done.
| |
OLD | NEW |