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

net/http/http_cache.h

 // 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.
 
 // This file declares a HttpTransactionFactory implementation that can be
 // layered on top of another HttpTransactionFactory to add HTTP caching.  The
 // caching logic follows RFC 7234 (any exceptions are called out in the code).
 //
 // The HttpCache takes a disk_cache::Backend as a parameter, and uses that for
 // the cache storage.
@@ skipping 222 matching lines @@
   // Disk cache entry data indices.
   enum {
     kResponseInfoIndex = 0,
     kResponseContentIndex,
     kMetadataIndex,
 
     // Must remain at the end of the enum.
     kNumCacheEntryDataIndices
   };
 
+  // Used with DoneWithEntry() to indicate the state of the entry.
+  enum class EntryState { KEEP, DOOM };
+
   class MetadataWriter;
   class QuicServerInfoFactoryAdaptor;
   class Transaction;
   class WorkItem;
   friend class Transaction;
   friend class ViewCacheHelper;
   struct PendingOp;  // Info for an entry under construction.
 
   typedef std::list<Transaction*> TransactionList;
   typedef std::list<WorkItem*> WorkItemList;
@@ skipping 87 matching lines @@
   // Destroys an ActiveEntry (active or doomed).
   void DestroyEntry(ActiveEntry* entry);
 
   // Adds a transaction to an ActiveEntry. If this method returns ERR_IO_PENDING
   // the transaction will be notified about completion via its IO callback. This
   // method returns ERR_CACHE_RACE to signal the transaction that it cannot be
   // added to the provided entry, and it should retry the process with another
   // one (in this case, the entry is no longer valid).
   int AddTransactionToEntry(ActiveEntry* entry, Transaction* trans);
 
-  // Called when the transaction has finished working with this entry. |cancel|
-  // is true if the operation was cancelled by the caller instead of running
-  // to completion.
-  void DoneWithEntry(ActiveEntry* entry, Transaction* trans, bool cancel);
-
-  // Called when the transaction has finished writing to this entry. |success|
-  // is false if the cache entry should be deleted.
-  void DoneWritingToEntry(ActiveEntry* entry, bool success);
-
-  // Called when the transaction has finished reading from this entry.
-  void DoneReadingFromEntry(ActiveEntry* entry, Transaction* trans);
+  // Removes |trans| from |entry|. |trans| is required to be a reader or writer
+  // that was added to |trans| by AddTransactionToEntry(). For writers,
+  // |entry_state| indicates whether the cache entry should be kept or
+  // discarded.
+  //
+  // If |entry_state| is DOOM, then the cache entry is destroyed and any
+  // pending transactions that were formerly waiting to be added to |entry| will
+  // receive ERR_CACHE_RACE.
+  //
+  // If |entry_state| is KEEP, then |entry| is assumed to be safe for
+  // further consumption and pending transaction will be permitted to use it.
+  void DoneWithEntry(ActiveEntry* entry,
+                     Transaction* trans,
+                     EntryState entry_state);
 
   // Converts the active writer transaction to a reader so that other
   // transactions can start reading from this entry.
   void ConvertWriterToReader(ActiveEntry* entry);
 
   // Returns the LoadState of the provided pending transaction.
   LoadState GetLoadStateForPendingTransaction(const Transaction* trans);
 
   // Removes the transaction |trans|, from the pending list of an entry
   // (PendingOp, active or doomed entry).
@@ skipping 70 matching lines @@
   scoped_ptr<base::Clock> clock_;
 
   base::WeakPtrFactory<HttpCache> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpCache);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_CACHE_H_