[net] Better StopCaching() handling for HttpCache::Transaction.

net/http/http_cache.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 821 matching lines @@
 
   // We do this before calling EntryAvailable to force any further calls to
   // AddTransactionToEntry to add their transaction to the pending queue, which
   // ensures FIFO ordering.
   if (!entry->writer && !entry->pending_queue.empty())
     ProcessPendingQueue(entry);
 
   return OK;
 }
 
-void HttpCache::DoneWithEntry(ActiveEntry* entry, Transaction* trans,
-                              bool cancel) {
+void HttpCache::DoneWithEntry(ActiveEntry* entry,
+                              Transaction* trans,
+                              EntryState entry_state) {
   // If we already posted a task to move on to the next transaction and this was
   // the writer, there is nothing to cancel.
   if (entry->will_process_pending_queue && entry->readers.empty())
     return;
 
   if (entry->writer) {
-    DCHECK(trans == entry->writer);
+    DCHECK_EQ(trans, entry->writer);
+    DCHECK(entry->readers.empty());
 
-    // 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 = trans->AddTruncatedFlag();
-      // The previous operation may have deleted the entry.
-      if (!trans->entry())
-        return;
+    entry->writer = nullptr;
+
+    if (entry_state == EntryState::DOOM || entry->doomed) {
+      DCHECK(!entry->will_process_pending_queue);
+
+      TransactionList pending_queue;
+      pending_queue.swap(entry->pending_queue);
+      if (!entry->doomed)
+        entry->disk_entry->Doom();
+      DestroyEntry(entry);
+
+      // We need to do something about these pending entries, which now need to
+      // be added to a new entry.
+      while (!pending_queue.empty()) {
+        // ERR_CACHE_RACE causes the transaction to restart the whole process.
+        pending_queue.front()->io_callback().Run(ERR_CACHE_RACE);
+        pending_queue.pop_front();
+      }
+      return;
     }
-    DoneWritingToEntry(entry, success);
   } else {
-    DoneReadingFromEntry(entry, trans);
+    auto it = std::find(entry->readers.begin(), entry->readers.end(), trans);
+    DCHECK(it != entry->readers.end());
+    entry->readers.erase(it);
   }
-}
-
-void HttpCache::DoneWritingToEntry(ActiveEntry* entry, bool success) {
-  DCHECK(entry->readers.empty());
-
-  entry->writer = NULL;
-
-  if (success) {
-    ProcessPendingQueue(entry);
-  } else {
-    DCHECK(!entry->will_process_pending_queue);
-
-    // We failed to create this entry.
-    TransactionList pending_queue;
-    pending_queue.swap(entry->pending_queue);
-
-    entry->disk_entry->Doom();
-    DestroyEntry(entry);
-
-    // We need to do something about these pending entries, which now need to
-    // be added to a new entry.
-    while (!pending_queue.empty()) {
-      // ERR_CACHE_RACE causes the transaction to restart the whole process.
-      pending_queue.front()->io_callback().Run(ERR_CACHE_RACE);
-      pending_queue.pop_front();
-    }
-  }
-}
-
-void HttpCache::DoneReadingFromEntry(ActiveEntry* entry, Transaction* trans) {
-  DCHECK(!entry->writer);
-
-  TransactionList::iterator it =
-      std::find(entry->readers.begin(), entry->readers.end(), trans);
-  DCHECK(it != entry->readers.end());
-
-  entry->readers.erase(it);
-
   ProcessPendingQueue(entry);
 }
 
 void HttpCache::ConvertWriterToReader(ActiveEntry* entry) {
   DCHECK(entry->writer);
   DCHECK(entry->writer->mode() == Transaction::READ_WRITE);
   DCHECK(entry->readers.empty());
 
   Transaction* trans = entry->writer;
 
@@ skipping 266 matching lines @@
     building_backend_ = false;
     DeletePendingOp(pending_op);
   }
 
   // The cache may be gone when we return from the callback.
   if (!item->DoCallback(result, disk_cache_.get()))
     item->NotifyTransaction(result, NULL);
 }
 
 }  // namespace net