Http Cache: Make sure that we don't fail transactions when the...

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 "base/compiler_specific.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 91 matching lines @@
       mode_(NONE),
       target_state_(STATE_NONE),
       reading_(false),
       invalid_range_(false),
       enable_range_support_(enable_range_support),
       truncated_(false),
       server_responded_206_(false),
       cache_pending_(false),
       read_offset_(0),
       effective_load_flags_(0),
+      write_len_(0),
       final_upload_progress_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &Transaction::OnIOComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           cache_callback_(new CancelableCompletionCallback<Transaction>(
               this, &Transaction::OnIOComplete))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           write_headers_callback_(new CancelableCompletionCallback<Transaction>(
               this, &Transaction::OnIOComplete))) {
   COMPILE_ASSERT(HttpCache::Transaction::kNumValidationHeaders ==
@@ skipping 1045 matching lines @@
     read_offset_ += result;
   } else if (result == 0) {  // End of file.
     cache_->DoneReadingFromEntry(entry_, this);
     entry_ = NULL;
   }
   return result;
 }
 
 int HttpCache::Transaction::DoCacheWriteData(int num_bytes) {
   next_state_ = STATE_CACHE_WRITE_DATA_COMPLETE;
+  write_len_ = num_bytes;
   cache_callback_->AddRef();  // Balanced in DoCacheWriteDataComplete.
 
   return AppendResponseDataToEntry(read_buf_, num_bytes, cache_callback_);
 }
 
 int HttpCache::Transaction::DoCacheWriteDataComplete(int result) {
   // Balance the AddRef from DoCacheWriteData.
   cache_callback_->Release();
   if (!cache_)
     return ERR_UNEXPECTED;
 
-  if (result < 0)
-    return result;
+  if (result != write_len_) {
+    DLOG(ERROR) << "failed to write response data to cache";
+    DoneWritingToEntry(false);
+
+    // We want to ignore errors writing to disk and just keep reading from
+    // the network.
+    result = write_len_;
+  }
 
   if (partial_.get()) {
     // This may be the last request.
     if (!(result == 0 && !truncated_ &&
           (partial_->IsLastRange() || mode_ == WRITE)))
       return DoPartialNetworkReadCompleted(result);
   }
 
   if (result == 0)  // End of file.
     DoneWritingToEntry(true);
@@ skipping 518 matching lines @@
   if (!entry_)
     return data_len;
 
   int rv = 0;
   if (!partial_.get() || !data_len) {
     rv = entry_->disk_entry->WriteData(index, offset, data, data_len, callback,
                                        true);
   } else {
     rv = partial_->CacheWrite(entry_->disk_entry, data, data_len, callback);
   }
-
-  if (rv != ERR_IO_PENDING && rv != data_len) {
-    DLOG(ERROR) << "failed to write response data to cache";
-    DoneWritingToEntry(false);
-
-    // We want to ignore errors writing to disk and just keep reading from
-    // the network.
-    rv = data_len;
-  }
   return rv;
 }
 
 int HttpCache::Transaction::WriteResponseInfoToEntry(bool truncated) {
   next_state_ = STATE_CACHE_WRITE_RESPONSE_COMPLETE;
   if (!entry_)
     return OK;
 
   // Do not cache no-store content (unless we are record mode).  Do not cache
   // content with cert errors either.  This is to prevent not reporting net
@@ skipping 123 matching lines @@
   // |value| goes from 0 to 63. Actually, the max value should be 47 (0x2f)
   // but we'll see.
   UMA_HISTOGRAM_ENUMERATION("HttpCache.ResponseHeaders", value, 65);
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net