Home | History | Annotate | Download | only in extensions 
      1 // Copyright (c) 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_EXTENSION_ASSETS_MANAGER_CHROMEOS_H_
      6 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_ASSETS_MANAGER_CHROMEOS_H_
      7 
      8 #include <map>
      9 
     10 #include "chrome/browser/extensions/extension_assets_manager.h"
     11 
     12 template <typename T> struct DefaultSingletonTraits;
     13 class PrefRegistrySimple;
     14 
     15 namespace base {
     16 class DictionaryValue;
     17 class SequencedTaskRunner;
     18 }
     19 
     20 namespace extensions {
     21 
     22 // Chrome OS specific implementation of assets manager that shares default apps
     23 // between all users on the machine.
     24 class ExtensionAssetsManagerChromeOS : public ExtensionAssetsManager {
     25  public:
     26   static ExtensionAssetsManagerChromeOS* GetInstance();
     27 
     28   // A dictionary that maps shared extension IDs to version/paths/users.
     29   static const char kSharedExtensions[];
     30 
     31   // Name of path attribute in shared extensions map.
     32   static const char kSharedExtensionPath[];
     33 
     34   // Name of users attribute (list of user emails) in shared extensions map.
     35   static const char kSharedExtensionUsers[];
     36 
     37   // Register shared assets related preferences.
     38   static void RegisterPrefs(PrefRegistrySimple* registry);
     39 
     40   // Override from ExtensionAssetsManager.
     41   virtual void InstallExtension(const Extension* extension,
     42                                 const base::FilePath& unpacked_extension_root,
     43                                 const base::FilePath& local_install_dir,
     44                                 Profile* profile,
     45                                 InstallExtensionCallback callback) OVERRIDE;
     46   virtual void UninstallExtension(
     47       const std::string& id,
     48       Profile* profile,
     49       const base::FilePath& local_install_dir,
     50       const base::FilePath& extension_root) OVERRIDE;
     51 
     52   // Return shared install dir.
     53   static base::FilePath GetSharedInstallDir();
     54 
     55   // Return true if |extension| was installed to shared location.
     56   static bool IsSharedInstall(const Extension* extension);
     57 
     58   // Cleans up shared extensions list in preferences and returns list of
     59   // extension IDs and version paths that are in use in |live_extension_paths|.
     60   // Files on disk are not removed. Must be called on UI thread.
     61   // Returns |false| in case of errors.
     62   static bool CleanUpSharedExtensions(
     63       std::multimap<std::string, base::FilePath>* live_extension_paths);
     64 
     65   static void SetSharedInstallDirForTesting(const base::FilePath& install_dir);
     66 
     67  private:
     68   friend struct DefaultSingletonTraits<ExtensionAssetsManagerChromeOS>;
     69 
     70   ExtensionAssetsManagerChromeOS();
     71   virtual ~ExtensionAssetsManagerChromeOS();
     72 
     73   // Should be called on UI thread to get associated file task runner for
     74   // the profile.
     75   static base::SequencedTaskRunner* GetFileTaskRunner(Profile* profile);
     76 
     77   // Return |true| if |extension| can be installed in a shared place for all
     78   // users on the device.
     79   static bool CanShareAssets(const Extension* extension,
     80                              const base::FilePath& unpacked_extension_root);
     81 
     82   // Called on the UI thread to check if a given version of the |extension|
     83   // already exists at the shared location.
     84   static void CheckSharedExtension(
     85       const std::string& id,
     86       const std::string& version,
     87       const base::FilePath& unpacked_extension_root,
     88       const base::FilePath& local_install_dir,
     89       Profile* profile,
     90       InstallExtensionCallback callback);
     91 
     92   // Called on task runner thread to install extension to shared location.
     93   static void InstallSharedExtension(
     94       const std::string& id,
     95       const std::string& version,
     96       const base::FilePath& unpacked_extension_root);
     97 
     98   // Called on UI thread to process shared install result.
     99   static void InstallSharedExtensionDone(
    100       const std::string& id,
    101       const std::string& version,
    102       const base::FilePath& shared_version_dir);
    103 
    104   // Called on task runner thread to install the extension to local dir call
    105   // callback with the result.
    106   static void InstallLocalExtension(
    107       const std::string& id,
    108       const std::string& version,
    109       const base::FilePath& unpacked_extension_root,
    110       const base::FilePath& local_install_dir,
    111       InstallExtensionCallback callback);
    112 
    113   // Called on UI thread to mark that shared version is not used.
    114   static void MarkSharedExtensionUnused(const std::string& id,
    115                                         Profile* profile);
    116 
    117   // Called on task runner thread to remove shared version.
    118   static void DeleteSharedVersion(const base::FilePath& shared_version_dir);
    119 
    120   // Clean shared extension with given |id|.
    121   static bool CleanUpExtension(
    122       const std::string& id,
    123       base::DictionaryValue* extension_info,
    124       std::multimap<std::string, base::FilePath>* live_extension_paths);
    125 
    126   DISALLOW_COPY_AND_ASSIGN(ExtensionAssetsManagerChromeOS);
    127 };
    128 
    129 }  // namespace extensions
    130 
    131 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_ASSETS_MANAGER_CHROMEOS_H_
    132