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())

[Ami GONE FROM CHROMIUM, 2011/04/08 03:02:10]

Is there a test here for the case of a lying server (claims to support range but
returns 200 instead of 206)?

[acolwell GONE FROM CHROMIUM, 2011/04/18 22:09:56]

Done. Added ServerLiesAboutRangeSupport test to simulate this situation.

         .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 115 matching lines @@
     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),
                         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)));
 
     EXPECT_CALL(*this, ReadCallback(size));
 
     data_source_->Read(
@@ skipping 44 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 167 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