Http Cache: First pass of byte-range requests support....

net/http/http_cache.cc

 // Copyright (c) 2006-2008 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 "net/http/http_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 
@@ skipping 10 matching lines @@
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_util.h"
+#include "net/http/partial_data.h"
 
 using base::Time;
 
+// Uncomment this to enable experimental byte-range support.
+// #define ENABLE_RANGE_SUPPORT
+
 namespace net {
 
 // disk cache entry data indices.
 enum {
   kResponseInfoIndex,
   kResponseContentIndex
 };
 
 // These values can be bit-wise combined to form the flags field of the
 // serialized HttpResponseInfo.
@@ skipping 25 matching lines @@
 //-----------------------------------------------------------------------------
 
 struct HeaderNameAndValue {
   const char* name;
   const char* value;
 };
 
 // If the request includes one of these request headers, then avoid caching
 // to avoid getting confused.
 static const HeaderNameAndValue kPassThroughHeaders[] = {
-  { "range", NULL },                // causes unexpected 206s
   { "if-modified-since", NULL },    // causes unexpected 304s
   { "if-none-match", NULL },        // causes unexpected 304s
   { "if-unmodified-since", NULL },  // causes unexpected 412s
   { "if-match", NULL },             // causes unexpected 412s
   { NULL, NULL }
 };
 
 // If the request includes one of these request headers, then avoid reusing
 // our cached copy if any.
 static const HeaderNameAndValue kForceFetchHeaders[] = {
@@ skipping 22 matching lines @@
     while (v.GetNext()) {
       if (LowerCaseEqualsASCII(v.value_begin(), v.value_end(), search->value))
         return true;
     }
   }
   return false;
 }
 
 //-----------------------------------------------------------------------------
 
