Merge 21999 - BufferedDataSource to support server without range request supp...

webkit/glue/media/buffered_data_source_unittest.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 
 #include "base/string_util.h"
 #include "media/base/filters.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
@@ skipping 53 matching lines @@
   void Start() {
     InSequence s;
     EXPECT_CALL(bridge_factory_,
                 CreateBridge(gurl_, _, first_position_, last_position_))
         .WillOnce(Return(bridge_.get()));
     EXPECT_CALL(*bridge_, Start(loader_.get()));
     loader_->Start(NewCallback(this,
                                &BufferedResourceLoaderTest::StartCallback));
   }
 
-  void FullResponse(int64 content_length) {
+  void FullResponse(int64 instance_size) {
     EXPECT_CALL(*this, StartCallback(net::OK));
     ResourceLoaderBridge::ResponseInfo info;
     std::string header = StringPrintf("HTTP/1.1 200 OK\n"
-                                      "Content-Length: %lld", content_length);
+                                      "Content-Length: %lld", instance_size);
+    replace(header.begin(), header.end(), '\n', '\0');
+    info.headers = new net::HttpResponseHeaders(header);
+    info.content_length = instance_size;
+    loader_->OnReceivedResponse(info, false);
+    EXPECT_EQ(instance_size, loader_->content_length());
+    EXPECT_EQ(instance_size, loader_->instance_size());
+  }
+
+  void PartialResponse(int64 instance_size) {
+    EXPECT_CALL(*this, StartCallback(net::OK));
+    int64 content_length = last_position_ - first_position_ + 1;
+    ResourceLoaderBridge::ResponseInfo info;
+    std::string header = StringPrintf("HTTP/1.1 206 Partial Content\n"
+                                      "Content-Range: bytes %lld-%lld/%lld",
+                                      first_position_,
+                                      last_position_,
+                                      instance_size);
     replace(header.begin(), header.end(), '\n', '\0');
     info.headers = new net::HttpResponseHeaders(header);
     info.content_length = content_length;
     loader_->OnReceivedResponse(info, false);
     EXPECT_EQ(content_length, loader_->content_length());
-  }
-
-  void PartialResponse(int64 content_length) {
-    EXPECT_CALL(*this, StartCallback(net::OK));
-    ResourceLoaderBridge::ResponseInfo info;
-    std::string header = StringPrintf("HTTP/1.1 206 Partial Content\n"
-                                      "Content-Range: bytes %lld-%lld/%lld",
-                                      first_position_,
-                                      last_position_,
-                                      content_length);
-    replace(header.begin(), header.end(), '\n', '\0');
-    info.headers = new net::HttpResponseHeaders(header);
-    info.content_length = content_length;
-    loader_->OnReceivedResponse(info, false);
-    // TODO(hclam): Right now BufferedResourceLoader doesn't care about the
-    // partial range replied by the server. Do the check here.
+    EXPECT_EQ(instance_size, loader_->instance_size());
   }
 
   void StopWhenLoad() {
     InSequence s;
     EXPECT_CALL(*bridge_, Cancel());
     EXPECT_CALL(*bridge_, OnDestroy())
       .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
     loader_->Stop();
   }
 
@@ skipping 68 matching lines @@
   ResourceLoaderBridge::ResponseInfo info;
   info.headers = new net::HttpResponseHeaders("HTTP/1.1 404 Bot Found\n");
   loader_->OnReceivedResponse(info, false);
 }
 
 // Tests that partial content is requested but not fulfilled.
 TEST_F(BufferedResourceLoaderTest, NotPartialRange) {
   Initialize(kHttpUrl, 100, -1);
   Start();
 
-  EXPECT_CALL(*this, StartCallback(net::ERR_INVALID_RESPONSE));
+  EXPECT_CALL(*this, StartCallback(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE));
   EXPECT_CALL(*bridge_, Cancel());
   EXPECT_CALL(*bridge_, OnDestroy())
       .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
 
   ResourceLoaderBridge::ResponseInfo info;
   info.headers = new net::HttpResponseHeaders("HTTP/1.1 200 OK\n");
   loader_->OnReceivedResponse(info, false);
 }
 
 // Tests that a 200 response is received.
@@ skipping 34 matching lines @@
   VerifyBuffer(buffer, 20, 5);
   EXPECT_CALL(*this, ReadCallback(5));
   ReadLoader(25, 5, buffer);
   VerifyBuffer(buffer, 25, 5);
 
   // Read backward within buffer.
   EXPECT_CALL(*this, ReadCallback(10));
   ReadLoader(10, 10, buffer);
   VerifyBuffer(buffer, 10, 10);
 
