Adds a new class HttpCache::Writers for multiple cache transactions reading from the network.

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 228 matching lines @@
     kMetadataIndex,
 
     // Must remain at the end of the enum.
     kNumCacheEntryDataIndices
   };
 
   class MetadataWriter;
   class QuicServerInfoFactoryAdaptor;
   class Transaction;
   class WorkItem;
+  class Writers;
+  friend class WritersTest;  // To access ActiveEntry in the test class.
+  friend class MockHttpCacheTransaction;
   friend class Transaction;
   friend class ViewCacheHelper;
   struct PendingOp;  // Info for an entry under construction.
 
   // To help with testing.
   friend class MockHttpCache;
 
   using TransactionList = std::list<Transaction*>;
   using TransactionSet = std::unordered_set<Transaction*>;
   typedef std::list<std::unique_ptr<WorkItem>> WorkItemList;
@@ skipping 158 matching lines @@
 
   // 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,
                           Transaction* transaction);
 
   // Called when the transaction has finished reading from this entry.
   void DoneReadingFromEntry(ActiveEntry* entry, Transaction* transaction);
 
+  // Called when the transaction has received a non-matching response to
+  // validation and it's not the transaction responsible for writing the
+  // response body.
+  void DoomEntryValidationNoMatch(ActiveEntry* entry);
+
   // Removes and returns all queued transactions in |entry| in FIFO order. This
   // includes transactions that have completed the headers phase and those that
   // have not been added to the entry yet in that order. |list| is the output
   // argument.
   void RemoveAllQueuedTransactions(ActiveEntry* entry, TransactionList* list);
 
   // Processes either writer's failure to write response body or
-  // headers_transactions's failure to write headers. Also invoked when headers
-  // transaction's validation result is not a match.
+  // headers_transactions's failure to write headers.
   void ProcessEntryFailure(ActiveEntry* entry, Transaction* transaction);
 
   // Restarts headers_transaction and done_headers_queue transactions.
   void RestartHeadersPhaseTransactions(ActiveEntry* entry,
                                        Transaction* transaction);
 
   // Restarts the headers_transaction by setting its state. Since the
   // headers_transaction is awaiting an asynchronous operation completion,
   // it will be restarted when it's IO callback is invoked.
   void RestartHeadersTransaction(ActiveEntry* entry);
@@ skipping 100 matching lines @@
   THREAD_CHECKER(thread_checker_);
 
   base::WeakPtrFactory<HttpCache> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpCache);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_CACHE_H_