Home | History | Annotate | Download | only in media 
      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