chrome/browser/extensions/updater/local_extension_cache.h

   1 // Copyright 2014 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 CHROME_BROWSER_EXTENSIONS_UPDATER_LOCAL_EXTENSION_CACHE_H_
   6 #define CHROME_BROWSER_EXTENSIONS_UPDATER_LOCAL_EXTENSION_CACHE_H_
   7
   8 #include <map>
   9 #include <string>
  10
  11 #include "base/callback_forward.h"
  12 #include "base/files/file_path.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/time/time.h"
  16
  17 namespace extensions {
  18
  19 // Cache .crx files in some local dir for future use. Cache keeps only latest
  20 // version of the extensions. Only one instance of LocalExtensionCache can work
  21 // with the same directory. But LocalExtensionCache instance can be shared
  22 // between multiple clients. Public interface can be used only from UI thread.
  23 class LocalExtensionCache {
  24  public:
  25   // Callback invoked on UI thread when PutExtension is completed.
  26   typedef base::Callback<void(const base::FilePath& file_path,
  27                               bool file_ownership_passed)> PutExtensionCallback;
  28
  29   // |cache_dir| - directory that will be used for caching CRX files.
  30   // |max_cache_size| - maximum disk space that cache can use, 0 means no limit.
  31   // |max_cache_age| - maximum age that unused item can be kept in cache, 0 age
  32   // means that all unused cache items will be removed on Shutdown.
  33   // All file I/O is done via the |backend_task_runner|.
  34   LocalExtensionCache(const base::FilePath& cache_dir,
  35                       uint64 max_cache_size,
  36                       const base::TimeDelta& max_cache_age,
  37                       const scoped_refptr<base::SequencedTaskRunner>&
  38                           backend_task_runner);
  39   ~LocalExtensionCache();
  40
  41   // Name of flag file that indicates that cache is ready (import finished).
  42   static const char kCacheReadyFlagFileName[];
  43
  44   // Initialize cache. If |wait_for_cache_initialization| is |true|, the cache
  45   // contents will not be read until a flag file appears in the cache directory,
  46   // signaling that the cache is ready. The |callback| is called when cache is
  47   // ready and cache dir content was already checked.
  48   void Init(bool wait_for_cache_initialization,
  49             const base::Closure& callback);
  50
  51   // Shut down the cache. The |callback| will be invoked when the cache has shut
  52   // down completely and there are no more pending file I/O operations.
  53   void Shutdown(const base::Closure& callback);
  54
  55   // If extension with |id| exists in the cache, returns |true|, |file_path| and
  56   // |version| for the extension. Extension will be marked as used with current
  57   // timestamp.
  58   bool GetExtension(const std::string& id,
  59                     base::FilePath* file_path,
  60                     std::string* version);
  61
  62   // Put extension with |id| and |version| into local cache. Older version in
  63   // the cache will be on next run so it can be safely used. Extension will be
  64   // marked as used with current timestamp. The file will be available via
  65   // GetExtension when |callback| is called. PutExtension may get ownership
  66   // of |file_path| or return it back via |callback|.
  67   void PutExtension(const std::string& id,
  68                     const base::FilePath& file_path,
  69                     const std::string& version,
  70                     const PutExtensionCallback& callback);
  71
  72   // Remove extension with |id| from local cache, corresponding crx file will be
  73   // removed from disk too.
  74   bool RemoveExtension(const std::string& id);
  75
  76   // Return cache statistics. Returns |false| if cache is not ready.
  77   bool GetStatistics(uint64* cache_size,
  78                      size_t* extensions_count);
  79
  80   bool is_ready() const { return state_ == kReady; }
  81   bool is_uninitialized() const { return state_ == kUninitialized; }
  82   bool is_shutdown() const { return state_ == kShutdown; }
  83
  84   // For tests only!
  85   void SetCacheStatusPollingDelayForTests(const base::TimeDelta& delay);
  86
  87  private:
  88   struct CacheItemInfo {
  89     std::string version;
  90     base::Time last_used;
  91     uint64 size;
  92     base::FilePath file_path;
  93
  94     CacheItemInfo(const std::string& version,
  95                   const base::Time& last_used,
  96                   uint64 size,
  97                   const base::FilePath& file_path);
  98   };
  99   typedef std::map<std::string, CacheItemInfo> CacheMap;
 100
 101   enum State {
 102     kUninitialized,
 103     kWaitInitialization,
 104     kReady,
 105     kShutdown
 106   };
 107
 108   // Sends BackendCheckCacheStatus task on backend thread.
 109   void CheckCacheStatus(const base::Closure& callback);
 110
 111   // Checks whether a flag file exists in the |cache_dir|, indicating that the
 112   // cache is ready. This method is invoked via the |backend_task_runner_| and
 113   // posts its result back to the |local_cache| on the UI thread.
 114   static void BackendCheckCacheStatus(
 115       base::WeakPtr<LocalExtensionCache> local_cache,
 116       const base::FilePath& cache_dir,
 117       const base::Closure& callback);
 118
 119   // Invoked on the UI thread after checking whether the cache is ready. If the
 120   // cache is not ready yet, posts a delayed task that will repeat the check,
 121   // thus polling for cache readiness.
 122   void OnCacheStatusChecked(bool ready, const base::Closure& callback);
 123
 124   // Checks the cache contents. This is a helper that invokes the actual check
 125   // by posting to the |backend_task_runner_|.
 126   void CheckCacheContents(const base::Closure& callback);
 127
 128   // Checks the cache contents. This method is invoked via the
 129   // |backend_task_runner_| and posts back a list of cache entries to the
 130   // |local_cache| on the UI thread.
 131   static void BackendCheckCacheContents(
 132       base::WeakPtr<LocalExtensionCache> local_cache,
 133       const base::FilePath& cache_dir,
 134       const base::Closure& callback);
 135
 136   // Helper for BackendCheckCacheContents() that updates |cache_content|.
 137   static void BackendCheckCacheContentsInternal(
 138       const base::FilePath& cache_dir,
 139       CacheMap* cache_content);
 140
 141   // Invoked when the cache content on disk has been checked. |cache_content|
 142   // contains all the currently valid crx files in the cache.
 143   void OnCacheContentsChecked(scoped_ptr<CacheMap> cache_content,
 144                               const base::Closure& callback);
 145
 146   // Update timestamp for the file to mark it as "used". This method is invoked
 147   // via the |backend_task_runner_|.
 148   static void BackendMarkFileUsed(const base::FilePath& file_path,
 149                                   const base::Time& time);
 150
 151   // Installs the downloaded crx file at |path| in the |cache_dir|. This method
 152   // is invoked via the |backend_task_runner_|.
 153   static void BackendInstallCacheEntry(
 154       base::WeakPtr<LocalExtensionCache> local_cache,
 155       const base::FilePath& cache_dir,
 156       const std::string& id,
 157       const base::FilePath& file_path,
 158       const std::string& version,
 159       const PutExtensionCallback& callback);
 160
 161   // Invoked on the UI thread when a new entry has been installed in the cache.
 162   void OnCacheEntryInstalled(const std::string& id,
 163                              const CacheItemInfo& info,
 164                              bool was_error,
 165                              const PutExtensionCallback& callback);
 166
 167   // Remove cached crx files(all versions) under |cached_dir| for extension with
 168   // |id|. This method is invoked via the |backend_task_runner_|.
 169   static void BackendRemoveCacheEntry(const base::FilePath& cache_dir,
 170                                       const std::string& id);
 171
 172   // Compare two cache items returns true if first item is older.
 173   static bool CompareCacheItemsAge(const CacheMap::iterator& lhs,
 174                                    const CacheMap::iterator& rhs);
 175
 176   // Calculate which files need to be deleted and schedule files deletion.
 177   void CleanUp();
 178
 179   // Path to the directory where the extension cache is stored.
 180   base::FilePath cache_dir_;
 181
 182   // Maximum size of cache dir on disk.
 183   uint64 max_cache_size_;
 184
 185   // Minimal age of unused item in cache, items prior to this age will be
 186   // deleted on shutdown.
 187   base::Time min_cache_age_;
 188
 189   // Task runner for executing file I/O tasks.
 190   scoped_refptr<base::SequencedTaskRunner> backend_task_runner_;
 191
 192   // Track state of the instance.
 193   State state_;
 194
 195   // This contains info about all cached extensions.
 196   CacheMap cached_extensions_;
 197
 198   // Weak factory for callbacks from the backend and delayed tasks.
 199   base::WeakPtrFactory<LocalExtensionCache> weak_ptr_factory_;
 200
 201   // Delay between polling cache status.
 202   base::TimeDelta cache_status_polling_delay_;
 203
 204   DISALLOW_COPY_AND_ASSIGN(LocalExtensionCache);
 205 };
 206
 207 }  // namespace extensions
 208
 209 #endif  // CHROME_BROWSER_EXTENSIONS_UPDATER_LOCAL_EXTENSION_CACHE_H_