Http cache: Extend support for byte range requests....

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 "base/compiler_specific.h"
 
@@ skipping 291 matching lines @@
   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();
 
+  // Makes sure that a 206 response is expected.  Returns a network error code.
+  bool ValidatePartialResponse(const HttpResponseHeaders* headers);
+
   // 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);
 
+  // Deletes the current partial cache entry (sparse), and optionally removes
+  // the control object (partial_).
+  void DoomPartialEntry(bool delete_object);
+
   // 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);
 
@@ skipping 443 matching lines @@
     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;
+      partial_.reset(NULL);
     }
   }
 
   // If there is more than one validation header, we can't treat this request as
   // a cache validation, since we don't know for sure which header the server
   // will give us a response for (and they could be contradictory).
   if (num_validation_headers > 1) {
     LOG(WARNING) << "Multiple validation headers found.";
     effective_load_flags_ |= LOAD_DISABLE_CACHE;
   }
@@ skipping 65 matching lines @@
     return HandleResult(rv);
   }
 
   if (response_.headers->response_code() != 206)
     return BeginCacheValidation();
 
 #if !defined(ENABLE_RANGE_SUPPORT)
   return BeginCacheValidation();
 #endif
 
-  if (!partial_.get()) {
+  bool byte_range_requested = partial_.get() != NULL;
+  if (!byte_range_requested) {
     // The request is not for a range, but we have stored just ranges.
-    // TODO(rvargas): Add support for this case.
-    NOTREACHED();
+    partial_.reset(new PartialData());
+    if (!custom_request_.get()) {
+      custom_request_.reset(new HttpRequestInfo(*request_));
+      request_ = custom_request_.get();
+      DCHECK(custom_request_->extra_headers.empty());
+    }
   }
 
-  if (!partial_->UpdateFromStoredHeaders(response_.headers)) {
-    // TODO(rvargas): Handle this error.
-    NOTREACHED();
+  if (!partial_->UpdateFromStoredHeaders(response_.headers,
+                                         entry_->disk_entry)) {
+    // The stored data cannot be used. Get rid of it and restart this request.
+    DoomPartialEntry(!byte_range_requested);
+    mode_ = WRITE;
+    return AddToEntry();
   }
 
   return ContinuePartialCacheValidation();
 }
 
 int HttpCache::Transaction::ContinuePartialCacheValidation() {
   DCHECK(mode_ == READ_WRITE);
-  // TODO(rvargas): Avoid re-validation of each cached piece.
-
   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);
   }
 
+  if (reading_ && partial_->IsCurrentRangeCached()) {
+    rv = ReadFromEntry(read_buf_, read_buf_len_);
+
+    // We are supposed to hanlde errors here.
+    if (rv < 0 && rv != ERR_IO_PENDING)
+      HandleResult(rv);
+    return rv;
+  }
+
   return BeginCacheValidation();
 }
 
 int HttpCache::Transaction::BeginExternallyConditionalizedRequest() {
   DCHECK_EQ(UPDATE, mode_);
   DCHECK(external_validation_.initialized());
 
   // Read the cached response.
   int rv = ReadResponseInfoFromEntry();
   if (rv != OK) {
@@ skipping 146 matching lines @@
     } 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;
 }
 
+bool HttpCache::Transaction::ValidatePartialResponse(
+    const HttpResponseHeaders* headers) {
+#ifdef ENABLE_RANGE_SUPPORT
+  bool partial_content = headers->response_code() == 206;
+#else
+  bool partial_content = false;
+#endif
+
+  bool failure = false;
+  if (!partial_content) {
+    if (!partial_.get())
+      return false;
+
+    // TODO(rvargas): Do we need to consider other results here?.
+    if (headers->response_code() == 200 || headers->response_code() == 416)
+      failure = true;
+
+    if (!reading_ && failure) {
+      // We are expecting 206 or 304 because we asked for a range. Given that
+      // the server is refusing the request we'll remove the sparse entry.
+      DoomPartialEntry(true);
+      mode_ = NONE;
+      return false;
+    }
+  }
+
+  if (!failure && partial_.get() && partial_->ResponseHeadersOK(headers))
+    return true;
+
+  // We have a problem. We may or may not be reading already (in which case we
+  // returned the headers), but we'll just pretend that this request is not
+  // using the cache and see what happens. Most likely this is the first
+  // response from the server (it's not changing its mind midway, right?).
+  if (mode_ & WRITE) {
+    DoneWritingToEntry(mode_ != WRITE);
+  } else if (mode_ & READ && entry_) {
+    cache_->DoneReadingFromEntry(entry_, this);
+  }
+
+  entry_ = NULL;
+  mode_ = NONE;
+  return false;
+}
+
 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) {
@@ skipping 97 matching lines @@
 
   if (cache_->mode() == RECORD)
     DLOG(INFO) << "Recorded: " << request_->method << request_->url
                << " status: " << response_.headers->response_code();
 
   cache_->DoneWritingToEntry(entry_, success);
   entry_ = NULL;
   mode_ = NONE;  // switch to 'pass through' mode
 }
 
+void HttpCache::Transaction::DoomPartialEntry(bool delete_object) {
+  cache_->DoneWithEntry(entry_, this);
+  cache_->DoomEntry(cache_key_);
+  entry_ = NULL;
+  if (delete_object)
+    partial_.reset(NULL);
+}
+
 void HttpCache::Transaction::OnNetworkInfoAvailable(int result) {
   DCHECK(result != ERR_IO_PENDING);
 
   if (revoked()) {
     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());
-        if (!partial_->ResponseHeadersOK(new_response->headers)) {
-          // TODO(rvargas): Handle this error.
-          NOTREACHED();
-        }
-      }
+      bool partial_content = ValidatePartialResponse(new_response->headers);
+
       // Are we expecting a response to a conditional query?
       if (mode_ == READ_WRITE || mode_ == UPDATE) {
         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 {
@@ skipping 724 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->connection_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net