Fixes the cache lock issue.

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.
 //
 // See HttpTransactionFactory and HttpTransaction for more details.
 
 #ifndef NET_HTTP_HTTP_CACHE_H_
 #define NET_HTTP_HTTP_CACHE_H_
 
 #include <list>
 #include <map>
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "net/base/cache_type.h"
 #include "net/base/completion_callback.h"
 #include "net/base/load_states.h"
@@ skipping 163 matching lines @@
   }
 
   // Causes all transactions created after this point to generate a failure
   // when attempting to conditionalize a network request.
   void FailConditionalizationForTest() {
     fail_conditionalization_for_test_ = true;
   }
 
   // HttpTransactionFactory implementation:
   int CreateTransaction(RequestPriority priority,
-                        std::unique_ptr<HttpTransaction>* trans) override;
+                        std::unique_ptr<HttpTransaction>* transaction) override;
   HttpCache* GetCache() override;
   HttpNetworkSession* GetSession() override;
 
   base::WeakPtr<HttpCache> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }
 
   // Resets the network layer to allow for tests that probe
   // network changes (e.g. host unreachable).  The old network layer is
   // returned to allow for filter patterns that only intercept
   // some creation requests.  Note ownership exchange.
   std::unique_ptr<HttpTransactionFactory>
   SetHttpNetworkTransactionFactoryForTesting(
       std::unique_ptr<HttpTransactionFactory> new_network_layer);
 
  private:
   // Types --------------------------------------------------------------------
 
   // Disk cache entry data indices.
   enum {
     kResponseInfoIndex = 0,
     kResponseContentIndex,
     kMetadataIndex,
 
     // Must remain at the end of the enum.
     kNumCacheEntryDataIndices
   };
 
+  class DataAccess;
+  class SharedWriters;
+  class Transaction;
+  using TransactionList = std::list<Transaction*>;
+  using TransactionSet = std::unordered_set<Transaction*>;
   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<std::unique_ptr<WorkItem>> WorkItemList;
 
   struct ActiveEntry {
     explicit ActiveEntry(disk_cache::Entry* entry);
     ~ActiveEntry();
 
     disk_cache::Entry* disk_entry;
+    // Either writer or shared_writers will be non-null at any point in time.
     Transaction*       writer;
-    TransactionList    readers;
+    std::unique_ptr<SharedWriters> shared_writers;
+    TransactionSet readers;
     TransactionList    pending_queue;
     bool               will_process_pending_queue;
     bool               doomed;
   };
 
   using ActiveEntriesMap =
       std::unordered_map<std::string, std::unique_ptr<ActiveEntry>>;
   using PendingOpsMap = std::unordered_map<std::string, PendingOp*>;
   using ActiveEntriesSet = std::map<ActiveEntry*, std::unique_ptr<ActiveEntry>>;
   using PlaybackCacheMap = std::unordered_map<std::string, int>;
@@ skipping 35 matching lines @@
   // Closes a previously doomed entry.
   void FinalizeDoomedEntry(ActiveEntry* entry);
 
   // Returns an entry that is currently in use and not doomed, or NULL.
   ActiveEntry* FindActiveEntry(const std::string& key);
 
   // Creates a new ActiveEntry and starts tracking it. |disk_entry| is the disk
   // cache entry.
   ActiveEntry* ActivateEntry(disk_cache::Entry* disk_entry);
 
-  // Deletes an ActiveEntry.
+  // Deletes an ActiveEntry. Expects writer to be nullptr and containers to be
+  // empty: shared_writers, pending_queue and readers.
   void DeactivateEntry(ActiveEntry* entry);
 
   // Deletes an ActiveEntry using an exhaustive search.
   void SlowDeactivateEntry(ActiveEntry* entry);
 
   // Returns the PendingOp for the desired |key|. If an entry is not under
   // construction already, a new PendingOp structure is created.
   PendingOp* GetPendingOp(const std::string& key);
 
   // Deletes a PendingOp.
@@ skipping 69 matching lines @@
   // TODO(ajwong): The PendingOp lifetime management is very tricky.  It might
   // be possible to simplify it using either base::Owned() or base::Passed()
   // with the callback.
   static void OnPendingOpComplete(const base::WeakPtr<HttpCache>& cache,
                                   PendingOp* pending_op,
                                   int result);
 
   // Processes the backend creation notification.
   void OnBackendCreated(int result, PendingOp* pending_op);
 
+  // Destroys the entry and any pending queue transactions' callbacks are
+  // invoked with ERR_CACHE_RACE that restarts their state machine.
+  void DestroyEntryRestartPendingQueue(ActiveEntry* entry);
+
+  // Dooms the entry and any pending queue transactions' callbacks are
+  // invoked with ERR_CACHE_RACE that restarts their state machine.
+  void DoomEntryRestartPendingQueue(const std::string& key, ActiveEntry* entry);
+
+  // Writes response info to entry.
+  int WriteResponseInfo(ActiveEntry* entry,
+                        const HttpResponseInfo* response,
+                        CompletionCallback& callback,
+                        bool truncated,
+                        int* io_buf_len);
+
+  // Checks if the response is completed based on content length.
+  bool IsResponseCompleted(const ActiveEntry* entry,
+                           const HttpResponseInfo* response);
+
+  // Returns true if we should bother attempting to resume this request if it is
+  // aborted while in progress. If |has_data| is true, the size of the stored
+  // data is considered for the result.
+  bool CanResumeEntry(bool has_data,
+                      const std::string& method,
+                      const HttpResponseInfo* response,
+                      ActiveEntry* entry);
+
+  // Response data completely written to the cache successfully, or
+  // Response data could not be written to the cache successfully, or
+  // Response data could not be read from the network successfully.
+  // Success is true if the entry was marked as truncated successfully.
+  // destroyed is set to true when the calling SharedWiters object is reset.
+  void ResponseDoneSharedWriters(ActiveEntry* entry,
+                                 bool success,
+                                 bool* destroyed);
+
+  // Resets SharedWriters if entry contains an empty SharedWriters object and
+  // calls ProcessPendingQueue.
+  void ResetSharedWritersProcessPendingQueue(ActiveEntry* entry);
+  void ResetSharedWriters(ActiveEntry* entry);
+
+  void RemovedSharedWriterTransaction(Transaction* transaction,
+                                      ActiveEntry* entry);
+
   // Variables ----------------------------------------------------------------
 
   NetLog* net_log_;
 
   // Used when lazily constructing the disk_cache_.
   std::unique_ptr<BackendFactory> backend_factory_;
   bool building_backend_;
   bool bypass_lock_for_test_;
   bool fail_conditionalization_for_test_;
 
@@ skipping 18 matching lines @@
   std::unique_ptr<base::Clock> clock_;
 
   base::WeakPtrFactory<HttpCache> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpCache);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_CACHE_H_