Fix a regression with satisfying range requests out of the appcache and add a...

webkit/appcache/appcache_url_request_job_unittest.cc

 // Copyright (c) 2010 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 "base/compiler_specific.h"
 #include "base/pickle.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request.h"
@@ skipping 599 matching lines @@
     EXPECT_TRUE(CompareHttpResponseInfos(
         write_info_buffer_->http_info.get(),
         &url_request_delegate_->received_info_));
     EXPECT_EQ(3072, url_request_delegate_->amount_received_);
     char* p = url_request_delegate_->received_data_->data();
     for (int i = 0; i < 3; ++i, p += kBlockSize)
       EXPECT_TRUE(CheckData(i + 1, p, kBlockSize));
     TestFinished();
   }
 
+  // DeliverPartialResponse --------------------------------------
+
+  void DeliverPartialResponse() {
+    // This test has several async steps.
+    // 1. Write a small response to response storage.
+    // 2. Use URLRequest to retrieve it a subset using a range request
+    // 3. Verify we received what we expected to receive.
+    PushNextTask(NewRunnableMethod(
+       this, &AppCacheURLRequestJobTest::VerifyDeliverPartialResponse));
+    PushNextTask(NewRunnableMethod(
+       this, &AppCacheURLRequestJobTest::MakeRangeRequest));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
+    written_response_id_ = writer_->response_id();
+    WriteBasicResponse();
+    // Continues async
+  }
+
+  void MakeRangeRequest() {
+    AppCacheStorage* storage = service_->storage();
+    request_.reset(
+        new URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
+
+    // Request a range, the 3 middle chars out of 'Hello'
+    net::HttpRequestHeaders extra_headers;
+    extra_headers.SetHeader("Range", "bytes= 1-3");
+    request_->SetExtraRequestHeaders(extra_headers);
+
+    // Create job with orders to deliver an appcached entry.
+    scoped_refptr<AppCacheURLRequestJob> job(
+        new AppCacheURLRequestJob(request_.get(), storage));
+    job->DeliverAppCachedResponse(
+        GURL(), 111,
+        AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_));
+    EXPECT_TRUE(job->is_delivering_appcache_response());
+
+    // Start the request.
+    EXPECT_FALSE(job->has_been_started());
+    mock_factory_job_ = job;
+    request_->Start();
+    EXPECT_FALSE(mock_factory_job_);
+    EXPECT_TRUE(job->has_been_started());
+    // Completion is async.
+  }
+
+  void VerifyDeliverPartialResponse() {
+    EXPECT_TRUE(request_->status().is_success());
+    EXPECT_EQ(3, url_request_delegate_->amount_received_);
+    EXPECT_EQ(0, memcmp(kHttpBasicBody + 1,
+                        url_request_delegate_->received_data_->data(),
+                        3));
+    net::HttpResponseHeaders* headers =
+        url_request_delegate_->received_info_.headers.get();
+    EXPECT_EQ(206, headers->response_code());
+    EXPECT_EQ(3, headers->GetContentLength());
+    int64 range_start, range_end, object_size;
+    EXPECT_TRUE(
+        headers->GetContentRange(&range_start, &range_end, &object_size));
+    EXPECT_EQ(1, range_start);
+    EXPECT_EQ(3, range_end);
+    EXPECT_EQ(5, object_size);
+    TestFinished();
+  }
+
   // CancelRequest --------------------------------------
 
   void CancelRequest() {
     // This test has several async steps.
     // 1. Write a large response to response storage.
     // 2. Use URLRequest to retrieve it.
     // 3. Cancel the request after data starts coming in.
 
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::VerifyCancel));
@@ skipping 95 matching lines @@
 }
 
 TEST_F(AppCacheURLRequestJobTest, DeliverSmallAppCachedResponse) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::DeliverSmallAppCachedResponse);
 }
 
 TEST_F(AppCacheURLRequestJobTest, DeliverLargeAppCachedResponse) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::DeliverLargeAppCachedResponse);
 }
 
+TEST_F(AppCacheURLRequestJobTest, DeliverPartialResponse) {
+  RunTestOnIOThread(&AppCacheURLRequestJobTest::DeliverPartialResponse);
+}
+
 TEST_F(AppCacheURLRequestJobTest, CancelRequest) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequest);
 }
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequestWithIOPending) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequestWithIOPending);
 }
 
 }  // namespace appcache
 
 // AppCacheURLRequestJobTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheURLRequestJobTest);