| OLD | NEW |
|---|
| (Empty) |
| 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 CHROME_BROWSER_POLICY_APP_PACK_UPDATER_H_ | |
| 6 #define CHROME_BROWSER_POLICY_APP_PACK_UPDATER_H_ | |
| 7 | |
| 8 #include <map> | |
| 9 #include <set> | |
| 10 #include <string> | |
| 11 | |
| 12 #include "base/basictypes.h" | |
| 13 #include "base/callback.h" | |
| 14 #include "base/compiler_specific.h" | |
| 15 #include "base/files/file_path.h" | |
| 16 #include "base/memory/weak_ptr.h" | |
| 17 #include "base/threading/sequenced_worker_pool.h" | |
| 18 #include "chrome/browser/extensions/updater/extension_downloader_delegate.h" | |
| 19 #include "content/public/browser/notification_observer.h" | |
| 20 #include "content/public/browser/notification_registrar.h" | |
| 21 | |
| 22 class GURL; | |
| 23 | |
| 24 namespace extensions { | |
| 25 class CrxInstaller; | |
| 26 class ExtensionDownloader; | |
| 27 class ExternalLoader; | |
| 28 } | |
| 29 | |
| 30 namespace net { | |
| 31 class URLRequestContextGetter; | |
| 32 } | |
| 33 | |
| 34 namespace tracked_objects { | |
| 35 class Location; | |
| 36 } | |
| 37 | |
| 38 namespace policy { | |
| 39 | |
| 40 class AppPackExternalLoader; | |
| 41 class EnterpriseInstallAttributes; | |
| 42 | |
| 43 // The AppPackUpdater manages a set of extensions that are configured via a | |
| 44 // device policy to be locally cached and installed into the Demo user account | |
| 45 // at login time. | |
| 46 class AppPackUpdater : public content::NotificationObserver, | |
| 47 public extensions::ExtensionDownloaderDelegate { | |
| 48 public: | |
| 49 // Callback to listen for updates to the screensaver extension's path. | |
| 50 typedef base::Callback<void(const base::FilePath&)> ScreenSaverUpdateCallback; | |
| 51 | |
| 52 // Keys for the entries in the AppPack dictionary policy. | |
| 53 static const char kExtensionId[]; | |
| 54 static const char kUpdateUrl[]; | |
| 55 | |
| 56 // The |request_context| is used for the update checks. | |
| 57 AppPackUpdater(net::URLRequestContextGetter* request_context, | |
| 58 EnterpriseInstallAttributes* install_attributes); | |
| 59 virtual ~AppPackUpdater(); | |
| 60 | |
| 61 // Creates an extensions::ExternalLoader that will load the crx files | |
| 62 // downloaded by the AppPackUpdater. This can be called at most once, and the | |
| 63 // caller owns the returned value. | |
| 64 extensions::ExternalLoader* CreateExternalLoader(); | |
| 65 | |
| 66 // |callback| will be invoked whenever the screen saver extension's path | |
| 67 // changes. It will be invoked "soon" after this call if a valid path already | |
| 68 // exists. Subsequent calls will override the previous |callback|. A null | |
| 69 // |callback| can be used to remove a previous callback. | |
| 70 void SetScreenSaverUpdateCallback(const ScreenSaverUpdateCallback& callback); | |
| 71 | |
| 72 // If a user of one of the AppPack's extensions detects that the extension | |
| 73 // is damaged then this method can be used to remove it from the cache and | |
| 74 // retry to download it after a restart. | |
| 75 void OnDamagedFileDetected(const base::FilePath& path); | |
| 76 | |
| 77 private: | |
| 78 struct CacheEntry { | |
| 79 std::string path; | |
| 80 std::string cached_version; | |
| 81 }; | |
| 82 | |
| 83 // Maps an extension ID to its update URL. | |
| 84 typedef std::map<std::string, std::string> PolicyEntryMap; | |
| 85 | |
| 86 // Maps an extension ID to a CacheEntry. | |
| 87 typedef std::map<std::string, CacheEntry> CacheEntryMap; | |
| 88 | |
| 89 void Init(); | |
| 90 | |
| 91 // content::NotificationObserver: | |
| 92 virtual void Observe(int type, | |
| 93 const content::NotificationSource& source, | |
| 94 const content::NotificationDetails& details) OVERRIDE; | |
| 95 | |
| 96 // Loads the current policy and schedules a cache update. | |
| 97 void LoadPolicy(); | |
| 98 | |
| 99 // Starts a cache update check immediately. | |
| 100 void CheckCacheNow(); | |
| 101 | |
| 102 // Performs a cache update check on the blocking pool. |app_pack_updater| is | |
| 103 // used to reply in the UI thread. |valid_ids| contains the list of IDs that | |
| 104 // are currently configured by policy; anything else is invalid, and should | |
| 105 // be removed from the cache. |valid_ids| is owned by the posted task. | |
| 106 static void BlockingCheckCache(base::WeakPtr<AppPackUpdater> app_pack_updater, | |
| 107 const std::set<std::string>* valid_ids); | |
| 108 | |
| 109 // Helper for BlockingCheckCache(). | |
| 110 static void BlockingCheckCacheInternal( | |
| 111 const std::set<std::string>* valid_ids, | |
| 112 CacheEntryMap* entries); | |
| 113 | |
| 114 // Invoked when the cache has been updated. |cache_entries| contains all the | |
| 115 // currently valid crx files in the cache, and is owned by the posted task. | |
| 116 void OnCacheUpdated(CacheEntryMap* cache_entries); | |
| 117 | |
| 118 // Notifies the |extension_loader_| that the cache has been updated, providing | |
| 119 // it with an updated list of app-pack extensions. | |
| 120 void UpdateExtensionLoader(); | |
| 121 | |
| 122 // Schedules downloads of all the extensions that are currently configured | |
| 123 // by the policy but missing in the cache. | |
| 124 void DownloadMissingExtensions(); | |
| 125 | |
| 126 // Implementation of ExtensionDownloaderDelegate: | |
| 127 | |
| 128 virtual void OnExtensionDownloadFailed( | |
| 129 const std::string& id, | |
| 130 Error error, | |
| 131 const PingResult& ping_result, | |
| 132 const std::set<int>& request_ids) OVERRIDE; | |
| 133 | |
| 134 virtual void OnExtensionDownloadFinished( | |
| 135 const std::string& id, | |
| 136 const base::FilePath& path, | |
| 137 const GURL& download_url, | |
| 138 const std::string& version, | |
| 139 const PingResult& ping_result, | |
| 140 const std::set<int>& request_ids) OVERRIDE; | |
| 141 | |
| 142 virtual void OnBlacklistDownloadFinished( | |
| 143 const std::string& data, | |
| 144 const std::string& package_hash, | |
| 145 const std::string& version, | |
| 146 const PingResult& ping_result, | |
| 147 const std::set<int>& request_ids) OVERRIDE; | |
| 148 | |
| 149 virtual bool IsExtensionPending(const std::string& id) OVERRIDE; | |
| 150 | |
| 151 virtual bool GetExtensionExistingVersion(const std::string& id, | |
| 152 std::string* version) OVERRIDE; | |
| 153 | |
| 154 // Invoked to install the downloaded crx file at |path| in the AppPack cache. | |
| 155 static void BlockingInstallCacheEntry( | |
| 156 base::WeakPtr<AppPackUpdater> app_pack_updater, | |
| 157 const std::string& id, | |
| 158 const base::FilePath& path, | |
| 159 const std::string& version); | |
| 160 | |
| 161 // Invoked on the UI thread when a new AppPack entry has been installed in | |
| 162 // the AppPack cache. | |
| 163 void OnCacheEntryInstalled(const std::string& id, | |
| 164 const std::string& path, | |
| 165 const std::string& version); | |
| 166 | |
| 167 // Handles failure to install CRX files. The file is deleted if it came from | |
| 168 // the cache. | |
| 169 void OnCrxInstallFailed(extensions::CrxInstaller* installer); | |
| 170 | |
| 171 // Helper to post blocking IO tasks to the blocking pool. | |
| 172 void PostBlockingTask(const tracked_objects::Location& from_here, | |
| 173 const base::Closure& task); | |
| 174 | |
| 175 // Sets |screen_saver_path_| and invokes |screen_saver_update_callback_| if | |
| 176 // appropriate. | |
| 177 void SetScreenSaverPath(const base::FilePath& path); | |
| 178 | |
| 179 base::WeakPtrFactory<AppPackUpdater> weak_ptr_factory_; | |
| 180 | |
| 181 // Observes failures to install CRX files. | |
| 182 content::NotificationRegistrar notification_registrar_; | |
| 183 | |
| 184 // Unique sequence token so that tasks posted by the AppPackUpdater are | |
| 185 // executed sequentially in the blocking pool. | |
| 186 base::SequencedWorkerPool::SequenceToken worker_pool_token_; | |
| 187 | |
| 188 // Whether the updater has initialized. This is only done if the device is in | |
| 189 // kiosk mode and the app pack policy is present. | |
| 190 bool initialized_; | |
| 191 | |
| 192 // This is the list of extensions currently configured by the policy. | |
| 193 PolicyEntryMap app_pack_extensions_; | |
| 194 | |
| 195 // This contains extensions that are both currently configured by the policy | |
| 196 // and that have a valid crx in the cache. | |
| 197 CacheEntryMap cached_extensions_; | |
| 198 | |
| 199 // The extension ID and path of the CRX file of the screen saver extension, | |
| 200 // if it is configured by the policy. Otherwise these fields are empty. | |
| 201 std::string screen_saver_id_; | |
| 202 base::FilePath screen_saver_path_; | |
| 203 | |
| 204 // Callback to invoke whenever the screen saver's extension path changes. | |
| 205 // Can be null. | |
| 206 ScreenSaverUpdateCallback screen_saver_update_callback_; | |
| 207 | |
| 208 // The extension loader wires the AppPackUpdater to the extensions system, and | |
| 209 // makes it install the currently cached extensions. | |
| 210 bool created_extension_loader_; | |
| 211 base::WeakPtr<AppPackExternalLoader> extension_loader_; | |
| 212 | |
| 213 // Used to download the extensions configured via policy, and to check for | |
| 214 // updates. | |
| 215 scoped_ptr<extensions::ExtensionDownloader> downloader_; | |
| 216 | |
| 217 // Request context used by the |downloader_|. | |
| 218 net::URLRequestContextGetter* request_context_; | |
| 219 | |
| 220 // For checking the device mode. | |
| 221 EnterpriseInstallAttributes* install_attributes_; | |
| 222 | |
| 223 DISALLOW_COPY_AND_ASSIGN(AppPackUpdater); | |
| 224 }; | |
| 225 | |
| 226 } // namespace policy | |
| 227 | |
| 228 #endif // CHROME_BROWSER_POLICY_APP_PACK_UPDATER_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 12189011:
Split up chrome/browser/policy subdirectory (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src