Http cache: Fix handling of truncated entries....

net/http/http_cache_transaction.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 "net/http/http_cache_transaction.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 713 matching lines @@
   next_state_ = STATE_NETWORK_READ_COMPLETE;
   return network_trans_->Read(read_buf_, io_buf_len_, &io_callback_);
 }
 
 int HttpCache::Transaction::DoNetworkReadComplete(int result) {
   DCHECK(mode_ & WRITE || mode_ == NONE);
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
+  // If there is an error and we are saving the data, just tell the user about
+  // it and wait until the destructor runs to see if we can keep the data.
+  if (mode_ != NONE && result < 0)
+    return result;
+
   next_state_ = STATE_CACHE_WRITE_DATA;
   return result;
 }
 
 int HttpCache::Transaction::DoInitEntry() {
   DCHECK(!new_entry_);
 
   if (!cache_)
     return ERR_UNEXPECTED;
 
@@ skipping 231 matching lines @@
     DoneWritingToEntry(true);
   } else if (entry_ && !server_responded_206_) {
     DCHECK_EQ(READ_WRITE, mode_);
     if (!partial_.get() || partial_->IsLastRange()) {
       cache_->ConvertWriterToReader(entry_);
       mode_ = READ;
     }
     // We no longer need the network transaction, so destroy it.
     final_upload_progress_ = network_trans_->GetUploadProgress();
     network_trans_.reset();
+  } else if (entry_ && server_responded_206_ && truncated_ &&
+             partial_->initial_validation()) {
+    // We just finishing the validation of a truncated entry, and the server

[eroman, 2011/03/02 02:06:04]

wording nit: "finishing" --> "finished".

+    // is willing to resume the operation. Now we go back and start serving
+    // the first part to the user.
+    network_trans_.reset();
+    new_response_ = NULL;
+    next_state_ = STATE_START_PARTIAL_CACHE_VALIDATION;
+    partial_->SetRangeToStartDownload();
+    return OK;
   }
   next_state_ = STATE_OVERWRITE_CACHED_RESPONSE;
   return OK;
 }
 
 int HttpCache::Transaction::DoOverwriteCachedResponse() {
   if (mode_ & READ) {
     next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
     return OK;
   }
@@ skipping 440 matching lines @@
 
   return OK;
 }
 
 int HttpCache::Transaction::BeginCacheValidation() {
   DCHECK(mode_ == READ_WRITE);
 
   bool skip_validation = effective_load_flags_ & LOAD_PREFERRING_CACHE ||
                          !RequiresValidation();
 
+  if (truncated_)
+    skip_validation = !partial_->initial_validation();
+
   if ((partial_.get() && !partial_->IsCurrentRangeCached()) || invalid_range_)
     skip_validation = false;
 
   if (skip_validation) {
     if (partial_.get()) {
       // We are going to return the saved response headers to the caller, so
       // we may need to adjust them first.
       next_state_ = STATE_PARTIAL_HEADERS_RECEIVED;
       return OK;
     }
@@ skipping 276 matching lines @@
       return true;
   } else {
     // We asked for "If-Range: " so a 206 means just another range.
     if (partial_response && partial_->ResponseHeadersOK(headers)) {
       *partial_content = true;
       return true;
     }
 
     // 304 is not expected here, but we'll spare the entry (unless it was
     // truncated).
-    if (truncated_)
+    if (truncated_) {
+      if (!reading_ && response_code == 200) {
+        // The server is sending the whole resource, and we can save it.
+        DCHECK(!partial_->IsLastRange());
+        partial_.reset();
+        truncated_ = false;
+        return true;
+      }
       failure = true;
+    }
   }
 
   if (failure) {
     // We cannot truncate this entry, it has to be deleted.
     DoomPartialEntry(false);
     mode_ = NONE;
     if (!reading_ && !partial_->IsLastRange()) {
       // We'll attempt to issue another network request, this time without us
       // messing up the headers.
       partial_->RestoreHeaders(&custom_request_->extra_headers);
@@ skipping 155 matching lines @@
     next_state_ = STATE_START_PARTIAL_CACHE_VALIDATION;
   }
   return result;
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net