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
12template <typename T> struct DefaultSingletonTraits;
13class PrefRegistrySimple;
14
15namespace base {
16class DictionaryValue;
17class SequencedTaskRunner;
18}
19
20namespace extensions {
21
22// Chrome OS specific implementation of assets manager that shares default apps
23// between all users on the machine.
24class 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