Http cache: Don't delete sparse entries when we...

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 235 matching lines @@
   const std::string& key() const { return cache_key_; }
 
   // Associates this transaction with a cache entry.
   int AddToEntry();
 
   // Called by the HttpCache when the given disk cache entry becomes accessible
   // to the transaction.  Returns network error code.
   int EntryAvailable(ActiveEntry* entry);
 
   // This transaction is being deleted and we are not done writing to the cache.
-  // We need to indicate that the response data was truncated.
-  void AddTruncatedFlag();
+  // We need to indicate that the response data was truncated.  Returns true on
+  // success.
+  bool AddTruncatedFlag();
 
  private:
   // This is a helper function used to trigger a completion callback.  It may
   // only be called if callback_ is non-null.
   void DoCallback(int rv);
 
   // This will trigger the completion callback if appropriate.
   int HandleResult(int rv);
 
   // Sets request_ and fields derived from it.
@@ skipping 133 matching lines @@
   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_) {
-      bool cancel_request = reading_ && !partial_.get() &&
-                            enable_range_support_ &&
-                            response_.headers->response_code() == 200;
+      bool cancel_request = reading_ && enable_range_support_;
+      if (cancel_request && !partial_.get())
+        cancel_request &= (response_.headers->response_code() == 200);
 
       cache_->DoneWithEntry(entry_, this, cancel_request);
     } else {
       cache_->RemovePendingTransaction(this);
     }
   }
 
   // If there is an outstanding callback, mark it as cancelled so running it
   // does nothing.
   cache_read_callback_->Cancel();
@@ skipping 288 matching lines @@
     case UPDATE:
       rv = BeginExternallyConditionalizedRequest();
       break;
     default:
       NOTREACHED();
       rv = ERR_FAILED;
   }
   return rv;
 }
 
-void HttpCache::Transaction::AddTruncatedFlag() {
+bool HttpCache::Transaction::AddTruncatedFlag() {
   DCHECK(mode_ & WRITE);
+
+  // Don't set the flag for sparse entries.
+  if (partial_.get())
+    return true;
+
+  // Double check that there is something worth keeping.
+  if (!entry_->disk_entry->GetDataSize(kResponseContentIndex))
+    return false;
+
   truncated_ = true;
   WriteResponseInfoToEntry(true);
+  return true;
 }
 
 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);
@@ skipping 1260 matching lines @@
 
   if (entry->writer) {
     DCHECK(trans == entry->writer);
 
     // Assume there was a failure.
     bool success = false;
     if (cancel) {
       DCHECK(entry->disk_entry);
       // This is a successful operation in the sense that we want to keep the
       // entry.
-      success = true;
-      // Double check that there is something worth keeping.
-      if (!entry->disk_entry->GetDataSize(kResponseContentIndex))
-        success = false;
-      trans->AddTruncatedFlag();
+      success = trans->AddTruncatedFlag();
     }
     DoneWritingToEntry(entry, success);
   } else {
     DoneReadingFromEntry(entry, trans);
   }
 }
 
 void HttpCache::DoneWritingToEntry(ActiveEntry* entry, bool success) {
   DCHECK(entry->readers.empty());
 
@@ skipping 99 matching lines @@
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
     session->tcp_socket_pool()->CloseIdleSockets();
   }
 }
 
 //-----------------------------------------------------------------------------
 
 }  // namespace net