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

webkit/glue/media/buffered_resource_loader_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/format_macros.h"
 #include "base/stringprintf.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_util.h"
@@ skipping 85 matching lines @@
   void Start() {
     InSequence s;
     EXPECT_CALL(*url_loader_, loadAsynchronously(_, loader_.get()));
     loader_->Start(
         NewCallback(this, &BufferedResourceLoaderTest::StartCallback),
         NewCallback(this, &BufferedResourceLoaderTest::NetworkCallback),
         frame_.get());
   }
 
   void FullResponse(int64 instance_size) {
-    EXPECT_CALL(*this, StartCallback(net::OK));
+    FullResponse(instance_size, net::OK);
+  }
+
+  void FullResponse(int64 instance_size, int status) {
+    EXPECT_CALL(*this, StartCallback(status));
+    if (status != net::OK) {
+      EXPECT_CALL(*url_loader_, cancel())
+          .WillOnce(RequestCanceled(loader_));
+    }
 
     WebURLResponse response(gurl_);
     response.setHTTPHeaderField(WebString::fromUTF8("Content-Length"),
                                 WebString::fromUTF8(base::StringPrintf("%"
                                     PRId64, instance_size)));
     response.setExpectedContentLength(instance_size);
     response.setHTTPStatusCode(kHttpOK);
     loader_->didReceiveResponse(url_loader_, response);
-    EXPECT_EQ(instance_size, loader_->content_length());
-    EXPECT_EQ(instance_size, loader_->instance_size());
-    EXPECT_FALSE(loader_->partial_response());
+
+    if (status == net::OK) {
+      EXPECT_EQ(instance_size, loader_->content_length());
+      EXPECT_EQ(instance_size, loader_->instance_size());
+    }
+
+    EXPECT_FALSE(loader_->range_supported());
   }
 
   void PartialResponse(int64 first_position, int64 last_position,
                        int64 instance_size) {
     EXPECT_CALL(*this, StartCallback(net::OK));
     int64 content_length = last_position - first_position + 1;
 
     WebURLResponse response(gurl_);
+    response.setHTTPHeaderField(WebString::fromUTF8("Accept-Ranges"),
+                                WebString::fromUTF8("bytes"));
     response.setHTTPHeaderField(WebString::fromUTF8("Content-Range"),
                                 WebString::fromUTF8(base::StringPrintf("bytes "
                                             "%" PRId64 "-%" PRId64 "/%" PRId64,
                                             first_position,
                                             last_position,
                                             instance_size)));
     response.setExpectedContentLength(content_length);
     response.setHTTPStatusCode(kHttpPartialContent);
     loader_->didReceiveResponse(url_loader_, response);
     EXPECT_EQ(content_length, loader_->content_length());
     EXPECT_EQ(instance_size, loader_->instance_size());
-    EXPECT_TRUE(loader_->partial_response());
+    EXPECT_TRUE(loader_->range_supported());
   }
 
   void Redirect(const char* url) {
     GURL redirectUrl(url);
     WebKit::WebURLRequest newRequest(redirectUrl);
     WebKit::WebURLResponse redirectResponse(gurl_);
 
     loader_->willSendRequest(url_loader_, newRequest, redirectResponse);
 
     MessageLoop::current()->RunAllPending();
@@ skipping 69 matching lines @@
   WebURLResponse response(gurl_);
   response.setHTTPStatusCode(404);
   response.setHTTPStatusText("Not Found\n");
   loader_->didReceiveResponse(url_loader_, response);
 }
 
 // Tests that partial content is requested but not fulfilled.
 TEST_F(BufferedResourceLoaderTest, NotPartialResponse) {
   Initialize(kHttpUrl, 100, -1);
   Start();
-  FullResponse(1024);
-  StopWhenLoad();
+  FullResponse(1024, net::ERR_INVALID_RESPONSE);
 }
 
 // Tests that a 200 response is received.
 TEST_F(BufferedResourceLoaderTest, FullResponse) {
   Initialize(kHttpUrl, -1, -1);
   Start();
   FullResponse(1024);
   StopWhenLoad();
 }
 
@@ skipping 244 matching lines @@
   Start();
   Redirect(kHttpRedirectToSameDomainUrl1);
   Redirect(kHttpRedirectToDifferentDomainUrl1);
   EXPECT_FALSE(loader_->HasSingleOrigin());
   StopWhenLoad();
 }
 
 // TODO(hclam): add unit test for defer loading.
 
 }  // namespace webkit_glue