Http Cache: Make sure that we don't switch to mode NONE when

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 352 matching lines @@
 
 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))
+  if (cache_ && entry_ && (mode_ & WRITE) && network_trans_.get() &&
+      !is_sparse_ && !range_requested_)

[gavinp, 2011/11/22 18:24:39]

So this is OK because downloads are never range_requested?

What happens if we get a resource cached sparsely for some use, then do a
download: will we still tickle bug 22900?

[rvargas (doing something else), 2011/11/22 18:35:03]

Yes we will. 22900 is an optimization, so in this case we just don't optimize it
and default to double-saving.

On the other hand, this is not the only measure to avoid caching a download (not
even the main one, from my point of view). Any user-initiated download should
have the right LoadFlag from the beginning.

Note that a more common case is when we are resuming an interrupted fetch
(truncated flag). If we are reading from the cache (and that should be the
common case), then there's no network transaction yet, so we don't do anything.
That's in fact the crash I looked at.

On 2011/11/22 18:24:39, gavinp wrote:

     mode_ = NONE;
 }
 
 void HttpCache::Transaction::DoneReading() {
   if (cache_ && entry_) {
     DCHECK(reading_);
     DCHECK_NE(mode_, UPDATE);
     if (mode_ & WRITE)
       DoneWritingToEntry(true);
   }
@@ skipping 1684 matching lines @@
     return false;
 
   return true;
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   DoLoop(result);
 }
 
 }  // namespace net