Home | History | Annotate | Download | only in extensions 
      1 // Copyright (c) 2013 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_CHROMEOS_EXTENSIONS_EXTERNAL_CACHE_H_
      6 #define CHROME_BROWSER_CHROMEOS_EXTENSIONS_EXTERNAL_CACHE_H_
      7 
      8 #include <string>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/callback_forward.h"
     12 #include "base/files/file_path.h"
     13 #include "base/gtest_prod_util.h"
     14 #include "base/memory/ref_counted.h"
     15 #include "base/memory/scoped_ptr.h"
     16 #include "base/memory/weak_ptr.h"
     17 #include "base/sequenced_task_runner.h"
     18 #include "chrome/browser/extensions/updater/extension_downloader_delegate.h"
     19 #include "chrome/browser/extensions/updater/local_extension_cache.h"
     20 #include "content/public/browser/notification_observer.h"
     21 #include "content/public/browser/notification_registrar.h"
     22 
     23 namespace base {
     24 class DictionaryValue;
     25 }
     26 
     27 namespace extensions {
     28 class ExtensionDownloader;
     29 }
     30 
     31 namespace net {
     32 class URLRequestContextGetter;
     33 }
     34 
     35 namespace chromeos {
     36 
     37 // The ExternalCache manages a cache for external extensions.
     38 class ExternalCache : public content::NotificationObserver,
     39                       public extensions::ExtensionDownloaderDelegate {
     40  public:
     41   typedef base::Callback<void(const std::string& id, bool success)>
     42       PutExternalExtensionCallback;
     43 
     44   class Delegate {
     45    public:
     46     virtual ~Delegate() {}
     47     // Caller owns |prefs|.
     48     virtual void OnExtensionListsUpdated(
     49         const base::DictionaryValue* prefs) = 0;
     50     // Called after extension with |id| is loaded in cache.
     51     virtual void OnExtensionLoadedInCache(const std::string& id) {}
     52     // Called when extension with |id| is failed with downloading for |error|.
     53     virtual void OnExtensionDownloadFailed(
     54         const std::string& id,
     55         extensions::ExtensionDownloaderDelegate::Error error) {}
     56 
     57     // Cache needs to provide already installed extensions otherwise they
     58     // will be removed. Cache calls this function to get version of installed
     59     // extension or empty string if not installed.
     60     virtual std::string GetInstalledExtensionVersion(const std::string& id);
     61   };
     62 
     63   // The |request_context| is used for update checks. All file I/O is done via
     64   // the |backend_task_runner|. If |always_check_updates| is |false|, update
     65   // checks are performed for extensions that have an |external_update_url|
     66   // only. If |wait_for_cache_initialization| is |true|, the cache contents will
     67   // not be read until a flag file appears in the cache directory, signaling
     68   // that the cache is ready.
     69   ExternalCache(const base::FilePath& cache_dir,
     70                 net::URLRequestContextGetter* request_context,
     71                 const scoped_refptr<base::SequencedTaskRunner>&
     72                     backend_task_runner,
     73                 Delegate* delegate,
     74                 bool always_check_updates,
     75                 bool wait_for_cache_initialization);
     76   virtual ~ExternalCache();
     77 
     78   // Returns already cached extensions.
     79   const base::DictionaryValue* cached_extensions() {
     80     return cached_extensions_.get();
     81   }
     82 
     83   // Implementation of content::NotificationObserver:
     84   virtual void Observe(int type,
     85                        const content::NotificationSource& source,
     86                        const content::NotificationDetails& details) OVERRIDE;
     87 
     88   // Implementation of ExtensionDownloaderDelegate:
     89   virtual void OnExtensionDownloadFailed(
     90       const std::string& id,
     91       Error error,
     92       const PingResult& ping_result,
     93       const std::set<int>& request_ids) OVERRIDE;
     94 
     95   virtual void OnExtensionDownloadFinished(
     96       const std::string& id,
     97       const base::FilePath& path,
     98       bool file_ownership_passed,
     99       const GURL& download_url,
    100       const std::string& version,
    101       const PingResult& ping_result,
    102       const std::set<int>& request_ids) OVERRIDE;
    103 
    104   virtual bool IsExtensionPending(const std::string& id) OVERRIDE;
    105 
    106   virtual bool GetExtensionExistingVersion(const std::string& id,
    107                                            std::string* version) OVERRIDE;
    108 
    109   // Shut down the cache. The |callback| will be invoked when the cache has shut
    110   // down completely and there are no more pending file I/O operations.
    111   void Shutdown(const base::Closure& callback);
    112 
    113   // Replace the list of extensions to cache with |prefs| and perform update
    114   // checks for these.
    115   void UpdateExtensionsList(scoped_ptr<base::DictionaryValue> prefs);
    116 
    117   // If a user of one of the ExternalCache's extensions detects that
    118   // the extension is damaged then this method can be used to remove it from
    119   // the cache and retry to download it after a restart.
    120   void OnDamagedFileDetected(const base::FilePath& path);
    121 
    122   // Removes extensions listed in |ids| from external cache, corresponding crx
    123   // files will be removed from disk too.
    124   void RemoveExtensions(const std::vector<std::string>& ids);
    125 
    126   // If extension with |id| exists in the cache, returns |true|, |file_path| and
    127   // |version| for the extension. Extension will be marked as used with current
    128   // timestamp.
    129   bool GetExtension(const std::string& id,
    130                     base::FilePath* file_path,
    131                     std::string* version);
    132 
    133   // Puts the external |crx_file_path| into |local_cache_| for extension with
    134   // |id|.
    135   void PutExternalExtension(const std::string& id,
    136                             const base::FilePath& crx_file_path,
    137                             const std::string& version,
    138                             const PutExternalExtensionCallback& callback);
    139 
    140  private:
    141   // Notifies the that the cache has been updated, providing
    142   // extensions loader with an updated list of extensions.
    143   void UpdateExtensionLoader();
    144 
    145   // Checks the cache contents and initiate download if needed.
    146   void CheckCache();
    147 
    148   // Invoked on the UI thread when a new entry has been installed in the cache.
    149   void OnPutExtension(const std::string& id,
    150                       const base::FilePath& file_path,
    151                       bool file_ownership_passed);
    152 
    153   // Invoked on the UI thread when the external extension has been installed
    154   // in the local cache by calling PutExternalExtension.
    155   void OnPutExternalExtension(const std::string& id,
    156                               const PutExternalExtensionCallback& callback,
    157                               const base::FilePath& file_path,
    158                               bool file_ownership_passed);
    159 
    160   extensions::LocalExtensionCache local_cache_;
    161 
    162   // Request context used by the |downloader_|.
    163   scoped_refptr<net::URLRequestContextGetter> request_context_;
    164 
    165   // Task runner for executing file I/O tasks.
    166   const scoped_refptr<base::SequencedTaskRunner> backend_task_runner_;
    167 
    168   // Delegate that would like to get notifications about cache updates.
    169   Delegate* delegate_;
    170 
    171   // Updates needs to be check for the extensions with external_crx too.
    172   bool always_check_updates_;
    173 
    174   // Set to true if cache should wait for initialization flag file.
    175   bool wait_for_cache_initialization_;
    176 
    177   // This is the list of extensions currently configured.
    178   scoped_ptr<base::DictionaryValue> extensions_;
    179 
    180   // This contains extensions that are both currently configured
    181   // and that have a valid crx in the cache.
    182   scoped_ptr<base::DictionaryValue> cached_extensions_;
    183 
    184   // Used to download the extensions and to check for updates.
    185   scoped_ptr<extensions::ExtensionDownloader> downloader_;
    186 
    187   // Observes failures to install CRX files.
    188   content::NotificationRegistrar notification_registrar_;
    189 
    190   // Weak factory for callbacks.
    191   base::WeakPtrFactory<ExternalCache> weak_ptr_factory_;
    192 
    193   DISALLOW_COPY_AND_ASSIGN(ExternalCache);
    194 };
    195 
    196 }  // namespace chromeos
    197 
    198 #endif  // CHROME_BROWSER_CHROMEOS_EXTENSIONS_EXTERNAL_CACHE_H_
    199