-  // Read backwith outside buffer.
+  // Read backward outside buffer.
   EXPECT_CALL(*this, ReadCallback(net::ERR_CACHE_MISS));
   ReadLoader(9, 10, buffer);
 
   // Response has completed.
   EXPECT_CALL(*bridge_, OnDestroy())
       .WillOnce(Invoke(this, &BufferedResourceLoaderTest::ReleaseBridge));
   URLRequestStatus status;
   status.set_status(URLRequestStatus::SUCCESS);
   loader_->OnCompletedRequest(status, "");
 
   // Try to read 10 from position 25 will just return with 5 bytes.
   EXPECT_CALL(*this, ReadCallback(5));
   ReadLoader(25, 10, buffer);
   VerifyBuffer(buffer, 25, 5);
 
   // Try to read outside buffered range after request has completed.
   EXPECT_CALL(*this, ReadCallback(net::ERR_CACHE_MISS));
   ReadLoader(5, 10, buffer);
-  EXPECT_CALL(*this, ReadCallback(net::ERR_CACHE_MISS));
+
+  // Try to read beyond the instance size.
+  EXPECT_CALL(*this, ReadCallback(0));
   ReadLoader(30, 10, buffer);
 }
 
 TEST_F(BufferedResourceLoaderTest, ReadOutsideBuffer) {
   Initialize(kHttpUrl, 10, 0x00FFFFFF);
   Start();
   PartialResponse(0x01000000);
 
   uint8 buffer[10];
   InSequence s;
@@ skipping 48 matching lines @@
 
   ~MockBufferedResourceLoader() {
     OnDestroy();
   }
 
   MOCK_METHOD1(Start, void(net::CompletionCallback* read_callback));
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD4(Read, void(int64 position, int read_size, uint8* buffer,
                           net::CompletionCallback* callback));
   MOCK_METHOD0(content_length, int64());
+  MOCK_METHOD0(instance_size, int64());
   MOCK_METHOD0(OnDestroy, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBufferedResourceLoader);
 };
 
 // A mock BufferedDataSource to inject mock BufferedResourceLoader through
 // CreateLoader() method.
 class MockBufferedDataSource : public BufferedDataSource {
  public:
@@ skipping 54 matching lines @@
       // Expects bridge factory to be destroyed along with data source.
       EXPECT_CALL(*bridge_factory_, OnDestroy())
           .WillOnce(Invoke(this,
                            &BufferedDataSourceTest::ReleaseBridgeFactory));
     }
 
     // We don't own the message loop so release it.
     message_loop_.release();
   }
 
