HTTP Cache: Implement StopCaching(), to avoid caching

net/http/http_cache_transaction.cc

 // Copyright (c) 2011 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 165 matching lines @@
 
   // We don't need to track this operation for anything.
   // It could be possible to check if there is something already written and
   // avoid writing again (it should be the same, right?), but let's allow the
   // caller to "update" the contents with something new.
   return entry_->disk_entry->WriteData(kMetadataIndex, 0, buf, buf_len,
                                        callback, true);
 }
 
 bool HttpCache::Transaction::AddTruncatedFlag() {
-  DCHECK(mode_ & WRITE);
+  DCHECK(mode_ & WRITE || mode_ == NONE);
 
   // Don't set the flag for sparse entries.
   if (partial_.get() && !truncated_)
     return true;
 
   if (!CanResume(true))
     return false;
 
   // We may have received the whole resource already.
   if (done_reading_)
@@ skipping 158 matching lines @@
   }
 
   if (rv == ERR_IO_PENDING) {
     DCHECK(!callback_);
     callback_ = callback;
   }
   return rv;
 }
 
 void HttpCache::Transaction::StopCaching() {
+  // We really don't know where we are now. Hopefully there is no operation in
+  // progress, but nothing really prevents this method to be called after we
+  // returned ERR_IO_PENDING. We cannot attempt to truncate the entry at this
+  // point because we need the state machine for that (and even if we are really
+  // free, that would be an asynchronous operation). In other words, keep the
+  // entry how it is (it will be marked as truncated at destruction), and let
+  // the next piece of code that executes know that we are now reading directly
+  // from the net.
+  if (cache_ && entry_ && (mode_ & WRITE))
+    mode_ = NONE;
 }
 
 void HttpCache::Transaction::DoneReading() {
   if (cache_ && entry_) {
     DCHECK(reading_);
     DCHECK_NE(mode_, UPDATE);
     if (mode_ & WRITE)
       DoneWritingToEntry(true);
   }
 }
@@ skipping 412 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)
+  // If there is an error or we aren't saving the data, we are done; just 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_)
@@ skipping 1248 matching lines @@
     return false;
 
   return true;
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net