-//-----------------------------------------------------------------------------
-
 HttpCache::ActiveEntry::ActiveEntry(disk_cache::Entry* e)
     : disk_entry(e),
       writer(NULL),
       will_process_pending_queue(false),
       doomed(false) {
 }
 
 HttpCache::ActiveEntry::~ActiveEntry() {
   if (disk_entry)
     disk_entry->Close();
 }
 
 //-----------------------------------------------------------------------------
 
 class HttpCache::Transaction
     : public HttpTransaction, public RevocableStore::Revocable {
  public:
   explicit Transaction(HttpCache* cache)
       : RevocableStore::Revocable(&cache->transactions_),
         request_(NULL),
         cache_(cache),
         entry_(NULL),
         network_trans_(NULL),
         callback_(NULL),
         mode_(NONE),
+        reading_(false),
         read_offset_(0),
         effective_load_flags_(0),
         final_upload_progress_(0),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             network_info_callback_(this, &Transaction::OnNetworkInfoAvailable)),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             network_read_callback_(this, &Transaction::OnNetworkReadCompleted)),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             cache_read_callback_(new CancelableCompletionCallback<Transaction>(
                 this, &Transaction::OnCacheReadCompleted))) {
@@ skipping 65 matching lines @@
 
   // Returns true if we should force an end-to-end fetch.
   bool ShouldBypassCache();
 
   // Called to begin reading from the cache.  Returns network error code.
   int BeginCacheRead();
 
   // Called to begin validating the cache entry.  Returns network error code.
   int BeginCacheValidation();
 
+  // Called to begin validating an entry that stores partial content.  Returns
+  // a network error code.
+  int BeginPartialCacheValidation();
+
+  // Performs the cache validation for the next chunk of data stored by the
+  // cache.  If this chunk is not currently stored, starts the network request
+  // to fetch it.  Returns a network error code.
+  int ContinuePartialCacheValidation();
+
   // Called to begin a network transaction.  Returns network error code.
   int BeginNetworkRequest();
 
   // Called to restart a network transaction after an error.  Returns network
   // error code.
   int RestartNetworkRequest();
 
   // Called to restart a network transaction with authentication credentials.
   // Returns network error code.
   int RestartNetworkRequestWithAuth(const std::wstring& username,
                                     const std::wstring& password);
 
   // Called to determine if we need to validate the cache entry before using it.
   bool RequiresValidation();
 
   // Called to make the request conditional (to ask the server if the cached
   // copy is valid).  Returns true if able to make the request conditional.
   bool ConditionalizeRequest();
 
+  // Reads data from the network.
+  int ReadFromNetwork(IOBuffer* data, int data_len);
+
+  // Reads data from the cache entry.
+  int ReadFromEntry(IOBuffer* data, int data_len);
+
   // Called to populate response_ from the cache entry.
   int ReadResponseInfoFromEntry();
 
   // Called to write data to the cache entry.  If the write fails, then the
   // cache entry is destroyed.  Future calls to this function will just do
   // nothing without side-effect.
   void WriteToEntry(int index, int offset, IOBuffer* data, int data_len);
 
   // Called to write response_ to the cache entry.
   void WriteResponseInfoToEntry();
 
   // Called to truncate response content in the entry.
   void TruncateResponseData();
 
   // Called to append response data to the cache entry.
   void AppendResponseDataToEntry(IOBuffer* data, int data_len);
 
   // Called when we are done writing to the cache entry.
   void DoneWritingToEntry(bool success);
 
+  // Performs the needed work after receiving data from the network.
+  int DoNetworkReadCompleted(int result);
+
+  // Performs the needed work after receiving data from the network, when
+  // working with range requests.
+  int DoPartialNetworkReadCompleted(int result);
+
+  // Performs the needed work after receiving data from the cache.
+  int DoCacheReadCompleted(int result);
+
+  // Performs the needed work after receiving data from the cache, when
+  // working with range requests.
+  int DoPartialCacheReadCompleted(int result);
+
   // Called to signal completion of the network transaction's Start method:
   void OnNetworkInfoAvailable(int result);
 
   // Called to signal completion of the network transaction's Read method:
   void OnNetworkReadCompleted(int result);
 
   // Called to signal completion of the cache's ReadData method:
   void OnCacheReadCompleted(int result);
 
   const HttpRequestInfo* request_;
   scoped_ptr<HttpRequestInfo> custom_request_;
   HttpCache* cache_;
   HttpCache::ActiveEntry* entry_;
   scoped_ptr<HttpTransaction> network_trans_;
-  CompletionCallback* callback_;  // consumer's callback
+  CompletionCallback* callback_;  // Consumer's callback.
   HttpResponseInfo response_;
   HttpResponseInfo auth_response_;
   std::string cache_key_;
   Mode mode_;
+  bool reading_;  // We are already reading.
   scoped_refptr<IOBuffer> read_buf_;
+  int read_buf_len_;
   int read_offset_;
   int effective_load_flags_;
+  scoped_ptr<PartialData> partial_;  // We are dealing with range requests.
   uint64 final_upload_progress_;
   CompletionCallbackImpl<Transaction> network_info_callback_;
   CompletionCallbackImpl<Transaction> network_read_callback_;
   scoped_refptr<CancelableCompletionCallback<Transaction> >
       cache_read_callback_;
 };
 
 HttpCache::Transaction::~Transaction() {
   if (!revoked()) {
     if (entry_) {
@@ skipping 121 matching lines @@
   // previous response in the cache then we should leave it intact.
   if (auth_response_.headers && mode_ != NONE) {
     DCHECK(mode_ & WRITE);
     DoneWritingToEntry(mode_ == READ_WRITE);
     mode_ = NONE;
   }
 
   int rv;
 
   switch (mode_) {
+    case READ_WRITE:
+      DCHECK(partial_.get());
+      reading_ = true;
+      if (!network_trans_.get()) {
+        // We are just reading from the cache, but we may be writing later.
+        rv = ReadFromEntry(buf, buf_len);
+        break;
+      }
     case NONE:
     case WRITE:
       DCHECK(network_trans_.get());
-      rv = network_trans_->Read(buf, buf_len, &network_read_callback_);
-      read_buf_ = buf;
-      if (rv >= 0)
-        OnNetworkReadCompleted(rv);
+      rv = ReadFromNetwork(buf, buf_len);
       break;
     case READ:
-      DCHECK(entry_);
-      cache_read_callback_->AddRef();  // Balanced in OnCacheReadCompleted.
-      rv = entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_,
-                                        buf, buf_len, cache_read_callback_);
-      read_buf_ = buf;
-      if (rv >= 0) {
-        OnCacheReadCompleted(rv);
-      } else if (rv != ERR_IO_PENDING) {
-        cache_read_callback_->Release();
-      }
+      rv = ReadFromEntry(buf, buf_len);
       break;
     default:
       NOTREACHED();
       rv = ERR_FAILED;
   }
 
-  if (rv == ERR_IO_PENDING)
+  if (rv == ERR_IO_PENDING) {
+    DCHECK(!callback_);
     callback_ = callback;
+  }
   return rv;
 }
 
 const HttpResponseInfo* HttpCache::Transaction::GetResponseInfo() const {
   // Null headers means we encountered an error or haven't a response yet
   if (auth_response_.headers)
     return &auth_response_;
   return (response_.headers || response_.ssl_info.cert) ? &response_ : NULL;
 }
 
@@ skipping 64 matching lines @@
   //    to be validated and then issue a network request if needed or just read
   //    from the cache if the cache entry is already valid.
   //
   int rv;
   entry_ = entry;
   switch (mode_) {
     case READ:
       rv = BeginCacheRead();
       break;
     case WRITE:
+      if (partial_.get())
+        partial_->RestoreHeaders(&custom_request_->extra_headers);
       rv = BeginNetworkRequest();
       break;
     case READ_WRITE:
-      rv = BeginCacheValidation();
+      rv = BeginPartialCacheValidation();
       break;
     default:
       NOTREACHED();
       rv = ERR_FAILED;
   }
   return rv;
 }
 
 void HttpCache::Transaction::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   DCHECK(callback_);
 
   // since Run may result in Read being called, clear callback_ up front.
   CompletionCallback* c = callback_;
   callback_ = NULL;
   c->Run(rv);
 }
 
 int HttpCache::Transaction::HandleResult(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
   if (callback_)
     DoCallback(rv);
   return rv;
 }
 
 void HttpCache::Transaction::SetRequest(const HttpRequestInfo* request) {
   request_ = request;
   effective_load_flags_ = request_->load_flags;
 
-  switch(cache_->mode()) {
+  switch (cache_->mode()) {
     case NORMAL:
       break;
     case RECORD:
       // When in record mode, we want to NEVER load from the cache.
       // The reason for this is beacuse we save the Set-Cookie headers
       // (intentionally).  If we read from the cache, we replay them
       // prematurely.
       effective_load_flags_ |= LOAD_BYPASS_CACHE;
     case PLAYBACK:
       // When in playback mode, we want to load exclusively from the cache.
@@ skipping 15 matching lines @@
   //
   static const struct {
     const HeaderNameAndValue* search;
     int load_flag;
   } kSpecialHeaders[] = {
     { kPassThroughHeaders, LOAD_DISABLE_CACHE },
     { kForceFetchHeaders, LOAD_BYPASS_CACHE },
     { kForceValidateHeaders, LOAD_VALIDATE_CACHE },
   };
 
+  std::string new_extra_headers;
+  bool range_found = false;
+
   // scan request headers to see if we have any that would impact our load flags
   HttpUtil::HeadersIterator it(request_->extra_headers.begin(),
                                request_->extra_headers.end(),
                                "\r\n");
   while (it.GetNext()) {
+    if (!LowerCaseEqualsASCII(it.name(), "range")) {
+      new_extra_headers.append(it.name_begin(), it.values_end());
+      new_extra_headers.append("\r\n");
+    } else {
+#ifdef ENABLE_RANGE_SUPPORT
+      range_found = true;
+#else
+      effective_load_flags_ |= LOAD_DISABLE_CACHE;
+      continue;
+#endif
+    }
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kSpecialHeaders); ++i) {
       if (HeaderMatches(it, kSpecialHeaders[i].search)) {
         effective_load_flags_ |= kSpecialHeaders[i].load_flag;
         break;
       }
     }
   }
+
+  if (range_found && !(effective_load_flags_ & LOAD_DISABLE_CACHE)) {
+    partial_.reset(new PartialData);
+    if (partial_->Init(request_->extra_headers, new_extra_headers)) {
+      // We will be modifying the actual range requested to the server, so
+      // let's remove the header here.
+      custom_request_.reset(new HttpRequestInfo(*request_));
+      request_ = custom_request_.get();
+      custom_request_->extra_headers = new_extra_headers;
+    } else {
+      // The range is invalid or we cannot handle it properly.
+      effective_load_flags_ |= LOAD_DISABLE_CACHE;
+    }
+  }
 }
 
 bool HttpCache::Transaction::ShouldPassThrough() {
   // We may have a null disk_cache if there is an error we cannot recover from,
   // like not enough disk space, or sharing violations.
   if (!cache_->disk_cache())
     return true;
 
   // When using the record/playback modes, we always use the cache
   // and we never pass through.
@@ skipping 10 matching lines @@
       request_->upload_data && request_->upload_data->identifier())
     return false;
 
   // TODO(darin): add support for caching HEAD responses
   return true;
 }
 
 int HttpCache::Transaction::BeginCacheRead() {
   DCHECK(mode_ == READ);
 
-  // read response headers
+  // Read response headers.
+  // TODO(rvargas): Handle partial content (206).
   return HandleResult(ReadResponseInfoFromEntry());
 }
 
 int HttpCache::Transaction::BeginCacheValidation() {
   DCHECK(mode_ == READ_WRITE);
 
-  int rv = ReadResponseInfoFromEntry();
-  if (rv != OK) {
-    DCHECK(rv != ERR_IO_PENDING);
-  } else if (effective_load_flags_ & LOAD_PREFERRING_CACHE ||
-             !RequiresValidation()) {
+  if ((effective_load_flags_ & LOAD_PREFERRING_CACHE ||
+       !RequiresValidation()) && !partial_.get()) {
     cache_->ConvertWriterToReader(entry_);
     mode_ = READ;
   } else {
     // Make the network request conditional, to see if we may reuse our cached
     // response.  If we cannot do so, then we just resort to a normal fetch.
     // Our mode remains READ_WRITE for a conditional request.  We'll switch to
     // either READ or WRITE mode once we hear back from the server.
     if (!ConditionalizeRequest())
       mode_ = WRITE;
     return BeginNetworkRequest();
   }
-  return HandleResult(rv);
+  return HandleResult(OK);
+}
+
+int HttpCache::Transaction::BeginPartialCacheValidation() {
+  DCHECK(mode_ == READ_WRITE);
+
+  int rv = ReadResponseInfoFromEntry();
+  if (rv != OK) {
+    DCHECK(rv != ERR_IO_PENDING);
+    return HandleResult(rv);
+  }
+
+  if (response_.headers->response_code() != 206)
+    return BeginCacheValidation();
+
+  if (!partial_.get()) {
+    // The request is not for a range, but we have stored just ranges.
+    // TODO(rvargas): Add support for this case.
+    NOTREACHED();
+  }
+
+  return ContinuePartialCacheValidation();
+}
+
+int HttpCache::Transaction::ContinuePartialCacheValidation() {
+  DCHECK(mode_ == READ_WRITE);
+
+  int rv = partial_->PrepareCacheValidation(entry_->disk_entry,
+                                            &custom_request_->extra_headers);
+
+  if (!rv) {
+    // Don't invoke the callback before telling the cache we're done.
+    return rv;
+  }
+
+  if (rv < 0) {
+    DCHECK(rv != ERR_IO_PENDING);
+    return HandleResult(rv);
+  }
+
+  return BeginCacheValidation();
 }
 
 int HttpCache::Transaction::BeginNetworkRequest() {
   DCHECK(mode_ & WRITE || mode_ == NONE);
   DCHECK(!network_trans_.get());
 
   network_trans_.reset(cache_->network_layer_->CreateTransaction());
   if (!network_trans_.get())
     return net::ERR_CACHE_CANNOT_CREATE_NETWORK_TRANSACTION;
 
@@ skipping 45 matching lines @@
   if (response_.vary_data.is_valid() &&
           !response_.vary_data.MatchesRequest(*request_, *response_.headers))
     return true;
 
   return false;
 }
 
 bool HttpCache::Transaction::ConditionalizeRequest() {
   DCHECK(response_.headers);
 
-  // This only makes sense for cached 200 responses.
-  if (response_.headers->response_code() != 200)
+  // This only makes sense for cached 200 or 206 responses.
+  if (response_.headers->response_code() != 200 &&
+      response_.headers->response_code() != 206)
     return false;
 
   // Just use the first available ETag and/or Last-Modified header value.
   // TODO(darin): Or should we use the last?
 
   std::string etag_value;
   response_.headers->EnumerateHeader(NULL, "etag", &etag_value);
 
   std::string last_modified_value;
   response_.headers->EnumerateHeader(NULL, "last-modified",
                                      &last_modified_value);
 
   if (etag_value.empty() && last_modified_value.empty())
     return false;
 
-  // Need to customize the request, so this forces us to allocate :(
-  custom_request_.reset(new HttpRequestInfo(*request_));
-  request_ = custom_request_.get();
+  if (!partial_.get()) {
+    // Need to customize the request, so this forces us to allocate :(
+    custom_request_.reset(new HttpRequestInfo(*request_));
+    request_ = custom_request_.get();
+  }
+  DCHECK(custom_request_.get());
 
   if (!etag_value.empty()) {
-    custom_request_->extra_headers.append("If-None-Match: ");
+    if (partial_.get() && !partial_->IsCurrentRangeCached()) {
+      // We don't want to switch to WRITE mode if we don't have this block of a
+      // byte-range request because we may have other parts cached.
+      custom_request_->extra_headers.append("If-Range: ");
+    } else {
+      custom_request_->extra_headers.append("If-None-Match: ");
+    }
     custom_request_->extra_headers.append(etag_value);
     custom_request_->extra_headers.append("\r\n");
+    if (partial_.get() && !partial_->IsCurrentRangeCached())
+      return true;
   }
 
   if (!last_modified_value.empty()) {
-    custom_request_->extra_headers.append("If-Modified-Since: ");
+    if (partial_.get() && !partial_->IsCurrentRangeCached()) {
+      custom_request_->extra_headers.append("If-Range: ");
+    } else {
+      custom_request_->extra_headers.append("If-Modified-Since: ");
+    }
     custom_request_->extra_headers.append(last_modified_value);
     custom_request_->extra_headers.append("\r\n");
   }
 
   return true;
 }
 
+int HttpCache::Transaction::ReadFromNetwork(IOBuffer* data, int data_len) {
+  int rv = network_trans_->Read(data, data_len, &network_read_callback_);
+  read_buf_ = data;
+  read_buf_len_ = data_len;
+  if (rv >= 0)
+    rv = DoNetworkReadCompleted(rv);
+  return rv;
+}
+
+int HttpCache::Transaction::ReadFromEntry(IOBuffer* data, int data_len) {
+  DCHECK(entry_);
+  int rv;
+  cache_read_callback_->AddRef();  // Balanced in DoCacheReadCompleted.
+  if (partial_.get()) {
+    rv = partial_->CacheRead(entry_->disk_entry, data, data_len,
+                            cache_read_callback_);
+  } else {
+    rv = entry_->disk_entry->ReadData(kResponseContentIndex, read_offset_,
+                                      data, data_len, cache_read_callback_);
+  }
+  read_buf_ = data;
+  read_buf_len_ = data_len;
+  if (rv >= 0) {
+    rv = DoCacheReadCompleted(rv);
+  } else if (rv != ERR_IO_PENDING) {
+    cache_read_callback_->Release();
+  }
+  return rv;
+}
+
 int HttpCache::Transaction::ReadResponseInfoFromEntry() {
   DCHECK(entry_);
 
   if (!HttpCache::ReadResponseInfo(entry_->disk_entry, &response_))
     return ERR_CACHE_READ_FAILURE;
   return OK;
 }
 
 void HttpCache::Transaction::WriteToEntry(int index, int offset,
                                           IOBuffer* data, int data_len) {
   if (!entry_)
     return;
 
-  int rv = entry_->disk_entry->WriteData(index, offset, data, data_len, NULL,
-                                         true);
+  int rv = 0;
+  if (!partial_.get() || !data_len) {
+    rv = entry_->disk_entry->WriteData(index, offset, data, data_len, NULL,
+                                       true);
+  } else {
+    rv = partial_->CacheWrite(entry_->disk_entry, data, data_len, NULL);
+  }
   if (rv != data_len) {
     DLOG(ERROR) << "failed to write response data to cache";
     DoneWritingToEntry(false);
   }
 }
 
 void HttpCache::Transaction::WriteResponseInfoToEntry() {
   if (!entry_)
     return;
 
@@ skipping 19 matching lines @@
 
   if (!HttpCache::WriteResponseInfo(entry_->disk_entry, &response_,
                                     skip_transient_headers)) {
     DLOG(ERROR) << "failed to write response info to cache";
     DoneWritingToEntry(false);
   }
 }
 
 void HttpCache::Transaction::AppendResponseDataToEntry(IOBuffer* data,
                                                        int data_len) {
-  if (!entry_)
+  if (!entry_ || !data_len)
     return;
 
   int current_size = entry_->disk_entry->GetDataSize(kResponseContentIndex);
   WriteToEntry(kResponseContentIndex, current_size, data, data_len);
 }
 
 void HttpCache::Transaction::TruncateResponseData() {
   if (!entry_)
     return;
 
@@ skipping 21 matching lines @@
     HandleResult(ERR_UNEXPECTED);
     return;
   }
 
   if (result == OK) {
     const HttpResponseInfo* new_response = network_trans_->GetResponseInfo();
     if (new_response->headers->response_code() == 401 ||
         new_response->headers->response_code() == 407) {
       auth_response_ = *new_response;
     } else {
+#ifdef ENABLE_RANGE_SUPPORT
+      bool partial_content = new_response->headers->response_code() == 206;
+#else
+      bool partial_content = false;
+#endif
+      // TODO(rvargas): Validate partial_content vs partial_ and mode_
+      if (partial_content) {
+        DCHECK(partial_.get());
+      }
       // Are we expecting a response to a conditional query?
       if (mode_ == READ_WRITE) {
-        if (new_response->headers->response_code() == 304) {
-          // Update cached response based on headers in new_response
+        if (new_response->headers->response_code() == 304 || partial_content) {
+          // Update cached response based on headers in new_response.
           // TODO(wtc): should we update cached certificate
           // (response_.ssl_info), too?
           response_.headers->Update(*new_response->headers);
           if (response_.headers->HasHeaderValue("cache-control", "no-store")) {
             cache_->DoomEntry(cache_key_);
           } else {
             WriteResponseInfoToEntry();
           }
 
-          if (entry_) {
-            cache_->ConvertWriterToReader(entry_);
+          if (entry_ && !partial_content) {
+            if (!partial_.get() || partial_->IsLastRange())
+              cache_->ConvertWriterToReader(entry_);
             // We no longer need the network transaction, so destroy it.
             final_upload_progress_ = network_trans_->GetUploadProgress();
             network_trans_.reset();
-            mode_ = READ;
+            if (!partial_.get() || partial_->IsLastRange())
+              mode_ = READ;
           }
         } else {
           mode_ = WRITE;
         }
       }
 
       if (!(mode_ & READ)) {
         response_ = *new_response;
         WriteResponseInfoToEntry();
 
-        // Truncate response data
+        // Truncate response data.
         TruncateResponseData();
 
         // If this response is a redirect, then we can stop writing now.  (We
         // don't need to cache the response body of a redirect.)
         if (response_.headers->IsRedirect(NULL))
           DoneWritingToEntry(true);
       }
+      if (reading_) {
+        DCHECK(partial_.get());
+        if (network_trans_.get()) {
+          result = ReadFromNetwork(read_buf_, read_buf_len_);
+        } else {
+          result = ReadFromEntry(read_buf_, read_buf_len_);
+        }
+        if (result >= 0 || result == net::ERR_IO_PENDING)
+          return;
+      }
     }
   } else if (IsCertificateError(result)) {
     const HttpResponseInfo* response = network_trans_->GetResponseInfo();
     // If we get a certificate error, then there is a certificate in ssl_info,
     // so GetResponseInfo() should never returns NULL here.
     DCHECK(response);
     response_.ssl_info = response->ssl_info;
   }
   HandleResult(result);
 }
 
 void HttpCache::Transaction::OnNetworkReadCompleted(int result) {
+  DoNetworkReadCompleted(result);
+}
+
+int HttpCache::Transaction::DoNetworkReadCompleted(int result) {
   DCHECK(mode_ & WRITE || mode_ == NONE);
 
-  if (revoked()) {
-    HandleResult(ERR_UNEXPECTED);
-    return;
-  }
+  if (revoked())
+    return HandleResult(ERR_UNEXPECTED);
 
-  if (result > 0) {
-    AppendResponseDataToEntry(read_buf_, result);
-  } else if (result == 0) {  // end of file
+  AppendResponseDataToEntry(read_buf_, result);
+
+  if (partial_.get())
+    return DoPartialNetworkReadCompleted(result);
+
+  if (result == 0)  // End of file.
+    DoneWritingToEntry(true);
+
+  return HandleResult(result);
+}
+
+int HttpCache::Transaction::DoPartialNetworkReadCompleted(int result) {
+  partial_->OnNetworkReadCompleted(result);
+
+  if (result == 0) {  // End of file.
+    if (mode_ == READ_WRITE) {
+      // We need to move on to the next range.
+      network_trans_.reset();
+      result = ContinuePartialCacheValidation();
+      if (result != OK)
+        // Any error was already handled.
+        return result;
+    }
     DoneWritingToEntry(true);
   }
-  HandleResult(result);
+  return HandleResult(result);
 }
 
 void HttpCache::Transaction::OnCacheReadCompleted(int result) {
+  DoCacheReadCompleted(result);
+}
+
+int HttpCache::Transaction::DoCacheReadCompleted(int result) {
   DCHECK(cache_);
   cache_read_callback_->Release();  // Balance the AddRef() from Start().
 
-  if (revoked()) {
-    HandleResult(ERR_UNEXPECTED);
-    return;
-  }
+  if (revoked())
+    return HandleResult(ERR_UNEXPECTED);
+
+  if (partial_.get())
+    return DoPartialCacheReadCompleted(result);
 
   if (result > 0) {
     read_offset_ += result;
-  } else if (result == 0) {  // end of file
+  } else if (result == 0) {  // End of file.
     cache_->DoneReadingFromEntry(entry_, this);
     entry_ = NULL;
   }
-  HandleResult(result);
+  return HandleResult(result);
+}
+
+int HttpCache::Transaction::DoPartialCacheReadCompleted(int result) {
+  partial_->OnCacheReadCompleted(result);
+
+  if (result == 0) {  // End of file.
+    if (partial_.get() && mode_ == READ_WRITE) {
+      // We need to move on to the next range.
+      result = ContinuePartialCacheValidation();
+      if (result != OK)
+        // Any error was already handled.
+        return result;
+      cache_->ConvertWriterToReader(entry_);
+    }
+    cache_->DoneReadingFromEntry(entry_, this);
+    entry_ = NULL;
+  }
+  return HandleResult(result);
 }
 
 //-----------------------------------------------------------------------------
 
 HttpCache::HttpCache(ProxyService* proxy_service,
                      const std::wstring& cache_dir,
                      int cache_size)
     : disk_cache_dir_(cache_dir),
       mode_(NORMAL),
       type_(DISK_CACHE),
@@ skipping 168 matching lines @@
   pickle.WriteInt64(response_info->response_time.ToInternalValue());
 
   net::HttpResponseHeaders::PersistOptions persist_options =
       net::HttpResponseHeaders::PERSIST_RAW;
 
   if (skip_transient_headers) {
     persist_options =
         net::HttpResponseHeaders::PERSIST_SANS_COOKIES |
         net::HttpResponseHeaders::PERSIST_SANS_CHALLENGES |
         net::HttpResponseHeaders::PERSIST_SANS_HOP_BY_HOP |
-        net::HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE;
+        net::HttpResponseHeaders::PERSIST_SANS_NON_CACHEABLE |
+        net::HttpResponseHeaders::PERSIST_SANS_RANGES;
   }
 
   response_info->headers->Persist(&pickle, persist_options);
 
   if (response_info->ssl_info.cert) {
     response_info->ssl_info.cert->Persist(&pickle);
     pickle.WriteInt(response_info->ssl_info.cert_status);
   }
   if (response_info->ssl_info.security_bits != -1)
     pickle.WriteInt(response_info->ssl_info.security_bits);
@@ skipping 317 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->connection_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net