Only make Range requests when the desired range doesn't cover the whole file.

webkit/glue/media/buffered_data_source_unittest.cc

 // Copyright (c) 2011 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/test/test_timeouts.h"
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
@@ skipping 58 matching lines @@
   }
 
   MOCK_METHOD3(Start, void(net::CompletionCallback* read_callback,
                            NetworkEventCallback* network_callback,
                            WebFrame* frame));
   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(partial_response, bool());
+  MOCK_METHOD0(range_supported, bool());
   MOCK_METHOD0(network_activity, bool());
   MOCK_METHOD0(url, const GURL&());
   MOCK_METHOD0(GetBufferedFirstBytePosition, int64());
   MOCK_METHOD0(GetBufferedLastBytePosition, int64());
 
  protected:
   ~MockBufferedResourceLoader() {}
 
   DISALLOW_COPY_AND_ASSIGN(MockBufferedResourceLoader);
 };
@@ skipping 67 matching lines @@
       }
     }
 
     // Attach a static function that deletes the memory referred by the
     // "callback" parameter.
     ON_CALL(*loader_, Read(_, _, _ , _))
         .WillByDefault(DeleteArg<3>());
 
     ON_CALL(*loader_, instance_size())
         .WillByDefault(Return(instance_size));
-    ON_CALL(*loader_, partial_response())
+
+    // range_supported() return true if we expect to get a partial response.
+    ON_CALL(*loader_, range_supported())
         .WillByDefault(Return(partial_response));
+
     ON_CALL(*loader_, url())
         .WillByDefault(ReturnRef(gurl_));
     media::PipelineStatus expected_init_status = media::PIPELINE_OK;
     if (initialized_ok) {
       // Expected loaded or not.
       EXPECT_CALL(host_, SetLoaded(loaded));
 
       // TODO(hclam): The condition for streaming needs to be adjusted.
       if (instance_size != -1 && (loaded || partial_response)) {
         EXPECT_CALL(host_, SetTotalBytes(instance_size));
@@ skipping 91 matching lines @@
     EXPECT_CALL(*this, ReadCallback(_));
     EXPECT_CALL(*loader_, Stop());
     data_source_->Abort();
     message_loop_->RunAllPending();
 
     // The loader has now been stopped. Set this to null so that when the
     // DataSource is stopped, it does not expect a call to stop the loader.
     loader_ = NULL;
   }
 
-  void ReadDataSourceMiss(int64 position, int size) {
+  void ReadDataSourceMiss(int64 position, int size, int start_error) {
     EXPECT_TRUE(loader_);
 
     // 1. Reply with a cache miss for the read.
     {
       InSequence s;
       EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
           .WillOnce(DoAll(Assign(&error_, net::ERR_CACHE_MISS),
                           Invoke(this,
                                  &BufferedDataSourceTest::InvokeReadCallback)));
       EXPECT_CALL(*loader_, Stop());
     }
 
     // 2. Then the current loader will be stop and destroyed.
     NiceMock<MockBufferedResourceLoader> *new_loader =
         new NiceMock<MockBufferedResourceLoader>();
     EXPECT_CALL(*data_source_, CreateResourceLoader(position, -1))
         .WillOnce(Return(new_loader));
 
     // 3. Then the new loader will be started.
     EXPECT_CALL(*new_loader, Start(NotNull(), NotNull(), NotNull()))
-        .WillOnce(DoAll(Assign(&error_, net::OK),
+        .WillOnce(DoAll(Assign(&error_, start_error),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeStartCallback)));
-    EXPECT_CALL(*new_loader, partial_response())
-        .WillRepeatedly(Return(loader_->partial_response()));
 
-    // 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)));
+    if (start_error == net::OK) {
+      EXPECT_CALL(*new_loader, range_supported())
+          .WillRepeatedly(Return(loader_->range_supported()));
 
-    EXPECT_CALL(*this, ReadCallback(size));
+      // 4a. 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)));
+
+      EXPECT_CALL(*this, ReadCallback(size));
+    } else {
+      // 4b. The read callback is called with an error because Start() on the
+      // new loader returned an error.
+      EXPECT_CALL(*this, ReadCallback(media::DataSource::kReadError));
+    }
 
     data_source_->Read(
         position, size, buffer_,
         NewCallback(this, &BufferedDataSourceTest::ReadCallback));
     message_loop_->RunAllPending();
 
     // Make sure data is correct.
-    EXPECT_EQ(0, memcmp(buffer_, data_ + static_cast<int>(position), size));
+    if (start_error == net::OK)
+      EXPECT_EQ(0, memcmp(buffer_, data_ + static_cast<int>(position), size));
 
     loader_ = new_loader;
   }
 
   void ReadDataSourceFailed(int64 position, int size, int error) {
     EXPECT_TRUE(loader_);
 
     // 1. Expect the read is delegated to the resource loader.
     EXPECT_CALL(*loader_, Read(position, size, NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, error),
@@ skipping 28 matching lines @@
     EXPECT_CALL(*data_source_, CreateResourceLoader(position, -1))
         .WillOnce(Return(new_loader));
 
     // 3. Then the new loader will be started and respond to queries about
     //    whether this is a partial response using the value of the previous
     //    loader.
     EXPECT_CALL(*new_loader, Start(NotNull(), NotNull(), NotNull()))
         .WillOnce(DoAll(Assign(&error_, net::OK),
                         Invoke(this,
                                &BufferedDataSourceTest::InvokeStartCallback)));
-    EXPECT_CALL(*new_loader, partial_response())
-        .WillRepeatedly(Return(loader_->partial_response()));
+    EXPECT_CALL(*new_loader, range_supported())
+        .WillRepeatedly(Return(loader_->range_supported()));
 
     // 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_,
                                           &MessageLoop::Quit)));
 
     EXPECT_CALL(*this, ReadCallback(size));
@@ skipping 70 matching lines @@
   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, true, 1024, LOADING);
-  ReadDataSourceMiss(1000, 10);
-  ReadDataSourceMiss(20, 10);
+  ReadDataSourceMiss(1000, 10, net::OK);
+  ReadDataSourceMiss(20, 10, net::OK);
   StopDataSource();
 }
 
+// Test the case where the initial response from the server indicates that
+// Range requests are supported, but a later request prove otherwise.
+TEST_F(BufferedDataSourceTest, ServerLiesAboutRangeSupport) {
+  InitializeDataSource(kHttpUrl, net::OK, true, 1024, LOADING);
+  ReadDataSourceHit(10, 10, 10);
+  ReadDataSourceMiss(1000, 10, net::ERR_INVALID_RESPONSE);
+  StopDataSource();
+}
+
 TEST_F(BufferedDataSourceTest, ReadHang) {
   InitializeDataSource(kHttpUrl, net::OK, true, 25, LOADING);
   ReadDataSourceHang(10, 10);
   StopDataSource();
 }
 
 TEST_F(BufferedDataSourceTest, ReadFailed) {
   InitializeDataSource(kHttpUrl, net::OK, true, 1024, LOADING);
   ReadDataSourceHit(10, 10, 10);
   ReadDataSourceFailed(10, 10, net::ERR_CONNECTION_RESET);
@@ skipping 72 matching lines @@
   data_source_->Stop(media::NewExpectedCallback());
 
   // Allow cleanup task to run.
   message_loop_->RunAllPending();
 
   // Verify that Read() was not called on the loader.
   EXPECT_FALSE(read_called);
 }
 
 }  // namespace webkit_glue