OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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 "media/blink/webmediaplayer_impl.h" | 5 #include "media/blink/webmediaplayer_impl.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 | 10 |
(...skipping 17 matching lines...) Expand all Loading... |
28 #include "testing/gmock/include/gmock/gmock.h" | 28 #include "testing/gmock/include/gmock/gmock.h" |
29 #include "testing/gtest/include/gtest/gtest.h" | 29 #include "testing/gtest/include/gtest/gtest.h" |
30 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h" | 30 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h" |
31 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h" | 31 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h" |
32 #include "third_party/WebKit/public/platform/WebSize.h" | 32 #include "third_party/WebKit/public/platform/WebSize.h" |
33 #include "third_party/WebKit/public/web/WebFrameClient.h" | 33 #include "third_party/WebKit/public/web/WebFrameClient.h" |
34 #include "third_party/WebKit/public/web/WebLocalFrame.h" | 34 #include "third_party/WebKit/public/web/WebLocalFrame.h" |
35 #include "third_party/WebKit/public/web/WebView.h" | 35 #include "third_party/WebKit/public/web/WebView.h" |
36 #include "url/gurl.h" | 36 #include "url/gurl.h" |
37 | 37 |
| 38 using ::testing::AnyNumber; |
38 using ::testing::InSequence; | 39 using ::testing::InSequence; |
39 using ::testing::Return; | 40 using ::testing::Return; |
40 using ::testing::_; | 41 using ::testing::_; |
41 | 42 |
42 namespace media { | 43 namespace media { |
43 | 44 |
44 int64_t OnAdjustAllocatedMemory(int64_t delta) { | 45 int64_t OnAdjustAllocatedMemory(int64_t delta) { |
45 return 0; | 46 return 0; |
46 } | 47 } |
47 | 48 |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
113 : media_thread_("MediaThreadForTest"), | 114 : media_thread_("MediaThreadForTest"), |
114 web_view_(blink::WebView::create(nullptr, | 115 web_view_(blink::WebView::create(nullptr, |
115 blink::WebPageVisibilityStateVisible)), | 116 blink::WebPageVisibilityStateVisible)), |
116 web_local_frame_( | 117 web_local_frame_( |
117 blink::WebLocalFrame::create(blink::WebTreeScopeType::Document, | 118 blink::WebLocalFrame::create(blink::WebTreeScopeType::Document, |
118 &web_frame_client_)), | 119 &web_frame_client_)), |
119 media_log_(new MediaLog()), | 120 media_log_(new MediaLog()), |
120 audio_parameters_(TestAudioParameters::Normal()) { | 121 audio_parameters_(TestAudioParameters::Normal()) { |
121 web_view_->setMainFrame(web_local_frame_); | 122 web_view_->setMainFrame(web_local_frame_); |
122 media_thread_.StartAndWaitForTesting(); | 123 media_thread_.StartAndWaitForTesting(); |
| 124 } |
123 | 125 |
| 126 void InitializeDefaultWebMediaPlayerImpl() { |
| 127 InitializeWebMediaPlayerImpl(delegate_.AsWeakPtr()); |
| 128 } |
| 129 |
| 130 void InitializeWebMediaPlayerImpl( |
| 131 base::WeakPtr<MockWebMediaPlayerDelegate> delegate) { |
124 wmpi_.reset(new WebMediaPlayerImpl( | 132 wmpi_.reset(new WebMediaPlayerImpl( |
125 web_local_frame_, &client_, nullptr, delegate_.AsWeakPtr(), | 133 web_local_frame_, &client_, nullptr, delegate, |
126 base::MakeUnique<DefaultRendererFactory>( | 134 base::MakeUnique<DefaultRendererFactory>( |
127 media_log_, nullptr, DefaultRendererFactory::GetGpuFactoriesCB()), | 135 media_log_, nullptr, DefaultRendererFactory::GetGpuFactoriesCB()), |
128 url_index_, | 136 url_index_, |
129 WebMediaPlayerParams( | 137 WebMediaPlayerParams( |
130 WebMediaPlayerParams::DeferLoadCB(), | 138 WebMediaPlayerParams::DeferLoadCB(), |
131 scoped_refptr<SwitchableAudioRendererSink>(), media_log_, | 139 scoped_refptr<SwitchableAudioRendererSink>(), media_log_, |
132 media_thread_.task_runner(), message_loop_.task_runner(), | 140 media_thread_.task_runner(), message_loop_.task_runner(), |
133 message_loop_.task_runner(), WebMediaPlayerParams::Context3DCB(), | 141 message_loop_.task_runner(), WebMediaPlayerParams::Context3DCB(), |
134 base::Bind(&OnAdjustAllocatedMemory), nullptr, nullptr, nullptr))); | 142 base::Bind(&OnAdjustAllocatedMemory), nullptr, nullptr, nullptr))); |
135 } | 143 } |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
190 wmpi_->must_suspend_ = false; | 198 wmpi_->must_suspend_ = false; |
191 return wmpi_->UpdatePlayState_ComputePlayState(false, false, true); | 199 return wmpi_->UpdatePlayState_ComputePlayState(false, false, true); |
192 } | 200 } |
193 | 201 |
194 WebMediaPlayerImpl::PlayState ComputeIdlePlayState() { | 202 WebMediaPlayerImpl::PlayState ComputeIdlePlayState() { |
195 wmpi_->is_idle_ = true; | 203 wmpi_->is_idle_ = true; |
196 wmpi_->must_suspend_ = false; | 204 wmpi_->must_suspend_ = false; |
197 return wmpi_->UpdatePlayState_ComputePlayState(false, false, false); | 205 return wmpi_->UpdatePlayState_ComputePlayState(false, false, false); |
198 } | 206 } |
199 | 207 |
| 208 WebMediaPlayerImpl::PlayState ComputeIdleSuspendedPlayState() { |
| 209 wmpi_->is_idle_ = true; |
| 210 wmpi_->must_suspend_ = false; |
| 211 return wmpi_->UpdatePlayState_ComputePlayState(false, true, false); |
| 212 } |
| 213 |
200 WebMediaPlayerImpl::PlayState ComputeMustSuspendPlayState() { | 214 WebMediaPlayerImpl::PlayState ComputeMustSuspendPlayState() { |
201 wmpi_->is_idle_ = false; | 215 wmpi_->is_idle_ = false; |
202 wmpi_->must_suspend_ = true; | 216 wmpi_->must_suspend_ = true; |
203 return wmpi_->UpdatePlayState_ComputePlayState(false, false, false); | 217 return wmpi_->UpdatePlayState_ComputePlayState(false, false, false); |
204 } | 218 } |
205 | 219 |
| 220 bool IsSuspended() { return wmpi_->pipeline_controller_.IsSuspended(); } |
| 221 |
| 222 void AddBufferedRanges() { |
| 223 wmpi_->buffered_data_source_host_.AddBufferedByteRange(0, 1); |
| 224 } |
| 225 |
206 void SetupForResumingBackgroundVideo() { | 226 void SetupForResumingBackgroundVideo() { |
207 #if !defined(OS_ANDROID) | 227 #if !defined(OS_ANDROID) |
208 // Need to enable media suspend to test resuming background videos. | 228 // Need to enable media suspend to test resuming background videos. |
209 base::CommandLine::ForCurrentProcess()->AppendSwitch( | 229 base::CommandLine::ForCurrentProcess()->AppendSwitch( |
210 switches::kEnableMediaSuspend); | 230 switches::kEnableMediaSuspend); |
211 #endif // !defined(OS_ANDROID) | 231 #endif // !defined(OS_ANDROID) |
212 std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList); | 232 std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList); |
213 feature_list->InitializeFromCommandLine(kResumeBackgroundVideo.name, ""); | 233 feature_list->InitializeFromCommandLine(kResumeBackgroundVideo.name, ""); |
214 base::FeatureList::ClearInstanceForTesting(); | 234 base::FeatureList::ClearInstanceForTesting(); |
215 base::FeatureList::SetInstance(std::move(feature_list)); | 235 base::FeatureList::SetInstance(std::move(feature_list)); |
(...skipping 14 matching lines...) Expand all Loading... |
230 scoped_refptr<MediaLog> media_log_; | 250 scoped_refptr<MediaLog> media_log_; |
231 linked_ptr<media::UrlIndex> url_index_; | 251 linked_ptr<media::UrlIndex> url_index_; |
232 | 252 |
233 // Audio hardware configuration. | 253 // Audio hardware configuration. |
234 AudioParameters audio_parameters_; | 254 AudioParameters audio_parameters_; |
235 | 255 |
236 // The client interface used by |wmpi_|. Just a dummy for now, but later we | 256 // The client interface used by |wmpi_|. Just a dummy for now, but later we |
237 // may want a mock or intelligent fake. | 257 // may want a mock or intelligent fake. |
238 DummyWebMediaPlayerClient client_; | 258 DummyWebMediaPlayerClient client_; |
239 | 259 |
240 MockWebMediaPlayerDelegate delegate_; | 260 testing::NiceMock<MockWebMediaPlayerDelegate> delegate_; |
241 | 261 |
242 // The WebMediaPlayerImpl instance under test. | 262 // The WebMediaPlayerImpl instance under test. |
243 std::unique_ptr<WebMediaPlayerImpl> wmpi_; | 263 std::unique_ptr<WebMediaPlayerImpl> wmpi_; |
244 | 264 |
245 private: | 265 private: |
246 DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImplTest); | 266 DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImplTest); |
247 }; | 267 }; |
248 | 268 |
249 TEST_F(WebMediaPlayerImplTest, ConstructAndDestroy) {} | 269 TEST_F(WebMediaPlayerImplTest, ConstructAndDestroy) { |
| 270 InitializeDefaultWebMediaPlayerImpl(); |
| 271 } |
| 272 |
| 273 TEST_F(WebMediaPlayerImplTest, DidLoadingProgressClearsIdle) { |
| 274 testing::StrictMock<MockWebMediaPlayerDelegate> strict_delegate; |
| 275 EXPECT_CALL(strict_delegate, AddObserver(_)); |
| 276 EXPECT_CALL(strict_delegate, IsPlayingBackgroundVideo()).Times(AnyNumber()); |
| 277 InitializeWebMediaPlayerImpl(strict_delegate.AsWeakPtr()); |
| 278 EXPECT_FALSE(IsSuspended()); |
| 279 EXPECT_CALL(strict_delegate, PlayerGone(0)); |
| 280 wmpi_->OnSuspendRequested(false); |
| 281 base::RunLoop().RunUntilIdle(); |
| 282 EXPECT_TRUE(IsSuspended()); |
| 283 AddBufferedRanges(); |
| 284 EXPECT_CALL(strict_delegate, PlayerGone(0)); |
| 285 wmpi_->didLoadingProgress(); |
| 286 base::RunLoop().RunUntilIdle(); |
| 287 EXPECT_FALSE(IsSuspended()); |
| 288 } |
250 | 289 |
251 TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterConstruction) { | 290 TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterConstruction) { |
| 291 InitializeDefaultWebMediaPlayerImpl(); |
252 WebMediaPlayerImpl::PlayState state; | 292 WebMediaPlayerImpl::PlayState state; |
253 | 293 |
254 state = ComputePlayState(); | 294 state = ComputePlayState(); |
255 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 295 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
256 EXPECT_FALSE(state.is_memory_reporting_enabled); | 296 EXPECT_FALSE(state.is_memory_reporting_enabled); |
257 EXPECT_FALSE(state.is_suspended); | 297 EXPECT_FALSE(state.is_suspended); |
258 | 298 |
| 299 state = ComputeIdlePlayState(); |
| 300 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
| 301 EXPECT_FALSE(state.is_memory_reporting_enabled); |
| 302 EXPECT_TRUE(state.is_suspended); |
| 303 |
259 state = ComputeBackgroundedPlayState(); | 304 state = ComputeBackgroundedPlayState(); |
260 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 305 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
261 EXPECT_FALSE(state.is_memory_reporting_enabled); | 306 EXPECT_FALSE(state.is_memory_reporting_enabled); |
262 EXPECT_FALSE(state.is_suspended); | 307 EXPECT_TRUE(state.is_suspended); |
263 | 308 |
264 state = ComputeMustSuspendPlayState(); | 309 state = ComputeMustSuspendPlayState(); |
265 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 310 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
266 EXPECT_FALSE(state.is_memory_reporting_enabled); | 311 EXPECT_FALSE(state.is_memory_reporting_enabled); |
267 EXPECT_TRUE(state.is_suspended); | 312 EXPECT_TRUE(state.is_suspended); |
268 } | 313 } |
269 | 314 |
270 TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterMetadata) { | 315 TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterMetadata) { |
| 316 InitializeDefaultWebMediaPlayerImpl(); |
271 WebMediaPlayerImpl::PlayState state; | 317 WebMediaPlayerImpl::PlayState state; |
272 SetMetadata(true, true); | 318 SetMetadata(true, true); |
273 | 319 |
274 state = ComputePlayState(); | 320 state = ComputePlayState(); |
275 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 321 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
276 EXPECT_FALSE(state.is_memory_reporting_enabled); | 322 EXPECT_FALSE(state.is_memory_reporting_enabled); |
277 EXPECT_FALSE(state.is_suspended); | 323 EXPECT_FALSE(state.is_suspended); |
278 | 324 |
| 325 state = ComputeIdlePlayState(); |
| 326 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
| 327 EXPECT_FALSE(state.is_memory_reporting_enabled); |
| 328 EXPECT_TRUE(state.is_suspended); |
| 329 |
279 state = ComputeBackgroundedPlayState(); | 330 state = ComputeBackgroundedPlayState(); |
280 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 331 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
281 EXPECT_FALSE(state.is_memory_reporting_enabled); | 332 EXPECT_FALSE(state.is_memory_reporting_enabled); |
282 EXPECT_TRUE(state.is_suspended); | 333 EXPECT_TRUE(state.is_suspended); |
283 | 334 |
284 state = ComputeMustSuspendPlayState(); | 335 state = ComputeMustSuspendPlayState(); |
285 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 336 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
286 EXPECT_FALSE(state.is_memory_reporting_enabled); | 337 EXPECT_FALSE(state.is_memory_reporting_enabled); |
287 EXPECT_TRUE(state.is_suspended); | 338 EXPECT_TRUE(state.is_suspended); |
288 } | 339 } |
289 | 340 |
290 TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterMetadata_AudioOnly) { | 341 TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterMetadata_AudioOnly) { |
| 342 InitializeDefaultWebMediaPlayerImpl(); |
291 WebMediaPlayerImpl::PlayState state; | 343 WebMediaPlayerImpl::PlayState state; |
292 SetMetadata(true, false); | 344 SetMetadata(true, false); |
293 | 345 |
294 state = ComputePlayState(); | 346 state = ComputePlayState(); |
295 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 347 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
296 EXPECT_FALSE(state.is_memory_reporting_enabled); | 348 EXPECT_FALSE(state.is_memory_reporting_enabled); |
297 EXPECT_FALSE(state.is_suspended); | 349 EXPECT_FALSE(state.is_suspended); |
298 | 350 |
| 351 state = ComputeIdlePlayState(); |
| 352 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
| 353 EXPECT_FALSE(state.is_memory_reporting_enabled); |
| 354 EXPECT_TRUE(state.is_suspended); |
| 355 |
299 SetPaused(false); | 356 SetPaused(false); |
300 state = ComputeBackgroundedPlayState(); | 357 state = ComputeBackgroundedPlayState(); |
301 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 358 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
302 EXPECT_FALSE(state.is_memory_reporting_enabled); | 359 EXPECT_FALSE(state.is_memory_reporting_enabled); |
303 EXPECT_FALSE(state.is_suspended); | 360 EXPECT_FALSE(state.is_suspended); |
304 | 361 |
305 state = ComputeMustSuspendPlayState(); | 362 state = ComputeMustSuspendPlayState(); |
306 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 363 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
307 EXPECT_FALSE(state.is_memory_reporting_enabled); | 364 EXPECT_FALSE(state.is_memory_reporting_enabled); |
308 EXPECT_TRUE(state.is_suspended); | 365 EXPECT_TRUE(state.is_suspended); |
309 } | 366 } |
310 | 367 |
311 TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterFutureData) { | 368 TEST_F(WebMediaPlayerImplTest, ComputePlayState_AfterFutureData) { |
| 369 InitializeDefaultWebMediaPlayerImpl(); |
312 WebMediaPlayerImpl::PlayState state; | 370 WebMediaPlayerImpl::PlayState state; |
313 SetMetadata(true, true); | 371 SetMetadata(true, true); |
314 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); | 372 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); |
315 | 373 |
316 state = ComputePlayState(); | 374 state = ComputePlayState(); |
317 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state); | 375 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state); |
318 EXPECT_FALSE(state.is_memory_reporting_enabled); | 376 EXPECT_FALSE(state.is_memory_reporting_enabled); |
319 EXPECT_FALSE(state.is_suspended); | 377 EXPECT_FALSE(state.is_suspended); |
320 | 378 |
321 state = ComputeBackgroundedPlayState(); | 379 state = ComputeBackgroundedPlayState(); |
(...skipping 11 matching lines...) Expand all Loading... |
333 EXPECT_FALSE(state.is_memory_reporting_enabled); | 391 EXPECT_FALSE(state.is_memory_reporting_enabled); |
334 EXPECT_TRUE(state.is_suspended); | 392 EXPECT_TRUE(state.is_suspended); |
335 | 393 |
336 state = ComputeMustSuspendPlayState(); | 394 state = ComputeMustSuspendPlayState(); |
337 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 395 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
338 EXPECT_FALSE(state.is_memory_reporting_enabled); | 396 EXPECT_FALSE(state.is_memory_reporting_enabled); |
339 EXPECT_TRUE(state.is_suspended); | 397 EXPECT_TRUE(state.is_suspended); |
340 } | 398 } |
341 | 399 |
342 TEST_F(WebMediaPlayerImplTest, ComputePlayState_Playing) { | 400 TEST_F(WebMediaPlayerImplTest, ComputePlayState_Playing) { |
| 401 InitializeDefaultWebMediaPlayerImpl(); |
343 WebMediaPlayerImpl::PlayState state; | 402 WebMediaPlayerImpl::PlayState state; |
344 SetMetadata(true, true); | 403 SetMetadata(true, true); |
345 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); | 404 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); |
346 SetPaused(false); | 405 SetPaused(false); |
347 | 406 |
348 state = ComputePlayState(); | 407 state = ComputePlayState(); |
349 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state); | 408 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state); |
350 EXPECT_TRUE(state.is_memory_reporting_enabled); | 409 EXPECT_TRUE(state.is_memory_reporting_enabled); |
351 EXPECT_FALSE(state.is_suspended); | 410 EXPECT_FALSE(state.is_suspended); |
352 | 411 |
353 state = ComputeBackgroundedPlayState(); | 412 state = ComputeBackgroundedPlayState(); |
354 if (base::FeatureList::IsEnabled(kResumeBackgroundVideo)) | 413 if (base::FeatureList::IsEnabled(kResumeBackgroundVideo)) |
355 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state); | 414 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state); |
356 else | 415 else |
357 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 416 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
358 EXPECT_FALSE(state.is_memory_reporting_enabled); | 417 EXPECT_FALSE(state.is_memory_reporting_enabled); |
359 EXPECT_TRUE(state.is_suspended); | 418 EXPECT_TRUE(state.is_suspended); |
360 | 419 |
361 state = ComputeMustSuspendPlayState(); | 420 state = ComputeMustSuspendPlayState(); |
362 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 421 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
363 EXPECT_FALSE(state.is_memory_reporting_enabled); | 422 EXPECT_FALSE(state.is_memory_reporting_enabled); |
364 EXPECT_TRUE(state.is_suspended); | 423 EXPECT_TRUE(state.is_suspended); |
365 } | 424 } |
366 | 425 |
367 TEST_F(WebMediaPlayerImplTest, ComputePlayState_PlayingThenUnderflow) { | 426 TEST_F(WebMediaPlayerImplTest, ComputePlayState_PlayingThenUnderflow) { |
| 427 InitializeDefaultWebMediaPlayerImpl(); |
368 WebMediaPlayerImpl::PlayState state; | 428 WebMediaPlayerImpl::PlayState state; |
369 SetMetadata(true, true); | 429 SetMetadata(true, true); |
370 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); | 430 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); |
371 SetPaused(false); | 431 SetPaused(false); |
372 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveCurrentData); | 432 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveCurrentData); |
373 | 433 |
374 // Underflow should not trigger idle suspend. The user is still playing the | 434 // Underflow should not trigger idle suspend. The user is still playing the |
375 // the video, just waiting on the network. | 435 // the video, just waiting on the network. |
376 state = ComputePlayState(); | 436 state = ComputePlayState(); |
377 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state); | 437 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state); |
(...skipping 10 matching lines...) Expand all Loading... |
388 EXPECT_TRUE(state.is_suspended); | 448 EXPECT_TRUE(state.is_suspended); |
389 | 449 |
390 // Forced suspend should still be possible during underflow. | 450 // Forced suspend should still be possible during underflow. |
391 state = ComputeMustSuspendPlayState(); | 451 state = ComputeMustSuspendPlayState(); |
392 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 452 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
393 EXPECT_FALSE(state.is_memory_reporting_enabled); | 453 EXPECT_FALSE(state.is_memory_reporting_enabled); |
394 EXPECT_TRUE(state.is_suspended); | 454 EXPECT_TRUE(state.is_suspended); |
395 } | 455 } |
396 | 456 |
397 TEST_F(WebMediaPlayerImplTest, ComputePlayState_Playing_AudioOnly) { | 457 TEST_F(WebMediaPlayerImplTest, ComputePlayState_Playing_AudioOnly) { |
| 458 InitializeDefaultWebMediaPlayerImpl(); |
398 WebMediaPlayerImpl::PlayState state; | 459 WebMediaPlayerImpl::PlayState state; |
399 SetMetadata(true, false); | 460 SetMetadata(true, false); |
400 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); | 461 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); |
401 SetPaused(false); | 462 SetPaused(false); |
402 | 463 |
403 state = ComputePlayState(); | 464 state = ComputePlayState(); |
404 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state); | 465 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state); |
405 EXPECT_TRUE(state.is_memory_reporting_enabled); | 466 EXPECT_TRUE(state.is_memory_reporting_enabled); |
406 EXPECT_FALSE(state.is_suspended); | 467 EXPECT_FALSE(state.is_suspended); |
407 | 468 |
(...skipping 11 matching lines...) Expand all Loading... |
419 EXPECT_FALSE(state.is_memory_reporting_enabled); | 480 EXPECT_FALSE(state.is_memory_reporting_enabled); |
420 EXPECT_TRUE(state.is_suspended); | 481 EXPECT_TRUE(state.is_suspended); |
421 | 482 |
422 state = ComputeMustSuspendPlayState(); | 483 state = ComputeMustSuspendPlayState(); |
423 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 484 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
424 EXPECT_FALSE(state.is_memory_reporting_enabled); | 485 EXPECT_FALSE(state.is_memory_reporting_enabled); |
425 EXPECT_TRUE(state.is_suspended); | 486 EXPECT_TRUE(state.is_suspended); |
426 } | 487 } |
427 | 488 |
428 TEST_F(WebMediaPlayerImplTest, ComputePlayState_Paused_Seek) { | 489 TEST_F(WebMediaPlayerImplTest, ComputePlayState_Paused_Seek) { |
| 490 InitializeDefaultWebMediaPlayerImpl(); |
429 WebMediaPlayerImpl::PlayState state; | 491 WebMediaPlayerImpl::PlayState state; |
430 SetMetadata(true, true); | 492 SetMetadata(true, true); |
431 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); | 493 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); |
432 SetSeeking(true); | 494 SetSeeking(true); |
433 | 495 |
434 state = ComputePlayState(); | 496 state = ComputePlayState(); |
435 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED_BUT_NOT_IDLE, | 497 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state); |
436 state.delegate_state); | |
437 EXPECT_FALSE(state.is_memory_reporting_enabled); | 498 EXPECT_FALSE(state.is_memory_reporting_enabled); |
438 EXPECT_FALSE(state.is_suspended); | 499 EXPECT_FALSE(state.is_suspended); |
439 } | 500 } |
440 | 501 |
441 TEST_F(WebMediaPlayerImplTest, ComputePlayState_Paused_Fullscreen) { | 502 TEST_F(WebMediaPlayerImplTest, ComputePlayState_Paused_Fullscreen) { |
| 503 InitializeDefaultWebMediaPlayerImpl(); |
442 WebMediaPlayerImpl::PlayState state; | 504 WebMediaPlayerImpl::PlayState state; |
443 SetMetadata(true, true); | 505 SetMetadata(true, true); |
444 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); | 506 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); |
445 SetFullscreen(true); | 507 SetFullscreen(true); |
446 | 508 |
447 state = ComputePlayState(); | 509 state = ComputePlayState(); |
448 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED_BUT_NOT_IDLE, | 510 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state); |
449 state.delegate_state); | |
450 EXPECT_FALSE(state.is_memory_reporting_enabled); | 511 EXPECT_FALSE(state.is_memory_reporting_enabled); |
451 EXPECT_FALSE(state.is_suspended); | 512 EXPECT_FALSE(state.is_suspended); |
452 } | 513 } |
453 | 514 |
454 TEST_F(WebMediaPlayerImplTest, ComputePlayState_Ended) { | 515 TEST_F(WebMediaPlayerImplTest, ComputePlayState_Ended) { |
| 516 InitializeDefaultWebMediaPlayerImpl(); |
455 WebMediaPlayerImpl::PlayState state; | 517 WebMediaPlayerImpl::PlayState state; |
456 SetMetadata(true, true); | 518 SetMetadata(true, true); |
457 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); | 519 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); |
458 SetEnded(true); | 520 SetEnded(true); |
459 | 521 |
460 // The pipeline is not suspended immediately on ended. | 522 // The pipeline is not suspended immediately on ended. |
461 state = ComputePlayState(); | 523 state = ComputePlayState(); |
462 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::ENDED, state.delegate_state); | 524 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::ENDED, state.delegate_state); |
463 EXPECT_FALSE(state.is_memory_reporting_enabled); | 525 EXPECT_FALSE(state.is_memory_reporting_enabled); |
464 EXPECT_FALSE(state.is_suspended); | 526 EXPECT_FALSE(state.is_suspended); |
465 | 527 |
466 state = ComputeIdlePlayState(); | 528 state = ComputeIdlePlayState(); |
467 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::ENDED, state.delegate_state); | 529 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::ENDED, state.delegate_state); |
468 EXPECT_FALSE(state.is_memory_reporting_enabled); | 530 EXPECT_FALSE(state.is_memory_reporting_enabled); |
469 EXPECT_TRUE(state.is_suspended); | 531 EXPECT_TRUE(state.is_suspended); |
470 } | 532 } |
471 | 533 |
472 TEST_F(WebMediaPlayerImplTest, ComputePlayState_Suspended) { | 534 TEST_F(WebMediaPlayerImplTest, ComputePlayState_Suspended) { |
| 535 InitializeDefaultWebMediaPlayerImpl(); |
473 WebMediaPlayerImpl::PlayState state; | 536 WebMediaPlayerImpl::PlayState state; |
474 SetMetadata(true, true); | 537 SetMetadata(true, true); |
475 | 538 |
476 // Suspended players should be resumed unless we have reached the appropriate | 539 // Suspended players should be resumed unless we have reached the appropriate |
477 // ready state and are not seeking. | 540 // ready state and are not seeking. |
478 SetPaused(true); | 541 SetPaused(true); |
479 state = ComputePlayStateSuspended(); | 542 state = ComputePlayStateSuspended(); |
480 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 543 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
481 EXPECT_FALSE(state.is_memory_reporting_enabled); | 544 EXPECT_FALSE(state.is_memory_reporting_enabled); |
482 EXPECT_FALSE(state.is_suspended); | 545 EXPECT_FALSE(state.is_suspended); |
483 | 546 |
| 547 // Paused players in the idle state are allowed to remain suspended. |
| 548 state = ComputeIdleSuspendedPlayState(); |
| 549 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
| 550 EXPECT_FALSE(state.is_memory_reporting_enabled); |
| 551 EXPECT_TRUE(state.is_suspended); |
| 552 |
484 SetPaused(false); | 553 SetPaused(false); |
485 state = ComputePlayStateSuspended(); | 554 state = ComputePlayStateSuspended(); |
486 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); | 555 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::GONE, state.delegate_state); |
487 EXPECT_FALSE(state.is_memory_reporting_enabled); | 556 EXPECT_FALSE(state.is_memory_reporting_enabled); |
488 EXPECT_FALSE(state.is_suspended); | 557 EXPECT_FALSE(state.is_suspended); |
489 | 558 |
490 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); | 559 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); |
491 | 560 |
492 // Paused players should stay suspended. | 561 // Paused players should stay suspended. |
493 SetPaused(true); | 562 SetPaused(true); |
494 state = ComputePlayStateSuspended(); | 563 state = ComputePlayStateSuspended(); |
495 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state); | 564 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state); |
496 EXPECT_FALSE(state.is_memory_reporting_enabled); | 565 EXPECT_FALSE(state.is_memory_reporting_enabled); |
497 EXPECT_TRUE(state.is_suspended); | 566 EXPECT_TRUE(state.is_suspended); |
498 | 567 |
499 // Playing players should resume into the playing state. | 568 // Playing players should resume into the playing state. |
500 SetPaused(false); | 569 SetPaused(false); |
501 state = ComputePlayStateSuspended(); | 570 state = ComputePlayStateSuspended(); |
502 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state); | 571 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state); |
503 EXPECT_TRUE(state.is_memory_reporting_enabled); | 572 EXPECT_TRUE(state.is_memory_reporting_enabled); |
504 EXPECT_FALSE(state.is_suspended); | 573 EXPECT_FALSE(state.is_suspended); |
505 | 574 |
506 // If seeking, the previously suspended state does not matter; the player | 575 // If seeking, the previously suspended state does not matter; the player |
507 // should always be resumed. | 576 // should always be resumed. |
508 SetSeeking(true); | 577 SetSeeking(true); |
509 | 578 |
510 SetPaused(true); | 579 SetPaused(true); |
511 state = ComputePlayStateSuspended(); | 580 state = ComputePlayStateSuspended(); |
512 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED_BUT_NOT_IDLE, | 581 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state); |
513 state.delegate_state); | |
514 EXPECT_FALSE(state.is_memory_reporting_enabled); | 582 EXPECT_FALSE(state.is_memory_reporting_enabled); |
515 EXPECT_FALSE(state.is_suspended); | 583 EXPECT_FALSE(state.is_suspended); |
516 | 584 |
517 SetPaused(false); | 585 SetPaused(false); |
518 state = ComputePlayStateSuspended(); | 586 state = ComputePlayStateSuspended(); |
519 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state); | 587 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state); |
520 EXPECT_TRUE(state.is_memory_reporting_enabled); | 588 EXPECT_TRUE(state.is_memory_reporting_enabled); |
521 EXPECT_FALSE(state.is_suspended); | 589 EXPECT_FALSE(state.is_suspended); |
522 } | 590 } |
523 | 591 |
524 TEST_F(WebMediaPlayerImplTest, NaturalSizeChange) { | 592 TEST_F(WebMediaPlayerImplTest, NaturalSizeChange) { |
| 593 InitializeDefaultWebMediaPlayerImpl(); |
525 PipelineMetadata metadata; | 594 PipelineMetadata metadata; |
526 metadata.has_video = true; | 595 metadata.has_video = true; |
527 metadata.natural_size = gfx::Size(320, 240); | 596 metadata.natural_size = gfx::Size(320, 240); |
528 | 597 |
529 OnMetadata(metadata); | 598 OnMetadata(metadata); |
530 ASSERT_EQ(blink::WebSize(320, 240), wmpi_->naturalSize()); | 599 ASSERT_EQ(blink::WebSize(320, 240), wmpi_->naturalSize()); |
531 | 600 |
532 // TODO(sandersd): Verify that the client is notified of the size change? | 601 // TODO(sandersd): Verify that the client is notified of the size change? |
533 OnVideoNaturalSizeChange(gfx::Size(1920, 1080)); | 602 OnVideoNaturalSizeChange(gfx::Size(1920, 1080)); |
534 ASSERT_EQ(blink::WebSize(1920, 1080), wmpi_->naturalSize()); | 603 ASSERT_EQ(blink::WebSize(1920, 1080), wmpi_->naturalSize()); |
535 } | 604 } |
536 | 605 |
537 TEST_F(WebMediaPlayerImplTest, NaturalSizeChange_Rotated) { | 606 TEST_F(WebMediaPlayerImplTest, NaturalSizeChange_Rotated) { |
| 607 InitializeDefaultWebMediaPlayerImpl(); |
538 PipelineMetadata metadata; | 608 PipelineMetadata metadata; |
539 metadata.has_video = true; | 609 metadata.has_video = true; |
540 metadata.natural_size = gfx::Size(320, 240); | 610 metadata.natural_size = gfx::Size(320, 240); |
541 metadata.video_rotation = VIDEO_ROTATION_90; | 611 metadata.video_rotation = VIDEO_ROTATION_90; |
542 | 612 |
543 // For 90/270deg rotations, the natural size should be transposed. | 613 // For 90/270deg rotations, the natural size should be transposed. |
544 OnMetadata(metadata); | 614 OnMetadata(metadata); |
545 ASSERT_EQ(blink::WebSize(240, 320), wmpi_->naturalSize()); | 615 ASSERT_EQ(blink::WebSize(240, 320), wmpi_->naturalSize()); |
546 | 616 |
547 OnVideoNaturalSizeChange(gfx::Size(1920, 1080)); | 617 OnVideoNaturalSizeChange(gfx::Size(1920, 1080)); |
548 ASSERT_EQ(blink::WebSize(1080, 1920), wmpi_->naturalSize()); | 618 ASSERT_EQ(blink::WebSize(1080, 1920), wmpi_->naturalSize()); |
549 } | 619 } |
550 | 620 |
551 // Audible backgrounded videos are not suspended if delegate_ allows it. | 621 // Audible backgrounded videos are not suspended if delegate_ allows it. |
552 TEST_F(WebMediaPlayerImplTest, ComputePlayState_BackgroundedVideoPlaying) { | 622 TEST_F(WebMediaPlayerImplTest, ComputePlayState_BackgroundedVideoPlaying) { |
| 623 InitializeDefaultWebMediaPlayerImpl(); |
553 WebMediaPlayerImpl::PlayState state; | 624 WebMediaPlayerImpl::PlayState state; |
554 SetMetadata(true, true); | 625 SetMetadata(true, true); |
555 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); | 626 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); |
556 | 627 |
557 SetupForResumingBackgroundVideo(); | 628 SetupForResumingBackgroundVideo(); |
558 | 629 |
559 EXPECT_CALL(delegate_, IsPlayingBackgroundVideo()) | 630 EXPECT_CALL(delegate_, IsPlayingBackgroundVideo()) |
560 .WillRepeatedly(Return(true)); | 631 .WillRepeatedly(Return(true)); |
561 EXPECT_CALL(delegate_, IsHidden()).WillRepeatedly(Return(true)); | 632 EXPECT_CALL(delegate_, IsHidden()).WillRepeatedly(Return(true)); |
562 | 633 |
563 SetPaused(false); | 634 SetPaused(false); |
564 state = ComputeBackgroundedPlayState(); | 635 state = ComputeBackgroundedPlayState(); |
565 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state); | 636 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PLAYING, state.delegate_state); |
566 EXPECT_TRUE(state.is_memory_reporting_enabled); | 637 EXPECT_TRUE(state.is_memory_reporting_enabled); |
567 EXPECT_FALSE(state.is_suspended); | 638 EXPECT_FALSE(state.is_suspended); |
568 } | 639 } |
569 | 640 |
570 // Backgrounding audible videos should suspend them and report as paused, not | 641 // Backgrounding audible videos should suspend them and report as paused, not |
571 // gone. | 642 // gone. |
572 TEST_F(WebMediaPlayerImplTest, ComputePlayState_BackgroundedVideoPaused) { | 643 TEST_F(WebMediaPlayerImplTest, ComputePlayState_BackgroundedVideoPaused) { |
| 644 InitializeDefaultWebMediaPlayerImpl(); |
573 WebMediaPlayerImpl::PlayState state; | 645 WebMediaPlayerImpl::PlayState state; |
574 SetMetadata(true, true); | 646 SetMetadata(true, true); |
575 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); | 647 SetReadyState(blink::WebMediaPlayer::ReadyStateHaveFutureData); |
576 | 648 |
577 SetupForResumingBackgroundVideo(); | 649 SetupForResumingBackgroundVideo(); |
578 | 650 |
579 EXPECT_CALL(delegate_, IsPlayingBackgroundVideo()).WillOnce(Return(false)); | 651 EXPECT_CALL(delegate_, IsPlayingBackgroundVideo()).WillOnce(Return(false)); |
580 EXPECT_CALL(delegate_, IsHidden()).WillRepeatedly(Return(true)); | 652 EXPECT_CALL(delegate_, IsHidden()).WillRepeatedly(Return(true)); |
581 | 653 |
582 state = ComputeBackgroundedPlayState(); | 654 state = ComputeBackgroundedPlayState(); |
583 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state); | 655 EXPECT_EQ(WebMediaPlayerImpl::DelegateState::PAUSED, state.delegate_state); |
584 EXPECT_FALSE(state.is_memory_reporting_enabled); | 656 EXPECT_FALSE(state.is_memory_reporting_enabled); |
585 EXPECT_TRUE(state.is_suspended); | 657 EXPECT_TRUE(state.is_suspended); |
586 } | 658 } |
587 | 659 |
588 } // namespace media | 660 } // namespace media |
OLD | NEW |