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  private:
  56   class CreateBackendCallbackShim;
  57   class EntryImpl;
  58
  59   // PendingCalls allow CreateEntry, OpenEntry, and DoomEntry to be called
  60   // immediately after construction, without waiting for the
  61   // underlying disk_cache::Backend to be fully constructed. Early
  62   // calls are queued up and serviced once the disk_cache::Backend is
  63   // really ready to go.
  64   enum PendingCallType {
  65     CREATE,
  66     OPEN,
  67     DOOM
  68   };
  69   struct PendingCall {
  70     PendingCallType call_type;
  71     int64 key;
  72     Entry** entry;
  73     net::CompletionCallback callback;
  74
  75     PendingCall();
  76
  77     PendingCall(PendingCallType call_type, int64 key,
  78                 Entry** entry, const net::CompletionCallback& callback);
  79
  80     ~PendingCall();
  81   };
  82   typedef std::vector<PendingCall> PendingCalls;
  83
  84   class ActiveCall;
  85   typedef std::set<ActiveCall*> ActiveCalls;
  86   typedef std::set<EntryImpl*> OpenEntries;
  87
  88   bool is_initializing() const {
  89     return create_backend_callback_.get() != NULL;
  90   }
  91   disk_cache::Backend* disk_cache() { return disk_cache_.get(); }
  92   int Init(net::CacheType cache_type,
  93            const base::FilePath& directory,
  94            int cache_size,
  95            bool force,
  96            const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread,
  97            const net::CompletionCallback& callback);
  98   void OnCreateBackendComplete(int rv);
  99   void AddActiveCall(ActiveCall* call) { active_calls_.insert(call); }
 100   void RemoveActiveCall(ActiveCall* call) { active_calls_.erase(call); }
 101   void AddOpenEntry(EntryImpl* entry) { open_entries_.insert(entry); }
 102   void RemoveOpenEntry(EntryImpl* entry) { open_entries_.erase(entry); }
 103
 104   bool is_disabled_;
 105   net::CompletionCallback init_callback_;
 106   scoped_refptr<CreateBackendCallbackShim> create_backend_callback_;
 107   PendingCalls pending_calls_;
 108   ActiveCalls active_calls_;
 109   OpenEntries open_entries_;
 110   scoped_ptr<disk_cache::Backend> disk_cache_;
 111 };
 112
 113 }  // namespace content
 114
 115 #endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_DISK_CACHE_H_