media/blink/buffered_data_source_unittest.cc

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