Http cache: Make sure that we handle byte range requests that...

net/http/http_cache.cc

 // Copyright (c) 2006-2009 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 <string>
 
 #include "base/compiler_specific.h"
@@ skipping 444 matching lines @@
         mode_ = NONE;
       }
     }
   }
 
   // if must use cache, then we must fail.  this can happen for back/forward
   // navigations to a page generated via a form post.
   if (!(mode_ & READ) && effective_load_flags_ & LOAD_ONLY_FROM_CACHE)
     return ERR_CACHE_MISS;
 
-  if (mode_ == NONE)
+  if (mode_ == NONE) {
+    if (partial_.get())
+      partial_->RestoreHeaders(&custom_request_->extra_headers);
     rv = BeginNetworkRequest();
-  else
+  } else {
     rv = AddToEntry();
+  }
 
   // setting this here allows us to check for the existance of a callback_ to
   // determine if we are still inside Start.
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
 int HttpCache::Transaction::RestartIgnoringLastError(
@@ skipping 148 matching lines @@
     entry = cache_->FindActiveEntry(cache_key_);
     if (!entry) {
       LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_OPEN_ENTRY);
       entry = cache_->OpenEntry(cache_key_);
       LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_OPEN_ENTRY);
       if (!entry) {
         if (mode_ == READ_WRITE) {
           mode_ = WRITE;
         } else if (mode_ == UPDATE) {
           // There is no cache entry to update; proceed without caching.
           mode_ = NONE;

[eroman, 2009/11/03 04:51:28]

I expect you need to restore headers here too.

[rvargas (doing something else), 2009/11/03 18:28:26]

This block requires mode_ to be UPDATE so we don't have a byte range request (we
avoid that in SetRequest). I can add a dcheck if you want me to.

           return BeginNetworkRequest();
         } else {
           if (cache_->mode() == PLAYBACK)
             DLOG(INFO) << "Playback Cache Miss: " << request_->url;
 
           // entry does not exist, and not permitted to create a new entry, so
           // we must fail.
           return HandleResult(ERR_CACHE_MISS);
         }
       }
     }
   }
 
   if (mode_ == WRITE) {
     DCHECK(!entry);
     LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_CREATE_ENTRY);
     entry = cache_->CreateEntry(cache_key_);
     LoadLog::EndEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_CREATE_ENTRY);
     if (!entry) {
       DLOG(WARNING) << "unable to create cache entry";
       mode_ = NONE;
+      if (partial_.get())
+        partial_->RestoreHeaders(&custom_request_->extra_headers);
       return BeginNetworkRequest();
     }
   }
 
 
   LoadLog::BeginEvent(load_log_, LoadLog::TYPE_HTTP_CACHE_WAITING);
   return cache_->AddTransactionToEntry(entry, this);
 }
 
 int HttpCache::Transaction::EntryAvailable(ActiveEntry* entry) {
@@ skipping 910 matching lines @@
           DoneWritingToEntry(true);
       }
       if (reading_ && 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 (partial_.get()) {
+      } else if (mode_ != NONE && partial_.get()) {
         // We are about to return the headers for a byte-range request to the
         // user, so let's fix them.
         partial_->FixResponseHeaders(response_.headers);
       }
     }
   } 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);
@@ skipping 499 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->tcp_socket_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net