1 // Copyright 2013 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 5 #include "base/bind.h" 6 #include "base/message_loop/message_loop.h" 7 #include "content/public/common/url_constants.h" 8 #include "content/renderer/media/buffered_data_source.h" 9 #include "content/renderer/media/test_response_generator.h" 10 #include "content/test/mock_webframeclient.h" 11 #include "content/test/mock_weburlloader.h" 12 #include "media/base/media_log.h" 13 #include "media/base/mock_filters.h" 14 #include "media/base/test_helpers.h" 15 #include "third_party/WebKit/public/platform/WebURLResponse.h" 16 #include "third_party/WebKit/public/web/WebLocalFrame.h" 17 #include "third_party/WebKit/public/web/WebView.h" 18 19 using ::testing::_; 20 using ::testing::Assign; 21 using ::testing::Invoke; 22 using ::testing::InSequence; 23 using ::testing::NiceMock; 24 using ::testing::StrictMock; 25 26 using blink::WebLocalFrame; 27 using blink::WebString; 28 using blink::WebURLLoader; 29 using blink::WebURLResponse; 30 using blink::WebView; 31 32 namespace content { 33 34 class MockBufferedDataSourceHost : public BufferedDataSourceHost { 35 public: 36 MockBufferedDataSourceHost() {} 37 virtual ~MockBufferedDataSourceHost() {} 38 39 MOCK_METHOD1(SetTotalBytes, void(int64 total_bytes)); 40 MOCK_METHOD2(AddBufferedByteRange, void(int64 start, int64 end)); 41 42 private: 43 DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSourceHost); 44 }; 45 46 // Overrides CreateResourceLoader() to permit injecting a MockWebURLLoader. 47 // Also keeps track of whether said MockWebURLLoader is actively loading. 48 class MockBufferedDataSource : public BufferedDataSource { 49 public: 50 MockBufferedDataSource( 51 const GURL& url, 52 const scoped_refptr<base::MessageLoopProxy>& message_loop, 53 WebLocalFrame* frame, 54 BufferedDataSourceHost* host) 55 : BufferedDataSource(url, 56 BufferedResourceLoader::kUnspecified, 57 message_loop, 58 frame, 59 new media::MediaLog(), 60 host, 61 base::Bind(&MockBufferedDataSource::set_downloading, 62 base::Unretained(this))), 63 downloading_(false), 64 loading_(false) {} 65 virtual ~MockBufferedDataSource() {} 66 67 MOCK_METHOD2(CreateResourceLoader, BufferedResourceLoader*(int64, int64)); 68 BufferedResourceLoader* CreateMockResourceLoader(int64 first_byte_position, 69 int64 last_byte_position) { 70 CHECK(!loading_) << "Previous resource load wasn't cancelled"; 71 72 BufferedResourceLoader* loader = 73 BufferedDataSource::CreateResourceLoader(first_byte_position, 74 last_byte_position); 75 76 // Keep track of active loading state via loadAsynchronously() and cancel(). 77 NiceMock<MockWebURLLoader>* url_loader = new NiceMock<MockWebURLLoader>(); 78 ON_CALL(*url_loader, loadAsynchronously(_, _)) 79 .WillByDefault(Assign(&loading_, true)); 80 ON_CALL(*url_loader, cancel()) 81 .WillByDefault(Assign(&loading_, false)); 82 83 // |test_loader_| will be used when Start() is called. 84 loader->test_loader_ = scoped_ptr<WebURLLoader>(url_loader); 85 return loader; 86 } 87 88 bool loading() { return loading_; } 89 void set_loading(bool loading) { loading_ = loading; } 90 bool downloading() { return downloading_; } 91 void set_downloading(bool downloading) { downloading_ = downloading; } 92 93 private: 94 // Whether the resource is downloading or deferred. 95 bool downloading_; 96 97 // Whether the resource load has starting loading but yet to been cancelled. 98 bool loading_; 99 100 DISALLOW_COPY_AND_ASSIGN(MockBufferedDataSource); 101 }; 102 103 static const int64 kFileSize = 5000000; 104 static const int64 kFarReadPosition = 4000000; 105 static const int kDataSize = 1024; 106 107 static const char kHttpUrl[] = "http://localhost/foo.webm"; 108 static const char kFileUrl[] = "file:///tmp/bar.webm"; 109 110 class BufferedDataSourceTest : public testing::Test { 111 public: 112 BufferedDataSourceTest() 113 : view_(WebView::create(NULL)), 114 frame_(WebLocalFrame::create(&client_)), 115 preload_(AUTO) { 116 view_->setMainFrame(frame_); 117 } 118 119 virtual ~BufferedDataSourceTest() { 120 view_->close(); 121 frame_->close(); 122 } 123 124 MOCK_METHOD1(OnInitialize, void(bool)); 125 126 void Initialize(const char* url, bool expected) { 127 GURL gurl(url); 128 data_source_.reset( 129 new MockBufferedDataSource(gurl, 130 message_loop_.message_loop_proxy(), 131 view_->mainFrame()->toWebLocalFrame(), 132 &host_)); 133 data_source_->SetPreload(preload_); 134 135 response_generator_.reset(new TestResponseGenerator(gurl, kFileSize)); 136 ExpectCreateResourceLoader(); 137 EXPECT_CALL(*this, OnInitialize(expected)); 138 data_source_->Initialize(base::Bind(&BufferedDataSourceTest::OnInitialize, 139 base::Unretained(this))); 140 message_loop_.RunUntilIdle(); 141 142 bool is_http = gurl.SchemeIsHTTPOrHTTPS(); 143 EXPECT_EQ(data_source_->downloading(), is_http); 144 } 145 146 // Helper to initialize tests with a valid 200 response. 147 void InitializeWith200Response() { 148 Initialize(kHttpUrl, true); 149 150 EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length())); 151 Respond(response_generator_->Generate200()); 152 } 153 154 // Helper to initialize tests with a valid 206 response. 155 void InitializeWith206Response() { 156 Initialize(kHttpUrl, true); 157 158 EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length())); 159 Respond(response_generator_->Generate206(0)); 160 } 161 162 // Helper to initialize tests with a valid file:// response. 163 void InitializeWithFileResponse() { 164 Initialize(kFileUrl, true); 165 166 EXPECT_CALL(host_, SetTotalBytes(kFileSize)); 167 EXPECT_CALL(host_, AddBufferedByteRange(0, kFileSize)); 168 Respond(response_generator_->GenerateFileResponse(0)); 169 } 170 171 // Stops any active loaders and shuts down the data source. 172 // 173 // This typically happens when the page is closed and for our purposes is 174 // appropriate to do when tearing down a test. 175 void Stop() { 176 if (data_source_->loading()) { 177 loader()->didFail(url_loader(), response_generator_->GenerateError()); 178 message_loop_.RunUntilIdle(); 179 } 180 181 data_source_->Stop(media::NewExpectedClosure()); 182 message_loop_.RunUntilIdle(); 183 } 184 185 void ExpectCreateResourceLoader() { 186 EXPECT_CALL(*data_source_, CreateResourceLoader(_, _)) 187 .WillOnce(Invoke(data_source_.get(), 188 &MockBufferedDataSource::CreateMockResourceLoader)); 189 message_loop_.RunUntilIdle(); 190 } 191 192 void Respond(const WebURLResponse& response) { 193 loader()->didReceiveResponse(url_loader(), response); 194 message_loop_.RunUntilIdle(); 195 } 196 197 void ReceiveData(int size) { 198 scoped_ptr<char[]> data(new char[size]); 199 memset(data.get(), 0xA5, size); // Arbitrary non-zero value. 200 201 loader()->didReceiveData(url_loader(), data.get(), size, size); 202 message_loop_.RunUntilIdle(); 203 } 204 205 void FinishLoading() { 206 data_source_->set_loading(false); 207 loader()->didFinishLoading(url_loader(), 0, -1); 208 message_loop_.RunUntilIdle(); 209 } 210 211 MOCK_METHOD1(ReadCallback, void(int size)); 212 213 void ReadAt(int64 position) { 214 data_source_->Read(position, kDataSize, buffer_, 215 base::Bind(&BufferedDataSourceTest::ReadCallback, 216 base::Unretained(this))); 217 message_loop_.RunUntilIdle(); 218 } 219 220 // Accessors for private variables on |data_source_|. 221 BufferedResourceLoader* loader() { 222 return data_source_->loader_.get(); 223 } 224 WebURLLoader* url_loader() { 225 return loader()->active_loader_->loader_.get(); 226 } 227 228 Preload preload() { return data_source_->preload_; } 229 void set_preload(Preload preload) { preload_ = preload; } 230 BufferedResourceLoader::DeferStrategy defer_strategy() { 231 return loader()->defer_strategy_; 232 } 233 int data_source_bitrate() { return data_source_->bitrate_; } 234 int data_source_playback_rate() { return data_source_->playback_rate_; } 235 int loader_bitrate() { return loader()->bitrate_; } 236 int loader_playback_rate() { return loader()->playback_rate_; } 237 bool is_local_source() { return data_source_->assume_fully_buffered(); } 238 void set_might_be_reused_from_cache_in_future(bool value) { 239 loader()->might_be_reused_from_cache_in_future_ = value; 240 } 241 242 scoped_ptr<MockBufferedDataSource> data_source_; 243 244 scoped_ptr<TestResponseGenerator> response_generator_; 245 MockWebFrameClient client_; 246 WebView* view_; 247 WebLocalFrame* frame_; 248 249 StrictMock<MockBufferedDataSourceHost> host_; 250 base::MessageLoop message_loop_; 251 252 private: 253 // Used for calling BufferedDataSource::Read(). 254 uint8 buffer_[kDataSize]; 255 256 Preload preload_; 257 258 DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceTest); 259 }; 260 261 TEST_F(BufferedDataSourceTest, Range_Supported) { 262 InitializeWith206Response(); 263 264 EXPECT_TRUE(data_source_->loading()); 265 EXPECT_FALSE(data_source_->IsStreaming()); 266 Stop(); 267 } 268 269 TEST_F(BufferedDataSourceTest, Range_InstanceSizeUnknown) { 270 Initialize(kHttpUrl, true); 271 272 Respond(response_generator_->Generate206( 273 0, TestResponseGenerator::kNoContentRangeInstanceSize)); 274 275 EXPECT_TRUE(data_source_->loading()); 276 EXPECT_TRUE(data_source_->IsStreaming()); 277 Stop(); 278 } 279 280 TEST_F(BufferedDataSourceTest, Range_NotFound) { 281 Initialize(kHttpUrl, false); 282 Respond(response_generator_->Generate404()); 283 284 EXPECT_FALSE(data_source_->loading()); 285 Stop(); 286 } 287 288 TEST_F(BufferedDataSourceTest, Range_NotSupported) { 289 InitializeWith200Response(); 290 291 EXPECT_TRUE(data_source_->loading()); 292 EXPECT_TRUE(data_source_->IsStreaming()); 293 Stop(); 294 } 295 296 // Special carve-out for Apache versions that choose to return a 200 for 297 // Range:0- ("because it's more efficient" than a 206) 298 TEST_F(BufferedDataSourceTest, Range_SupportedButReturned200) { 299 Initialize(kHttpUrl, true); 300 EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length())); 301 WebURLResponse response = response_generator_->Generate200(); 302 response.setHTTPHeaderField(WebString::fromUTF8("Accept-Ranges"), 303 WebString::fromUTF8("bytes")); 304 Respond(response); 305 306 EXPECT_TRUE(data_source_->loading()); 307 EXPECT_FALSE(data_source_->IsStreaming()); 308 Stop(); 309 } 310 311 TEST_F(BufferedDataSourceTest, Range_MissingContentRange) { 312 Initialize(kHttpUrl, false); 313 Respond(response_generator_->Generate206( 314 0, TestResponseGenerator::kNoContentRange)); 315 316 EXPECT_FALSE(data_source_->loading()); 317 Stop(); 318 } 319 320 TEST_F(BufferedDataSourceTest, Range_MissingContentLength) { 321 Initialize(kHttpUrl, true); 322 323 // It'll manage without a Content-Length response. 324 EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length())); 325 Respond(response_generator_->Generate206( 326 0, TestResponseGenerator::kNoContentLength)); 327 328 EXPECT_TRUE(data_source_->loading()); 329 EXPECT_FALSE(data_source_->IsStreaming()); 330 Stop(); 331 } 332 333 TEST_F(BufferedDataSourceTest, Range_WrongContentRange) { 334 Initialize(kHttpUrl, false); 335 336 // Now it's done and will fail. 337 Respond(response_generator_->Generate206(1337)); 338 339 EXPECT_FALSE(data_source_->loading()); 340 Stop(); 341 } 342 343 // Test the case where the initial response from the server indicates that 344 // Range requests are supported, but a later request prove otherwise. 345 TEST_F(BufferedDataSourceTest, Range_ServerLied) { 346 InitializeWith206Response(); 347 348 // Read causing a new request to be made -- we'll expect it to error. 349 ExpectCreateResourceLoader(); 350 ReadAt(kFarReadPosition); 351 352 // Return a 200 in response to a range request. 353 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); 354 Respond(response_generator_->Generate200()); 355 356 EXPECT_FALSE(data_source_->loading()); 357 Stop(); 358 } 359 360 TEST_F(BufferedDataSourceTest, Http_AbortWhileReading) { 361 InitializeWith206Response(); 362 363 // Make sure there's a pending read -- we'll expect it to error. 364 ReadAt(0); 365 366 // Abort!!! 367 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); 368 data_source_->Abort(); 369 message_loop_.RunUntilIdle(); 370 371 EXPECT_FALSE(data_source_->loading()); 372 Stop(); 373 } 374 375 TEST_F(BufferedDataSourceTest, File_AbortWhileReading) { 376 InitializeWithFileResponse(); 377 378 // Make sure there's a pending read -- we'll expect it to error. 379 ReadAt(0); 380 381 // Abort!!! 382 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); 383 data_source_->Abort(); 384 message_loop_.RunUntilIdle(); 385 386 EXPECT_FALSE(data_source_->loading()); 387 Stop(); 388 } 389 390 TEST_F(BufferedDataSourceTest, Http_Retry) { 391 InitializeWith206Response(); 392 393 // Read to advance our position. 394 EXPECT_CALL(*this, ReadCallback(kDataSize)); 395 EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1)); 396 ReadAt(0); 397 ReceiveData(kDataSize); 398 399 // Issue a pending read but terminate the connection to force a retry. 400 ReadAt(kDataSize); 401 ExpectCreateResourceLoader(); 402 FinishLoading(); 403 Respond(response_generator_->Generate206(kDataSize)); 404 405 // Complete the read. 406 EXPECT_CALL(*this, ReadCallback(kDataSize)); 407 EXPECT_CALL(host_, AddBufferedByteRange(kDataSize, (kDataSize * 2) - 1)); 408 ReceiveData(kDataSize); 409 410 EXPECT_TRUE(data_source_->loading()); 411 Stop(); 412 } 413 414 TEST_F(BufferedDataSourceTest, File_Retry) { 415 InitializeWithFileResponse(); 416 417 // Read to advance our position. 418 EXPECT_CALL(*this, ReadCallback(kDataSize)); 419 ReadAt(0); 420 ReceiveData(kDataSize); 421 422 // Issue a pending read but terminate the connection to force a retry. 423 ReadAt(kDataSize); 424 ExpectCreateResourceLoader(); 425 FinishLoading(); 426 Respond(response_generator_->GenerateFileResponse(kDataSize)); 427 428 // Complete the read. 429 EXPECT_CALL(*this, ReadCallback(kDataSize)); 430 ReceiveData(kDataSize); 431 432 EXPECT_TRUE(data_source_->loading()); 433 Stop(); 434 } 435 436 TEST_F(BufferedDataSourceTest, Http_TooManyRetries) { 437 InitializeWith206Response(); 438 439 // Make sure there's a pending read -- we'll expect it to error. 440 ReadAt(0); 441 442 // It'll try three times. 443 ExpectCreateResourceLoader(); 444 FinishLoading(); 445 Respond(response_generator_->Generate206(0)); 446 447 ExpectCreateResourceLoader(); 448 FinishLoading(); 449 Respond(response_generator_->Generate206(0)); 450 451 ExpectCreateResourceLoader(); 452 FinishLoading(); 453 Respond(response_generator_->Generate206(0)); 454 455 // It'll error after this. 456 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); 457 FinishLoading(); 458 459 EXPECT_FALSE(data_source_->loading()); 460 Stop(); 461 } 462 463 TEST_F(BufferedDataSourceTest, File_TooManyRetries) { 464 InitializeWithFileResponse(); 465 466 // Make sure there's a pending read -- we'll expect it to error. 467 ReadAt(0); 468 469 // It'll try three times. 470 ExpectCreateResourceLoader(); 471 FinishLoading(); 472 Respond(response_generator_->GenerateFileResponse(0)); 473 474 ExpectCreateResourceLoader(); 475 FinishLoading(); 476 Respond(response_generator_->GenerateFileResponse(0)); 477 478 ExpectCreateResourceLoader(); 479 FinishLoading(); 480 Respond(response_generator_->GenerateFileResponse(0)); 481 482 // It'll error after this. 483 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); 484 FinishLoading(); 485 486 EXPECT_FALSE(data_source_->loading()); 487 Stop(); 488 } 489 490 TEST_F(BufferedDataSourceTest, File_InstanceSizeUnknown) { 491 Initialize(kFileUrl, false); 492 EXPECT_FALSE(data_source_->downloading()); 493 494 Respond(response_generator_->GenerateFileResponse(-1)); 495 496 EXPECT_FALSE(data_source_->loading()); 497 Stop(); 498 } 499 500 TEST_F(BufferedDataSourceTest, File_Successful) { 501 InitializeWithFileResponse(); 502 503 EXPECT_TRUE(data_source_->loading()); 504 EXPECT_FALSE(data_source_->IsStreaming()); 505 Stop(); 506 } 507 508 static void SetTrue(bool* value) { 509 *value = true; 510 } 511 512 // This test makes sure that Stop() does not require a task to run on 513 // |message_loop_| before it calls its callback. This prevents accidental 514 // introduction of a pipeline teardown deadlock. The pipeline owner blocks 515 // the render message loop while waiting for Stop() to complete. Since this 516 // object runs on the render message loop, Stop() will not complete if it 517 // requires a task to run on the the message loop that is being blocked. 518 TEST_F(BufferedDataSourceTest, StopDoesNotUseMessageLoopForCallback) { 519 InitializeWith206Response(); 520 521 // Stop() the data source, using a callback that lets us verify that it was 522 // called before Stop() returns. This is to make sure that the callback does 523 // not require |message_loop_| to execute tasks before being called. 524 bool stop_done_called = false; 525 EXPECT_TRUE(data_source_->loading()); 526 data_source_->Stop(base::Bind(&SetTrue, &stop_done_called)); 527 528 // Verify that the callback was called inside the Stop() call. 529 EXPECT_TRUE(stop_done_called); 530 message_loop_.RunUntilIdle(); 531 } 532 533 TEST_F(BufferedDataSourceTest, StopDuringRead) { 534 InitializeWith206Response(); 535 536 uint8 buffer[256]; 537 data_source_->Read(0, arraysize(buffer), buffer, base::Bind( 538 &BufferedDataSourceTest::ReadCallback, base::Unretained(this))); 539 540 // The outstanding read should fail before the stop callback runs. 541 { 542 InSequence s; 543 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); 544 data_source_->Stop(media::NewExpectedClosure()); 545 } 546 message_loop_.RunUntilIdle(); 547 } 548 549 TEST_F(BufferedDataSourceTest, DefaultValues) { 550 InitializeWith206Response(); 551 552 // Ensure we have sane values for default loading scenario. 553 EXPECT_EQ(AUTO, preload()); 554 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 555 556 EXPECT_EQ(0, data_source_bitrate()); 557 EXPECT_EQ(0.0f, data_source_playback_rate()); 558 EXPECT_EQ(0, loader_bitrate()); 559 EXPECT_EQ(0.0f, loader_playback_rate()); 560 561 EXPECT_TRUE(data_source_->loading()); 562 Stop(); 563 } 564 565 TEST_F(BufferedDataSourceTest, SetBitrate) { 566 InitializeWith206Response(); 567 568 data_source_->SetBitrate(1234); 569 message_loop_.RunUntilIdle(); 570 EXPECT_EQ(1234, data_source_bitrate()); 571 EXPECT_EQ(1234, loader_bitrate()); 572 573 // Read so far ahead to cause the loader to get recreated. 574 BufferedResourceLoader* old_loader = loader(); 575 ExpectCreateResourceLoader(); 576 ReadAt(kFarReadPosition); 577 Respond(response_generator_->Generate206(kFarReadPosition)); 578 579 // Verify loader changed but still has same bitrate. 580 EXPECT_NE(old_loader, loader()); 581 EXPECT_EQ(1234, loader_bitrate()); 582 583 EXPECT_TRUE(data_source_->loading()); 584 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); 585 Stop(); 586 } 587 588 TEST_F(BufferedDataSourceTest, MediaPlaybackRateChanged) { 589 InitializeWith206Response(); 590 591 data_source_->MediaPlaybackRateChanged(2.0f); 592 message_loop_.RunUntilIdle(); 593 EXPECT_EQ(2.0f, data_source_playback_rate()); 594 EXPECT_EQ(2.0f, loader_playback_rate()); 595 596 // Read so far ahead to cause the loader to get recreated. 597 BufferedResourceLoader* old_loader = loader(); 598 ExpectCreateResourceLoader(); 599 ReadAt(kFarReadPosition); 600 Respond(response_generator_->Generate206(kFarReadPosition)); 601 602 // Verify loader changed but still has same playback rate. 603 EXPECT_NE(old_loader, loader()); 604 605 EXPECT_TRUE(data_source_->loading()); 606 EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError)); 607 Stop(); 608 } 609 610 TEST_F(BufferedDataSourceTest, Http_Read) { 611 InitializeWith206Response(); 612 613 ReadAt(0); 614 615 // Receive first half of the read. 616 EXPECT_CALL(host_, AddBufferedByteRange(0, (kDataSize / 2) - 1)); 617 ReceiveData(kDataSize / 2); 618 619 // Receive last half of the read. 620 EXPECT_CALL(*this, ReadCallback(kDataSize)); 621 EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1)); 622 ReceiveData(kDataSize / 2); 623 624 EXPECT_TRUE(data_source_->downloading()); 625 Stop(); 626 } 627 628 TEST_F(BufferedDataSourceTest, Http_Read_Seek) { 629 InitializeWith206Response(); 630 631 // Read a bit from the beginning. 632 ReadAt(0); 633 EXPECT_CALL(*this, ReadCallback(kDataSize)); 634 EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1)); 635 ReceiveData(kDataSize); 636 637 // Simulate a seek by reading a bit beyond kDataSize. 638 ReadAt(kDataSize * 2); 639 640 // We receive data leading up to but not including our read. 641 EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2 - 1)); 642 ReceiveData(kDataSize); 643 644 // We now receive the rest of the data for our read. 645 EXPECT_CALL(*this, ReadCallback(kDataSize)); 646 EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 3 - 1)); 647 ReceiveData(kDataSize); 648 649 EXPECT_TRUE(data_source_->downloading()); 650 Stop(); 651 } 652 653 TEST_F(BufferedDataSourceTest, File_Read) { 654 InitializeWithFileResponse(); 655 656 ReadAt(0); 657 658 // Receive first half of the read but no buffering update. 659 ReceiveData(kDataSize / 2); 660 661 // Receive last half of the read but no buffering update. 662 EXPECT_CALL(*this, ReadCallback(kDataSize)); 663 ReceiveData(kDataSize / 2); 664 665 Stop(); 666 } 667 668 TEST_F(BufferedDataSourceTest, Http_FinishLoading) { 669 InitializeWith206Response(); 670 671 EXPECT_TRUE(data_source_->downloading()); 672 FinishLoading(); 673 EXPECT_FALSE(data_source_->downloading()); 674 675 Stop(); 676 } 677 678 TEST_F(BufferedDataSourceTest, File_FinishLoading) { 679 InitializeWithFileResponse(); 680 681 EXPECT_FALSE(data_source_->downloading()); 682 FinishLoading(); 683 EXPECT_FALSE(data_source_->downloading()); 684 685 Stop(); 686 } 687 688 TEST_F(BufferedDataSourceTest, LocalResource_DeferStrategy) { 689 InitializeWithFileResponse(); 690 691 EXPECT_EQ(AUTO, preload()); 692 EXPECT_TRUE(is_local_source()); 693 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 694 695 data_source_->MediaIsPlaying(); 696 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 697 698 data_source_->MediaIsPaused(); 699 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 700 701 Stop(); 702 } 703 704 TEST_F(BufferedDataSourceTest, LocalResource_PreloadMetadata_DeferStrategy) { 705 set_preload(METADATA); 706 InitializeWithFileResponse(); 707 708 EXPECT_EQ(METADATA, preload()); 709 EXPECT_TRUE(is_local_source()); 710 EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy()); 711 712 data_source_->MediaIsPlaying(); 713 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 714 715 data_source_->MediaIsPaused(); 716 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 717 718 Stop(); 719 } 720 721 TEST_F(BufferedDataSourceTest, ExternalResource_Reponse200_DeferStrategy) { 722 InitializeWith200Response(); 723 724 EXPECT_EQ(AUTO, preload()); 725 EXPECT_FALSE(is_local_source()); 726 EXPECT_FALSE(loader()->range_supported()); 727 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 728 729 data_source_->MediaIsPlaying(); 730 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 731 732 data_source_->MediaIsPaused(); 733 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 734 735 Stop(); 736 } 737 738 TEST_F(BufferedDataSourceTest, 739 ExternalResource_Response200_PreloadMetadata_DeferStrategy) { 740 set_preload(METADATA); 741 InitializeWith200Response(); 742 743 EXPECT_EQ(METADATA, preload()); 744 EXPECT_FALSE(is_local_source()); 745 EXPECT_FALSE(loader()->range_supported()); 746 EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy()); 747 748 data_source_->MediaIsPlaying(); 749 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 750 751 data_source_->MediaIsPaused(); 752 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 753 754 Stop(); 755 } 756 757 TEST_F(BufferedDataSourceTest, ExternalResource_Reponse206_DeferStrategy) { 758 InitializeWith206Response(); 759 760 EXPECT_EQ(AUTO, preload()); 761 EXPECT_FALSE(is_local_source()); 762 EXPECT_TRUE(loader()->range_supported()); 763 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 764 765 data_source_->MediaIsPlaying(); 766 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 767 set_might_be_reused_from_cache_in_future(true); 768 data_source_->MediaIsPaused(); 769 EXPECT_EQ(BufferedResourceLoader::kNeverDefer, defer_strategy()); 770 771 data_source_->MediaIsPlaying(); 772 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 773 set_might_be_reused_from_cache_in_future(false); 774 data_source_->MediaIsPaused(); 775 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 776 777 Stop(); 778 } 779 780 TEST_F(BufferedDataSourceTest, 781 ExternalResource_Response206_PreloadMetadata_DeferStrategy) { 782 set_preload(METADATA); 783 InitializeWith206Response(); 784 785 EXPECT_EQ(METADATA, preload()); 786 EXPECT_FALSE(is_local_source()); 787 EXPECT_TRUE(loader()->range_supported()); 788 EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy()); 789 790 data_source_->MediaIsPlaying(); 791 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 792 set_might_be_reused_from_cache_in_future(true); 793 data_source_->MediaIsPaused(); 794 EXPECT_EQ(BufferedResourceLoader::kNeverDefer, defer_strategy()); 795 796 data_source_->MediaIsPlaying(); 797 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 798 set_might_be_reused_from_cache_in_future(false); 799 data_source_->MediaIsPaused(); 800 EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy()); 801 802 Stop(); 803 } 804 805 } // namespace content 806