-  void InitializeDataSource(const char* url, int error, int64 content_length) {
+  void InitializeDataSource(const char* url, int error, int probe_error,
+                            int64 instance_size) {
     // Saves the url first.
     gurl_ = GURL(url);
 
     media::MediaFormat url_format;
     url_format.SetAsString(media::MediaFormat::kMimeType,
                            media::mime_type::kURL);
     url_format.SetAsString(media::MediaFormat::kURL, url);
     data_source_ = factory_->Create<MockBufferedDataSource>(url_format);
     CHECK(data_source_);
 
     // There is no need to provide a message loop to data source.
     data_source_->set_host(&host_);
 
     // Creates the first mock loader to be injected.
     loader_.reset(new StrictMock<MockBufferedResourceLoader>());
+    probe_loader_.reset(new StrictMock<MockBufferedResourceLoader>());
 
     InSequence s;
     StrictMock<media::MockFilterCallback> callback;
+
+    // There is one resource loader with full range will be created.
     EXPECT_CALL(*data_source_, CreateLoader(-1, -1))
         .WillOnce(Return(loader_.get()));
+
+    // Then another resource loader with a small partial range is created.
+    EXPECT_CALL(*data_source_, CreateLoader(1, 1))
+        .WillOnce(Return(probe_loader_.get()));
+
+    // The initial response loader will be started.
     EXPECT_CALL(*loader_, Start(NotNull()))
         .WillOnce(DoAll(Assign(&error_, error),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeStartCallback)));
-    if (error != net::OK) {
+    if (error == net::OK) {
+      EXPECT_CALL(*loader_, instance_size())
+          .WillOnce(Return(instance_size));
+      if (instance_size != -1) {
+        EXPECT_CALL(host_, SetTotalBytes(instance_size));
+        EXPECT_CALL(host_, SetBufferedBytes(instance_size));
+      } else {
+        EXPECT_CALL(host_, SetStreaming(true));
+      }
+
+      // Then the probe resource loader will start.
+      EXPECT_CALL(*probe_loader_, Start(NotNull()))
+          .WillOnce(DoAll(Assign(&error_, probe_error),
+                    Invoke(this,
+                           &BufferedDataSourceTest::InvokeStartCallback)));
+      if (probe_error != net::OK)
+        EXPECT_CALL(host_, SetStreaming(true));
+      EXPECT_CALL(*probe_loader_, Stop());
+      EXPECT_CALL(callback, OnFilterCallback());
+      EXPECT_CALL(callback, OnCallbackDestroyed());
+    } else {
       EXPECT_CALL(host_, SetError(media::PIPELINE_ERROR_NETWORK));
       EXPECT_CALL(*loader_, Stop());
-    } else {
-      EXPECT_CALL(*loader_, content_length())
-          .WillOnce(Return(content_length));
-      EXPECT_CALL(host_, SetTotalBytes(content_length));
-      EXPECT_CALL(host_, SetBufferedBytes(content_length));
+      EXPECT_CALL(*probe_loader_, Stop());
+      EXPECT_CALL(callback, OnFilterCallback());
+      EXPECT_CALL(callback, OnCallbackDestroyed());
+
+      // This expectation looks a little strange, but this is actually what
+      // will happen since we are not running a message loop. So simply
+      // delete the callback.
+      EXPECT_CALL(*probe_loader_, Start(NotNull()))
+          .WillOnce(DeleteArg<0>());
     }
-    EXPECT_CALL(callback, OnFilterCallback());
-    EXPECT_CALL(callback, OnCallbackDestroyed());
 
     data_source_->Initialize(url, callback.NewCallback());
     message_loop_->RunAllPending();
 
     if (error == net::OK) {
+      // Verify the size of the data source.
       int64 size;
-      EXPECT_TRUE(data_source_->GetSize(&size));
-      EXPECT_EQ(content_length, size);
+      if (instance_size != -1) {
+        EXPECT_TRUE(data_source_->GetSize(&size));
+        EXPECT_EQ(instance_size, size);
+
+        if (probe_error == net::OK) {
+          EXPECT_FALSE(data_source_->IsStreaming());
+        }
+      } else {
+        EXPECT_FALSE(data_source_->GetSize(&size));
+        EXPECT_EQ(0, size);
+        EXPECT_TRUE(data_source_->IsStreaming());
+      }
+
+      // Verify the data source is streamed if the probe has received an error.
+      if (probe_error != net::OK) {
+        EXPECT_TRUE(data_source_->IsStreaming());
+      }
     }
   }
 
   void StopDataSource() {
     if (loader_.get()) {
       InSequence s;
       EXPECT_CALL(*loader_, Stop());
-      EXPECT_CALL(*loader_, OnDestroy())
-          .WillOnce(Invoke(this, &BufferedDataSourceTest::ReleaseLoader));
+      EXPECT_CALL(*probe_loader_, Stop());
     }
 
+    EXPECT_CALL(*loader_, OnDestroy())
+       .WillOnce(Invoke(this, &BufferedDataSourceTest::ReleaseLoader));
+    EXPECT_CALL(*probe_loader_, OnDestroy())
+       .WillOnce(Invoke(this, &BufferedDataSourceTest::ReleaseProbeLoader));
+
     data_source_->Stop();
     message_loop_->RunAllPending();
   }
 
   void ReleaseBridgeFactory() {
     bridge_factory_.release();
   }
 
   void ReleaseLoader() {
     loader_.release();
   }
 
+  void ReleaseProbeLoader() {
+    probe_loader_.release();
+  }
+
   void InvokeStartCallback(net::CompletionCallback* callback) {
     callback->RunWithParams(Tuple1<int>(error_));
     delete callback;
   }
 
   void InvokeReadCallback(int64 position, int size, uint8* buffer,
                           net::CompletionCallback* callback) {
     if (error_ > 0)
       memcpy(buffer, data_ + static_cast<int>(position), error_);
     callback->RunWithParams(Tuple1<int>(error_));
@@ skipping 71 matching lines @@
   void ReadDataSourceFailed(int64 position, int size, int error) {
     EXPECT_TRUE(loader_.get() != NULL);
 
     InSequence s;
     // 1. Expect the read is delegated to the resource loader.
     EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, error),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeReadCallback)));
 
-    // 2. The read has failed, so read callback will be called.
+    // 2. Host will then receive an error.
+    EXPECT_CALL(*loader_, Stop());
+
+    // 3. The read has failed, so read callback will be called.
     EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
 
