Http Cache: Handle the asynchronous instantiation of the...

net/http/http_cache.h

 // Copyright (c) 2010 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 2616 (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 <set>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/hash_tables.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "base/weak_ptr.h"
 #include "net/base/cache_type.h"
 #include "net/base/completion_callback.h"
 #include "net/http/http_transaction_factory.h"
+#include "testing/gtest/include/gtest/gtest_prod.h"
 
 class GURL;
 class MessageLoop;
 class ViewCacheHelper;
 
 namespace disk_cache {
 class Backend;
 class Entry;
 }
 
@@ skipping 138 matching lines @@
     kResponseInfoIndex = 0,
     kResponseContentIndex,
     kMetadataIndex,
 
     // Must remain at the end of the enum.
     kNumCacheEntryDataIndices
   };
   friend class ::ViewCacheHelper;
 
  private:
+  FRIEND_TEST(HttpCacheTest, SimpleGET_WaitForBackend);
+  FRIEND_TEST(HttpCacheTest, SimpleGET_WaitForBackend_CancelCreate);
 
   // Types --------------------------------------------------------------------
 
   class BackendCallback;
   class MetadataWriter;
   class Transaction;
   class WorkItem;
   friend class Transaction;
-  struct NewEntry;  // Info for an entry under construction.
+  struct PendingOp;  // Info for an entry under construction.
 
   typedef std::list<Transaction*> TransactionList;
   typedef std::list<WorkItem*> WorkItemList;
 
   struct ActiveEntry {
     disk_cache::Entry* disk_entry;
     Transaction*       writer;
     TransactionList    readers;
     TransactionList    pending_queue;
     bool               will_process_pending_queue;
     bool               doomed;
 
     explicit ActiveEntry(disk_cache::Entry*);
     ~ActiveEntry();
   };
 
   typedef base::hash_map<std::string, ActiveEntry*> ActiveEntriesMap;
-  typedef base::hash_map<std::string, NewEntry*> NewEntriesMap;
+  typedef base::hash_map<std::string, PendingOp*> PendingOpsMap;
   typedef std::set<ActiveEntry*> ActiveEntriesSet;
 
+  typedef int (*CreateCacheBackendFn)(CacheType, const FilePath&, int,
+                                      bool, MessageLoop*, disk_cache::Backend**,
+                                      CompletionCallback*);
+
   // Methods ------------------------------------------------------------------
 
+  // Creates the |backend| object and notifies the |callback| when the operation
+  // completes. Returns an error code.
+  int CreateBackend(disk_cache::Backend** backend,
+                    CompletionCallback* callback);
+
+  // Makes sure that the backend creation is complete before allowing the
+  // provided transaction to use the object. Returns an error code.  |trans|
+  // will be notified via its IO callback if this method returns ERR_IO_PENDING.
+  // The transaction is free to use the backend directly at any time after
+  // receiving the notification.
+  int GetBackendForTransaction(Transaction* trans);
+
   // Generates the cache key for this request.
   std::string GenerateCacheKey(const HttpRequestInfo*);
 
   // Dooms the entry selected by |key|. |trans| will be notified via its IO
   // callback if this method returns ERR_IO_PENDING. The entry can be
   // currently in use or not.
   int DoomEntry(const std::string& key, Transaction* trans);
 
   // Dooms the entry selected by |key|. |trans| will be notified via its IO
   // callback if this method returns ERR_IO_PENDING. The entry should not
@@ skipping 11 matching lines @@
   // TODO(rvargas): remove the |key| argument.
   ActiveEntry* ActivateEntry(const std::string& key,
                              disk_cache::Entry* disk_entry);
 
   // Deletes an ActiveEntry.
   void DeactivateEntry(ActiveEntry* entry);
 
   // Deletes an ActiveEntry using an exhaustive search.
   void SlowDeactivateEntry(ActiveEntry* entry);
 
-  // Returns the NewEntry for the desired |key|. If an entry is not under
-  // construction already, a new NewEntry structure is created.
-  NewEntry* GetNewEntry(const std::string& key);
+  // 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 NewEntry.
-  void DeleteNewEntry(NewEntry* entry);
+  // Deletes a PendingOp.
+  void DeletePendingOp(PendingOp* pending_op);
 
   // Opens the disk cache entry associated with |key|, returning an ActiveEntry
   // in |*entry|. |trans| will be notified via its IO callback if this method
   // returns ERR_IO_PENDING.
   int OpenEntry(const std::string& key, ActiveEntry** entry,
                 Transaction* trans);
 
   // Creates the disk cache entry associated with |key|, returning an
   // ActiveEntry in |*entry|. |trans| will be notified via its IO callback if
   // this method returns ERR_IO_PENDING.
@@ skipping 20 matching lines @@
   void DoneWritingToEntry(ActiveEntry* entry, bool success);
 
   // Called when the transaction has finished reading from this entry.
   void DoneReadingFromEntry(ActiveEntry* entry, Transaction* trans);
 
   // Convers the active writter transaction to a reader so that other
   // transactions can start reading from this entry.
   void ConvertWriterToReader(ActiveEntry* entry);
 
   // Removes the transaction |trans|, from the pending list of an entry
-  // (NewEntry, active or doomed entry).
+  // (PendingOp, active or doomed entry).
   void RemovePendingTransaction(Transaction* trans);
 
   // Removes the transaction |trans|, from the pending list of |entry|.
   bool RemovePendingTransactionFromEntry(ActiveEntry* entry,
                                          Transaction* trans);
 
-  // Removes the transaction |trans|, from the pending list of |entry|.
-  bool RemovePendingTransactionFromNewEntry(NewEntry* entry,
-                                            Transaction* trans);
+  // Removes the transaction |trans|, from the pending list of |pending_op|.
+  bool RemovePendingTransactionFromPendingOp(PendingOp* pending_op,
+                                             Transaction* trans);
 
   // Resumes processing the pending list of |entry|.
   void ProcessPendingQueue(ActiveEntry* entry);
 
   // Events (called via PostTask) ---------------------------------------------
 
   void OnProcessPendingQueue(ActiveEntry* entry);
 
   // Callbacks ----------------------------------------------------------------
 
   // Processes BackendCallback notifications.
-  void OnIOComplete(int result, NewEntry* entry);
+  void OnIOComplete(int result, PendingOp* entry);
+
+  // Processes the backend creation notification.
+  void OnBackendCreated(int result, PendingOp* pending_op);
 
 
   // Variables ----------------------------------------------------------------
 
   // Used when lazily constructing the disk_cache_.
   FilePath disk_cache_dir_;
   MessageLoop* cache_thread_;
+  disk_cache::Backend* temp_backend_;
+  bool building_backend_;
 
   Mode mode_;
   CacheType type_;
 
   scoped_ptr<HttpTransactionFactory> network_layer_;
   scoped_ptr<disk_cache::Backend> disk_cache_;
 
   // The set of active entries indexed by cache key.
   ActiveEntriesMap active_entries_;
 
   // The set of doomed entries.
   ActiveEntriesSet doomed_entries_;
 
   // The set of entries "under construction".
-  NewEntriesMap new_entries_;
+  PendingOpsMap pending_ops_;
 
   ScopedRunnableMethodFactory<HttpCache> task_factory_;
 
   bool enable_range_support_;
   int cache_size_;
 
   typedef base::hash_map<std::string, int> PlaybackCacheMap;
   scoped_ptr<PlaybackCacheMap> playback_cache_map_;
 
+  // Used for unit tests.
+  CreateCacheBackendFn create_backend_fn_;
+
   DISALLOW_COPY_AND_ASSIGN(HttpCache);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_CACHE_H_