content/browser/appcache/appcache_disk_cache.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_BROWSER_APPCACHE_APPCACHE_DISK_CACHE_H_
   6 #define CONTENT_BROWSER_APPCACHE_APPCACHE_DISK_CACHE_H_
   7
   8 #include <set>
   9 #include <vector>
  10
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "content/browser/appcache/appcache_response.h"
  14 #include "content/common/content_export.h"
  15 #include "net/disk_cache/disk_cache.h"
  16
  17 namespace base {
  18 class SingleThreadTaskRunner;
  19 }  // namespace base
  20
  21 namespace content {
  22
  23 // An implementation of AppCacheDiskCacheInterface that
  24 // uses net::DiskCache as the backing store.
  25 class CONTENT_EXPORT AppCacheDiskCache
  26     : public AppCacheDiskCacheInterface {
  27  public:
  28   AppCacheDiskCache();
  29   ~AppCacheDiskCache() override;
  30
  31   // Initializes the object to use disk backed storage.
  32   int InitWithDiskBackend(
  33       const base::FilePath& disk_cache_directory,
  34       int disk_cache_size,
  35       bool force,
  36       const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread,
  37       const net::CompletionCallback& callback);
  38
  39   // Initializes the object to use memory only storage.
  40   // This is used for Chrome's incognito browsing.
  41   int InitWithMemBackend(int disk_cache_size,
  42                          const net::CompletionCallback& callback);
  43
  44   void Disable();
  45   bool is_disabled() const { return is_disabled_; }
  46
  47   int CreateEntry(int64 key,
  48                   Entry** entry,
  49                   const net::CompletionCallback& callback) override;
  50   int OpenEntry(int64 key,
  51                 Entry** entry,
  52                 const net::CompletionCallback& callback) override;
  53   int DoomEntry(int64 key, const net::CompletionCallback& callback) override;
  54
  55   void set_is_waiting_to_initialize(bool is_waiting_to_initialize) {
  56     is_waiting_to_initialize_ = is_waiting_to_initialize;
  57   }
  58
  59  protected:
  60   explicit AppCacheDiskCache(bool use_simple_cache);
  61   disk_cache::Backend* disk_cache() { return disk_cache_.get(); }
  62
  63  private:
  64   class CreateBackendCallbackShim;
  65   class EntryImpl;
  66
  67   // PendingCalls allow CreateEntry, OpenEntry, and DoomEntry to be called
  68   // immediately after construction, without waiting for the
  69   // underlying disk_cache::Backend to be fully constructed. Early
  70   // calls are queued up and serviced once the disk_cache::Backend is
  71   // really ready to go.
  72   enum PendingCallType {
  73     CREATE,
  74     OPEN,
  75     DOOM
  76   };
  77   struct PendingCall {
  78     PendingCallType call_type;
  79     int64 key;
  80     Entry** entry;
  81     net::CompletionCallback callback;
  82
  83     PendingCall();
  84
  85     PendingCall(PendingCallType call_type, int64 key,
  86                 Entry** entry, const net::CompletionCallback& callback);
  87
  88     ~PendingCall();
  89   };
  90   typedef std::vector<PendingCall> PendingCalls;
  91
  92   class ActiveCall;
  93   typedef std::set<ActiveCall*> ActiveCalls;
  94   typedef std::set<EntryImpl*> OpenEntries;
  95
  96   bool is_initializing_or_waiting_to_initialize() const {
  97     return create_backend_callback_.get() != NULL || is_waiting_to_initialize_;
  98   }
  99
 100   int Init(net::CacheType cache_type,
 101            const base::FilePath& directory,
 102            int cache_size,
 103            bool force,
 104            const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread,
 105            const net::CompletionCallback& callback);
 106   void OnCreateBackendComplete(int rv);
 107   void AddOpenEntry(EntryImpl* entry) { open_entries_.insert(entry); }
 108   void RemoveOpenEntry(EntryImpl* entry) { open_entries_.erase(entry); }
 109
 110   bool use_simple_cache_;
 111   bool is_disabled_;
 112   bool is_waiting_to_initialize_;
 113   net::CompletionCallback init_callback_;
 114   scoped_refptr<CreateBackendCallbackShim> create_backend_callback_;
 115   PendingCalls pending_calls_;
 116   OpenEntries open_entries_;
 117   scoped_ptr<disk_cache::Backend> disk_cache_;
 118
 119   base::WeakPtrFactory<AppCacheDiskCache> weak_factory_;
 120 };
 121
 122 }  // namespace content
 123
 124 #endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_DISK_CACHE_H_