-    // 3. Host will then receive an error.
-    EXPECT_CALL(host_, SetError(media::PIPELINE_ERROR_NETWORK));
-
-    // 4. The the loader is destroyed.
-    EXPECT_CALL(*loader_, Stop());
-
     data_source_->Read(
         position, size, buffer_,
         NewCallback(this, &BufferedDataSourceTest::ReadCallback));
 
     message_loop_->RunAllPending();
   }
 
   void ReadDataSourceTimesOut(int64 position, int size) {
     InSequence s;
     // 1. Drop the request and let it times out.
     EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
         .WillOnce(DeleteArg<3>());
-    
+
     // 2. Then the current loader will be stop and destroyed.
     StrictMock<MockBufferedResourceLoader> *new_loader =
         new StrictMock<MockBufferedResourceLoader>();
     EXPECT_CALL(*loader_, Stop());
     EXPECT_CALL(*data_source_, CreateLoader(position, -1))
         .WillOnce(Return(new_loader));
     EXPECT_CALL(*loader_, OnDestroy())
         .WillOnce(Invoke(this, &BufferedDataSourceTest::ReleaseLoader));
-    
+
     // 3. Then the new loader will be started.
     EXPECT_CALL(*new_loader, Start(NotNull()))
         .WillOnce(DoAll(Assign(&error_, net::OK),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeStartCallback)));
-    
+
     // 4. Then again a read request is made to the new loader.
     EXPECT_CALL(*new_loader, Read(position, size, NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, size),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeReadCallback),
                         InvokeWithoutArgs(message_loop_.get(),
                                           &MessageLoop::Quit)));
 
     EXPECT_CALL(*this, ReadCallback(size));
-    
+
     data_source_->Read(
         position, size, buffer_,
         NewCallback(this, &BufferedDataSourceTest::ReadCallback));
 
     // This blocks the current thread until the watch task is executed and
     // triggers a read callback to quit this message loop.
     message_loop_->Run();
 
     // Make sure data is correct.
     EXPECT_EQ(0, memcmp(buffer_, data_ + static_cast<int>(position), size));
-    
+
     EXPECT_TRUE(loader_.get() == NULL);
     loader_.reset(new_loader);
   }
 
   MOCK_METHOD1(ReadCallback, void(size_t size));
 
   scoped_ptr<StrictMock<MockMediaResourceLoaderBridgeFactory> >
       bridge_factory_;
   scoped_ptr<StrictMock<MockBufferedResourceLoader> > loader_;
+  scoped_ptr<StrictMock<MockBufferedResourceLoader> > probe_loader_;
   scoped_refptr<MockBufferedDataSource > data_source_;
   scoped_refptr<media::FilterFactory> factory_;
 
   StrictMock<media::MockFilterHost> host_;
   GURL gurl_;
   scoped_ptr<MessageLoop> message_loop_;
 
   int error_;
   uint8 buffer_[1024];
   uint8 data_[1024];
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceTest);
 };
 
 TEST_F(BufferedDataSourceTest, InitializationSuccess) {
-  InitializeDataSource(kHttpUrl, net::OK, 1024);
+  InitializeDataSource(kHttpUrl, net::OK, net::OK, 1024);
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, InitiailizationFailed) {
-  InitializeDataSource(kHttpUrl, net::ERR_FILE_NOT_FOUND, 0);
+  InitializeDataSource(kHttpUrl, net::ERR_FILE_NOT_FOUND,
+                       net::ERR_FILE_NOT_FOUND, 0);
+  StopDataSource();
+}
+
+TEST_F(BufferedDataSourceTest, MissingContentLength) {
+  InitializeDataSource(kHttpUrl, net::OK, net::OK, -1);
+  StopDataSource();
+}
+
+TEST_F(BufferedDataSourceTest, RangeRequestNotSupported) {
+  InitializeDataSource(kHttpUrl, net::OK,
+                       net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, 1024);
+  StopDataSource();
+}
+
+TEST_F(BufferedDataSourceTest,
+       MissingContentLengthAndRangeRequestNotSupported) {
+  InitializeDataSource(kHttpUrl, net::OK,
+                       net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, -1);
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, ReadCacheHit) {
-  InitializeDataSource(kHttpUrl, net::OK, 25);
+  InitializeDataSource(kHttpUrl, net::OK, net::OK, 25);
 
   // Performs read with cache hit.
   ReadDataSourceHit(10, 10, 10);
 
   // Performs read with cache hit but partially filled.
   ReadDataSourceHit(20, 10, 5);
 
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, ReadCacheMiss) {
-  InitializeDataSource(kHttpUrl, net::OK, 1024);
+  InitializeDataSource(kHttpUrl, net::OK, net::OK, 1024);
   ReadDataSourceMiss(1000, 10);
   ReadDataSourceMiss(20, 10);
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, ReadFailed) {
-  InitializeDataSource(kHttpUrl, net::OK, 1024);
+  InitializeDataSource(kHttpUrl, net::OK, net::OK, 1024);
   ReadDataSourceHit(10, 10, 10);
   ReadDataSourceFailed(10, 10, net::ERR_CONNECTION_RESET);
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, ReadTimesOut) {
   InitializeDataSource(kHttpUrl, net::OK, 1024);
   ReadDataSourceTimesOut(20, 10);
   StopDataSource();
 }
 
 }  // namespace webkit_glue