blob: f4aa45be45b68ba4026f287d42c9a8e13ef824d2 [file] [log] [blame]
binjin5f405ef2014-09-03 21:23:161// 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#include "chrome/browser/extensions/extension_management.h"
6
dcheng1fc00f12015-12-26 22:18:037#include <utility>
binjin81d7c552014-10-02 11:47:128
binjin1569c9b2014-09-05 13:33:189#include "base/bind.h"
10#include "base/bind_helpers.h"
binjin5f405ef2014-09-03 21:23:1611#include "base/logging.h"
rkaplowdd66a1342015-03-05 00:31:4912#include "base/metrics/histogram_macros.h"
tripta.g0ac673a2017-07-07 05:45:0913#include "base/stl_util.h"
binjine6b58b52014-10-31 01:55:5714#include "base/strings/string16.h"
binjinb2454382014-09-22 15:17:4315#include "base/strings/string_util.h"
rkaplowdd66a1342015-03-05 00:31:4916#include "base/trace_event/trace_event.h"
binjin8e3d0182014-12-04 16:44:2817#include "base/version.h"
binjinb2454382014-09-22 15:17:4318#include "chrome/browser/extensions/extension_management_constants.h"
binjin81d7c552014-10-02 11:47:1219#include "chrome/browser/extensions/extension_management_internal.h"
binjin30301062014-09-08 20:27:3420#include "chrome/browser/extensions/external_policy_loader.h"
binjin5f405ef2014-09-03 21:23:1621#include "chrome/browser/extensions/external_provider_impl.h"
Sergey Poromov296de0a2018-10-11 21:44:0822#include "chrome/browser/extensions/forced_extensions/installation_failures.h"
binjine6b58b52014-10-31 01:55:5723#include "chrome/browser/extensions/permissions_based_management_policy_provider.h"
binjin1569c9b2014-09-05 13:33:1824#include "chrome/browser/extensions/standard_management_policy_provider.h"
binjin9733df12014-09-08 15:21:2125#include "chrome/browser/profiles/incognito_helpers.h"
binjin1569c9b2014-09-05 13:33:1826#include "chrome/browser/profiles/profile.h"
Owen Mina9a13e12018-11-01 20:43:5227#include "chrome/common/extensions/extension_constants.h"
28#include "chrome/common/pref_names.h"
binjin5f405ef2014-09-03 21:23:1629#include "components/crx_file/id_util.h"
binjin1569c9b2014-09-05 13:33:1830#include "components/keyed_service/content/browser_context_dependency_manager.h"
binjinb2454382014-09-22 15:17:4331#include "components/pref_registry/pref_registry_syncable.h"
brettwb1fc1b82016-02-02 00:19:0832#include "components/prefs/pref_service.h"
binjin5f405ef2014-09-03 21:23:1633#include "extensions/browser/pref_names.h"
rdevlin.cronin0670b562016-07-02 02:05:4334#include "extensions/common/extension.h"
Owen Mina9a13e12018-11-01 20:43:5235#include "extensions/common/extension_urls.h"
binjin685ade82014-11-06 09:53:5636#include "extensions/common/manifest_constants.h"
binjine6b58b52014-10-31 01:55:5737#include "extensions/common/permissions/api_permission_set.h"
38#include "extensions/common/permissions/permission_set.h"
binjin5f405ef2014-09-03 21:23:1639#include "extensions/common/url_pattern.h"
binjin311ecdf2014-09-12 22:56:5240#include "url/gurl.h"
binjin5f405ef2014-09-03 21:23:1641
achuith4607f072017-03-08 11:49:1342#if defined(OS_CHROMEOS)
43#include "chrome/browser/chromeos/profiles/profile_helper.h"
44#endif
45
binjin5f405ef2014-09-03 21:23:1646namespace extensions {
47
Sergey Poromov741e70702018-10-11 20:11:5448ExtensionManagement::ExtensionManagement(Profile* profile)
49 : profile_(profile), pref_service_(profile_->GetPrefs()) {
rkaplowdd66a1342015-03-05 00:31:4950 TRACE_EVENT0("browser,startup",
51 "ExtensionManagement::ExtensionManagement::ctor");
Sergey Poromov741e70702018-10-11 20:11:5452#if defined(OS_CHROMEOS)
53 is_signin_profile_ = chromeos::ProfileHelper::IsSigninProfile(profile);
54#endif
binjin1569c9b2014-09-05 13:33:1855 pref_change_registrar_.Init(pref_service_);
56 base::Closure pref_change_callback = base::Bind(
57 &ExtensionManagement::OnExtensionPrefChanged, base::Unretained(this));
58 pref_change_registrar_.Add(pref_names::kInstallAllowList,
59 pref_change_callback);
60 pref_change_registrar_.Add(pref_names::kInstallDenyList,
61 pref_change_callback);
62 pref_change_registrar_.Add(pref_names::kInstallForceList,
63 pref_change_callback);
achuith4607f072017-03-08 11:49:1364 pref_change_registrar_.Add(pref_names::kInstallLoginScreenAppList,
65 pref_change_callback);
binjin1569c9b2014-09-05 13:33:1866 pref_change_registrar_.Add(pref_names::kAllowedInstallSites,
67 pref_change_callback);
68 pref_change_registrar_.Add(pref_names::kAllowedTypes, pref_change_callback);
binjinb2454382014-09-22 15:17:4369 pref_change_registrar_.Add(pref_names::kExtensionManagement,
70 pref_change_callback);
Owen Mina9a13e12018-11-01 20:43:5271#if !defined(OS_CHROMEOS)
72 pref_change_registrar_.Add(prefs::kCloudReportingEnabled,
73 pref_change_callback);
74#endif
binjin81d7c552014-10-02 11:47:1275 // Note that both |global_settings_| and |default_settings_| will be null
76 // before first call to Refresh(), so in order to resolve this, Refresh() must
77 // be called in the initialization of ExtensionManagement.
binjin1569c9b2014-09-05 13:33:1878 Refresh();
lazyboy4aeef202016-09-07 21:28:5979 providers_.push_back(
Jinho Bangb5216cec2018-01-17 19:43:1180 std::make_unique<StandardManagementPolicyProvider>(this));
lazyboy4aeef202016-09-07 21:28:5981 providers_.push_back(
Jinho Bangb5216cec2018-01-17 19:43:1182 std::make_unique<PermissionsBasedManagementPolicyProvider>(this));
binjin5f405ef2014-09-03 21:23:1683}
84
85ExtensionManagement::~ExtensionManagement() {
86}
87
binjine6b58b52014-10-31 01:55:5788void ExtensionManagement::Shutdown() {
89 pref_change_registrar_.RemoveAll();
90 pref_service_ = nullptr;
91}
92
binjin1569c9b2014-09-05 13:33:1893void ExtensionManagement::AddObserver(Observer* observer) {
94 observer_list_.AddObserver(observer);
95}
96
97void ExtensionManagement::RemoveObserver(Observer* observer) {
98 observer_list_.RemoveObserver(observer);
99}
100
lazyboy4aeef202016-09-07 21:28:59101const std::vector<std::unique_ptr<ManagementPolicy::Provider>>&
102ExtensionManagement::GetProviders() const {
103 return providers_;
binjin1569c9b2014-09-05 13:33:18104}
105
binjin81d7c552014-10-02 11:47:12106bool ExtensionManagement::BlacklistedByDefault() const {
107 return default_settings_->installation_mode == INSTALLATION_BLOCKED;
108}
109
110ExtensionManagement::InstallationMode ExtensionManagement::GetInstallationMode(
binjin685ade82014-11-06 09:53:56111 const Extension* extension) const {
112 // Check per-extension installation mode setting first.
113 auto iter_id = settings_by_id_.find(extension->id());
114 if (iter_id != settings_by_id_.end())
115 return iter_id->second->installation_mode;
116 std::string update_url;
117 // Check per-update-url installation mode setting.
118 if (extension->manifest()->GetString(manifest_keys::kUpdateURL,
119 &update_url)) {
120 auto iter_update_url = settings_by_update_url_.find(update_url);
121 if (iter_update_url != settings_by_update_url_.end())
122 return iter_update_url->second->installation_mode;
123 }
124 // Fall back to default installation mode setting.
125 return default_settings_->installation_mode;
binjin1569c9b2014-09-05 13:33:18126}
127
dchengc963c7142016-04-08 03:55:22128std::unique_ptr<base::DictionaryValue>
hashimoto146e05a2016-11-18 07:42:53129ExtensionManagement::GetForceInstallList() const {
achuith4607f072017-03-08 11:49:13130 return GetInstallListByMode(INSTALLATION_FORCED);
binjincccacef2014-10-13 19:00:20131}
132
dchengc963c7142016-04-08 03:55:22133std::unique_ptr<base::DictionaryValue>
binjincccacef2014-10-13 19:00:20134ExtensionManagement::GetRecommendedInstallList() const {
achuith4607f072017-03-08 11:49:13135 return GetInstallListByMode(INSTALLATION_RECOMMENDED);
binjin30301062014-09-08 20:27:34136}
137
binjinc641add2014-10-15 16:20:45138bool ExtensionManagement::IsInstallationExplicitlyAllowed(
139 const ExtensionId& id) const {
avi3ec9c0d2016-12-27 22:38:06140 auto it = settings_by_id_.find(id);
binjinc641add2014-10-15 16:20:45141 // No settings explicitly specified for |id|.
142 if (it == settings_by_id_.end())
143 return false;
144 // Checks if the extension is on the automatically installed list or
145 // install white-list.
146 InstallationMode mode = it->second->installation_mode;
147 return mode == INSTALLATION_FORCED || mode == INSTALLATION_RECOMMENDED ||
148 mode == INSTALLATION_ALLOWED;
binjin30301062014-09-08 20:27:34149}
150
binjin81d7c552014-10-02 11:47:12151bool ExtensionManagement::IsOffstoreInstallAllowed(
152 const GURL& url,
153 const GURL& referrer_url) const {
binjin311ecdf2014-09-12 22:56:52154 // No allowed install sites specified, disallow by default.
binjin81d7c552014-10-02 11:47:12155 if (!global_settings_->has_restricted_install_sources)
binjin311ecdf2014-09-12 22:56:52156 return false;
157
binjin81d7c552014-10-02 11:47:12158 const URLPatternSet& url_patterns = global_settings_->install_sources;
binjin311ecdf2014-09-12 22:56:52159
160 if (!url_patterns.MatchesURL(url))
161 return false;
162
163 // The referrer URL must also be whitelisted, unless the URL has the file
164 // scheme (there's no referrer for those URLs).
165 return url.SchemeIsFile() || url_patterns.MatchesURL(referrer_url);
166}
167
binjin81d7c552014-10-02 11:47:12168bool ExtensionManagement::IsAllowedManifestType(
Owen Mina9a13e12018-11-01 20:43:52169 Manifest::Type manifest_type,
170 const std::string& extension_id) const {
171 if (extension_id == extension_misc::kCloudReportingExtensionId &&
172 IsCloudReportingPolicyEnabled()) {
173 return true;
174 }
175
binjin81d7c552014-10-02 11:47:12176 if (!global_settings_->has_restricted_allowed_types)
177 return true;
178 const std::vector<Manifest::Type>& allowed_types =
179 global_settings_->allowed_types;
tripta.g0ac673a2017-07-07 05:45:09180 return base::ContainsValue(allowed_types, manifest_type);
binjin1569c9b2014-09-05 13:33:18181}
182
binjin685ade82014-11-06 09:53:56183APIPermissionSet ExtensionManagement::GetBlockedAPIPermissions(
184 const Extension* extension) const {
Owen Mina9a13e12018-11-01 20:43:52185 // The Chrome Reporting extension is sideloaded via the CloudReportingEnabled
186 // policy and is not subject to permission withholding.
187 if (extension->id() == extension_misc::kCloudReportingExtensionId &&
188 IsCloudReportingPolicyEnabled()) {
189 return APIPermissionSet();
190 }
191
binjin685ade82014-11-06 09:53:56192 // Fetch per-extension blocked permissions setting.
193 auto iter_id = settings_by_id_.find(extension->id());
194
195 // Fetch per-update-url blocked permissions setting.
196 std::string update_url;
197 auto iter_update_url = settings_by_update_url_.end();
198 if (extension->manifest()->GetString(manifest_keys::kUpdateURL,
199 &update_url)) {
200 iter_update_url = settings_by_update_url_.find(update_url);
201 }
202
203 if (iter_id != settings_by_id_.end() &&
204 iter_update_url != settings_by_update_url_.end()) {
205 // Blocked permissions setting are specified in both per-extension and
206 // per-update-url settings, try to merge them.
207 APIPermissionSet merged;
208 APIPermissionSet::Union(iter_id->second->blocked_permissions,
209 iter_update_url->second->blocked_permissions,
210 &merged);
211 return merged;
212 }
213 // Check whether if in one of them, setting is specified.
214 if (iter_id != settings_by_id_.end())
Devlin Cronin32708b02018-12-05 17:58:04215 return iter_id->second->blocked_permissions.Clone();
binjin685ade82014-11-06 09:53:56216 if (iter_update_url != settings_by_update_url_.end())
Devlin Cronin32708b02018-12-05 17:58:04217 return iter_update_url->second->blocked_permissions.Clone();
binjin685ade82014-11-06 09:53:56218 // Fall back to the default blocked permissions setting.
Devlin Cronin32708b02018-12-05 17:58:04219 return default_settings_->blocked_permissions.Clone();
binjine6b58b52014-10-31 01:55:57220}
221
Devlin Cronin7e0f41ff2018-05-16 17:19:36222const URLPatternSet& ExtensionManagement::GetDefaultPolicyBlockedHosts() const {
223 return default_settings_->policy_blocked_hosts;
nrpetere33d2a5b2017-04-25 00:12:31224}
225
Devlin Cronin7e0f41ff2018-05-16 17:19:36226const URLPatternSet& ExtensionManagement::GetDefaultPolicyAllowedHosts() const {
227 return default_settings_->policy_allowed_hosts;
nrpetere33d2a5b2017-04-25 00:12:31228}
229
Devlin Cronin7e0f41ff2018-05-16 17:19:36230const URLPatternSet& ExtensionManagement::GetPolicyBlockedHosts(
nrpeter40e16382017-04-13 17:34:58231 const Extension* extension) const {
232 auto iter_id = settings_by_id_.find(extension->id());
233 if (iter_id != settings_by_id_.end())
Devlin Cronin7e0f41ff2018-05-16 17:19:36234 return iter_id->second->policy_blocked_hosts;
235 return default_settings_->policy_blocked_hosts;
nrpeter40e16382017-04-13 17:34:58236}
237
Devlin Cronin7e0f41ff2018-05-16 17:19:36238const URLPatternSet& ExtensionManagement::GetPolicyAllowedHosts(
nrpeter40e16382017-04-13 17:34:58239 const Extension* extension) const {
240 auto iter_id = settings_by_id_.find(extension->id());
241 if (iter_id != settings_by_id_.end())
Devlin Cronin7e0f41ff2018-05-16 17:19:36242 return iter_id->second->policy_allowed_hosts;
243 return default_settings_->policy_allowed_hosts;
nrpeter40e16382017-04-13 17:34:58244}
245
Devlin Cronin7e0f41ff2018-05-16 17:19:36246bool ExtensionManagement::UsesDefaultPolicyHostRestrictions(
nrpetere33d2a5b2017-04-25 00:12:31247 const Extension* extension) const {
248 return settings_by_id_.find(extension->id()) == settings_by_id_.end();
249}
250
Devlin Cronin7e0f41ff2018-05-16 17:19:36251bool ExtensionManagement::IsPolicyBlockedHost(const Extension* extension,
252 const GURL& url) const {
nrpeter40e16382017-04-13 17:34:58253 auto iter_id = settings_by_id_.find(extension->id());
254 if (iter_id != settings_by_id_.end())
Devlin Cronin7e0f41ff2018-05-16 17:19:36255 return iter_id->second->policy_blocked_hosts.MatchesURL(url);
256 return default_settings_->policy_blocked_hosts.MatchesURL(url);
nrpeter40e16382017-04-13 17:34:58257}
258
dchengc963c7142016-04-08 03:55:22259std::unique_ptr<const PermissionSet> ExtensionManagement::GetBlockedPermissions(
binjin685ade82014-11-06 09:53:56260 const Extension* extension) const {
binjine6b58b52014-10-31 01:55:57261 // Only api permissions are supported currently.
dchengc963c7142016-04-08 03:55:22262 return std::unique_ptr<const PermissionSet>(new PermissionSet(
binjin685ade82014-11-06 09:53:56263 GetBlockedAPIPermissions(extension), ManifestPermissionSet(),
264 URLPatternSet(), URLPatternSet()));
binjine6b58b52014-10-31 01:55:57265}
266
267bool ExtensionManagement::IsPermissionSetAllowed(
binjin685ade82014-11-06 09:53:56268 const Extension* extension,
rdevlin.cronine2d0fd02015-09-24 22:35:49269 const PermissionSet& perms) const {
vmpstrae72b082016-07-25 21:55:47270 for (auto* blocked_api : GetBlockedAPIPermissions(extension)) {
rdevlin.cronine2d0fd02015-09-24 22:35:49271 if (perms.HasAPIPermission(blocked_api->id()))
binjine6b58b52014-10-31 01:55:57272 return false;
273 }
274 return true;
275}
276
nrpeter2362e7e2017-05-10 17:21:26277const std::string ExtensionManagement::BlockedInstallMessage(
278 const ExtensionId& id) const {
279 auto iter_id = settings_by_id_.find(id);
280 if (iter_id != settings_by_id_.end())
281 return iter_id->second->blocked_install_message;
282 return default_settings_->blocked_install_message;
283}
284
binjin8e3d0182014-12-04 16:44:28285bool ExtensionManagement::CheckMinimumVersion(
286 const Extension* extension,
287 std::string* required_version) const {
288 auto iter = settings_by_id_.find(extension->id());
289 // If there are no minimum version required for |extension|, return true.
290 if (iter == settings_by_id_.end() || !iter->second->minimum_version_required)
291 return true;
Devlin Cronin03bf2d22017-12-20 08:21:05292 bool meets_requirement = extension->version().CompareTo(
293 *iter->second->minimum_version_required) >= 0;
binjin8e3d0182014-12-04 16:44:28294 // Output a human readable version string for prompting if necessary.
295 if (!meets_requirement && required_version)
296 *required_version = iter->second->minimum_version_required->GetString();
297 return meets_requirement;
298}
299
binjin5f405ef2014-09-03 21:23:16300void ExtensionManagement::Refresh() {
rkaplowdd66a1342015-03-05 00:31:49301 TRACE_EVENT0("browser,startup", "ExtensionManagement::Refresh");
302 SCOPED_UMA_HISTOGRAM_TIMER("Extensions.ExtensionManagement_RefreshTime");
binjin5f405ef2014-09-03 21:23:16303 // Load all extension management settings preferences.
304 const base::ListValue* allowed_list_pref =
305 static_cast<const base::ListValue*>(LoadPreference(
jdoerriedc72ee942016-12-07 15:43:28306 pref_names::kInstallAllowList, true, base::Value::Type::LIST));
binjin5f405ef2014-09-03 21:23:16307 // Allow user to use preference to block certain extensions. Note that policy
308 // managed forcelist or whitelist will always override this.
309 const base::ListValue* denied_list_pref =
310 static_cast<const base::ListValue*>(LoadPreference(
jdoerriedc72ee942016-12-07 15:43:28311 pref_names::kInstallDenyList, false, base::Value::Type::LIST));
binjin5f405ef2014-09-03 21:23:16312 const base::DictionaryValue* forced_list_pref =
313 static_cast<const base::DictionaryValue*>(LoadPreference(
jdoerriedc72ee942016-12-07 15:43:28314 pref_names::kInstallForceList, true, base::Value::Type::DICTIONARY));
achuith4607f072017-03-08 11:49:13315 const base::DictionaryValue* login_screen_app_list_pref = nullptr;
316 if (is_signin_profile_) {
317 login_screen_app_list_pref = static_cast<const base::DictionaryValue*>(
318 LoadPreference(pref_names::kInstallLoginScreenAppList, true,
319 base::Value::Type::DICTIONARY));
320 }
binjin5f405ef2014-09-03 21:23:16321 const base::ListValue* install_sources_pref =
322 static_cast<const base::ListValue*>(LoadPreference(
jdoerriedc72ee942016-12-07 15:43:28323 pref_names::kAllowedInstallSites, true, base::Value::Type::LIST));
binjin5f405ef2014-09-03 21:23:16324 const base::ListValue* allowed_types_pref =
325 static_cast<const base::ListValue*>(LoadPreference(
jdoerriedc72ee942016-12-07 15:43:28326 pref_names::kAllowedTypes, true, base::Value::Type::LIST));
binjinb2454382014-09-22 15:17:43327 const base::DictionaryValue* dict_pref =
328 static_cast<const base::DictionaryValue*>(
329 LoadPreference(pref_names::kExtensionManagement,
330 true,
jdoerriedc72ee942016-12-07 15:43:28331 base::Value::Type::DICTIONARY));
binjin5f405ef2014-09-03 21:23:16332
333 // Reset all settings.
binjin81d7c552014-10-02 11:47:12334 global_settings_.reset(new internal::GlobalSettings());
binjin5f405ef2014-09-03 21:23:16335 settings_by_id_.clear();
binjin81d7c552014-10-02 11:47:12336 default_settings_.reset(new internal::IndividualSettings());
binjin5f405ef2014-09-03 21:23:16337
338 // Parse default settings.
jdoerrie122c4da2017-03-06 11:12:04339 const base::Value wildcard("*");
binjin5f405ef2014-09-03 21:23:16340 if (denied_list_pref &&
341 denied_list_pref->Find(wildcard) != denied_list_pref->end()) {
binjin81d7c552014-10-02 11:47:12342 default_settings_->installation_mode = INSTALLATION_BLOCKED;
binjin5f405ef2014-09-03 21:23:16343 }
344
binjinb2454382014-09-22 15:17:43345 const base::DictionaryValue* subdict = NULL;
346 if (dict_pref &&
347 dict_pref->GetDictionary(schema_constants::kWildcard, &subdict)) {
binjin81d7c552014-10-02 11:47:12348 if (!default_settings_->Parse(
349 subdict, internal::IndividualSettings::SCOPE_DEFAULT)) {
binjinb2454382014-09-22 15:17:43350 LOG(WARNING) << "Default extension management settings parsing error.";
binjin81d7c552014-10-02 11:47:12351 default_settings_->Reset();
binjinb2454382014-09-22 15:17:43352 }
353
354 // Settings from new preference have higher priority over legacy ones.
355 const base::ListValue* list_value = NULL;
356 if (subdict->GetList(schema_constants::kInstallSources, &list_value))
357 install_sources_pref = list_value;
358 if (subdict->GetList(schema_constants::kAllowedTypes, &list_value))
359 allowed_types_pref = list_value;
360 }
361
binjin5f405ef2014-09-03 21:23:16362 // Parse legacy preferences.
363 ExtensionId id;
364
365 if (allowed_list_pref) {
jdoerrie13cd648c82018-10-02 21:21:02366 for (auto it = allowed_list_pref->begin(); it != allowed_list_pref->end();
367 ++it) {
jdoerriea5676c62017-04-11 18:09:14368 if (it->GetAsString(&id) && crx_file::id_util::IdIsValid(id))
binjin5f405ef2014-09-03 21:23:16369 AccessById(id)->installation_mode = INSTALLATION_ALLOWED;
370 }
371 }
372
373 if (denied_list_pref) {
jdoerrie13cd648c82018-10-02 21:21:02374 for (auto it = denied_list_pref->begin(); it != denied_list_pref->end();
375 ++it) {
jdoerriea5676c62017-04-11 18:09:14376 if (it->GetAsString(&id) && crx_file::id_util::IdIsValid(id))
binjin5f405ef2014-09-03 21:23:16377 AccessById(id)->installation_mode = INSTALLATION_BLOCKED;
378 }
379 }
380
achuith4607f072017-03-08 11:49:13381 UpdateForcedExtensions(forced_list_pref);
382 UpdateForcedExtensions(login_screen_app_list_pref);
binjin5f405ef2014-09-03 21:23:16383
384 if (install_sources_pref) {
binjin81d7c552014-10-02 11:47:12385 global_settings_->has_restricted_install_sources = true;
jdoerrie13cd648c82018-10-02 21:21:02386 for (auto it = install_sources_pref->begin();
binjin5f405ef2014-09-03 21:23:16387 it != install_sources_pref->end(); ++it) {
binjinb2454382014-09-22 15:17:43388 std::string url_pattern;
jdoerriea5676c62017-04-11 18:09:14389 if (it->GetAsString(&url_pattern)) {
binjinb2454382014-09-22 15:17:43390 URLPattern entry(URLPattern::SCHEME_ALL);
Devlin Croninbd7f2b5fa2018-09-05 17:41:18391 if (entry.Parse(url_pattern) == URLPattern::ParseResult::kSuccess) {
binjin81d7c552014-10-02 11:47:12392 global_settings_->install_sources.AddPattern(entry);
binjin5f405ef2014-09-03 21:23:16393 } else {
394 LOG(WARNING) << "Invalid URL pattern in for preference "
395 << pref_names::kAllowedInstallSites << ": "
396 << url_pattern << ".";
397 }
398 }
399 }
400 }
401
402 if (allowed_types_pref) {
binjin81d7c552014-10-02 11:47:12403 global_settings_->has_restricted_allowed_types = true;
jdoerrie13cd648c82018-10-02 21:21:02404 for (auto it = allowed_types_pref->begin(); it != allowed_types_pref->end();
405 ++it) {
binjin5f405ef2014-09-03 21:23:16406 int int_value;
binjinb2454382014-09-22 15:17:43407 std::string string_value;
jdoerriea5676c62017-04-11 18:09:14408 if (it->GetAsInteger(&int_value) && int_value >= 0 &&
binjin5f405ef2014-09-03 21:23:16409 int_value < Manifest::Type::NUM_LOAD_TYPES) {
binjin81d7c552014-10-02 11:47:12410 global_settings_->allowed_types.push_back(
binjin5f405ef2014-09-03 21:23:16411 static_cast<Manifest::Type>(int_value));
jdoerriea5676c62017-04-11 18:09:14412 } else if (it->GetAsString(&string_value)) {
binjinb2454382014-09-22 15:17:43413 Manifest::Type manifest_type =
414 schema_constants::GetManifestType(string_value);
415 if (manifest_type != Manifest::TYPE_UNKNOWN)
binjin81d7c552014-10-02 11:47:12416 global_settings_->allowed_types.push_back(manifest_type);
binjin5f405ef2014-09-03 21:23:16417 }
418 }
419 }
420
binjinb2454382014-09-22 15:17:43421 if (dict_pref) {
422 // Parse new extension management preference.
423 for (base::DictionaryValue::Iterator iter(*dict_pref); !iter.IsAtEnd();
424 iter.Advance()) {
425 if (iter.key() == schema_constants::kWildcard)
426 continue;
binjin81d7c552014-10-02 11:47:12427 if (!iter.value().GetAsDictionary(&subdict))
binjinb2454382014-09-22 15:17:43428 continue;
brettw66d1b81b2015-07-06 19:29:40429 if (base::StartsWith(iter.key(), schema_constants::kUpdateUrlPrefix,
430 base::CompareCase::SENSITIVE)) {
binjin685ade82014-11-06 09:53:56431 const std::string& update_url =
432 iter.key().substr(strlen(schema_constants::kUpdateUrlPrefix));
433 if (!GURL(update_url).is_valid()) {
434 LOG(WARNING) << "Invalid update URL: " << update_url << ".";
435 continue;
436 }
437 internal::IndividualSettings* by_update_url =
438 AccessByUpdateUrl(update_url);
439 if (!by_update_url->Parse(
440 subdict, internal::IndividualSettings::SCOPE_UPDATE_URL)) {
441 settings_by_update_url_.erase(update_url);
442 LOG(WARNING) << "Malformed Extension Management settings for "
443 "extensions with update url: " << update_url << ".";
444 }
445 } else {
446 const std::string& extension_id = iter.key();
447 if (!crx_file::id_util::IdIsValid(extension_id)) {
448 LOG(WARNING) << "Invalid extension ID : " << extension_id << ".";
449 continue;
450 }
451 internal::IndividualSettings* by_id = AccessById(extension_id);
452 if (!by_id->Parse(subdict,
453 internal::IndividualSettings::SCOPE_INDIVIDUAL)) {
454 settings_by_id_.erase(extension_id);
Sergey Poromov296de0a2018-10-11 21:44:08455 InstallationFailures::ReportFailure(
456 profile_, extension_id,
457 InstallationFailures::Reason::MALFORMED_EXTENSION_SETTINGS);
binjin685ade82014-11-06 09:53:56458 LOG(WARNING) << "Malformed Extension Management settings for "
459 << extension_id << ".";
460 }
binjinb2454382014-09-22 15:17:43461 }
462 }
463 }
Owen Mina9a13e12018-11-01 20:43:52464
465 UpdateForcedCloudReportingExtension();
binjin5f405ef2014-09-03 21:23:16466}
467
binjin5f405ef2014-09-03 21:23:16468const base::Value* ExtensionManagement::LoadPreference(
469 const char* pref_name,
470 bool force_managed,
Owen Mina9a13e12018-11-01 20:43:52471 base::Value::Type expected_type) const {
binjine6b58b52014-10-31 01:55:57472 if (!pref_service_)
473 return nullptr;
binjin5f405ef2014-09-03 21:23:16474 const PrefService::Preference* pref =
475 pref_service_->FindPreference(pref_name);
476 if (pref && !pref->IsDefaultValue() &&
477 (!force_managed || pref->IsManaged())) {
478 const base::Value* value = pref->GetValue();
jdoerrie1f536b22017-10-23 17:15:11479 if (value && value->type() == expected_type)
binjin5f405ef2014-09-03 21:23:16480 return value;
481 }
binjine6b58b52014-10-31 01:55:57482 return nullptr;
binjin5f405ef2014-09-03 21:23:16483}
484
binjin1569c9b2014-09-05 13:33:18485void ExtensionManagement::OnExtensionPrefChanged() {
486 Refresh();
487 NotifyExtensionManagementPrefChanged();
488}
489
490void ExtensionManagement::NotifyExtensionManagementPrefChanged() {
ericwilligersb5f79de2016-10-19 04:15:10491 for (auto& observer : observer_list_)
492 observer.OnExtensionManagementSettingsChanged();
binjin1569c9b2014-09-05 13:33:18493}
494
achuith4607f072017-03-08 11:49:13495std::unique_ptr<base::DictionaryValue>
496ExtensionManagement::GetInstallListByMode(
497 InstallationMode installation_mode) const {
Jinho Bangb5216cec2018-01-17 19:43:11498 auto extension_dict = std::make_unique<base::DictionaryValue>();
achuith4607f072017-03-08 11:49:13499 for (const auto& entry : settings_by_id_) {
500 if (entry.second->installation_mode == installation_mode) {
501 ExternalPolicyLoader::AddExtension(extension_dict.get(), entry.first,
502 entry.second->update_url);
503 }
504 }
505 return extension_dict;
506}
507
508void ExtensionManagement::UpdateForcedExtensions(
509 const base::DictionaryValue* extension_dict) {
510 if (!extension_dict)
511 return;
512
513 std::string update_url;
514 for (base::DictionaryValue::Iterator it(*extension_dict); !it.IsAtEnd();
515 it.Advance()) {
Sergey Poromov296de0a2018-10-11 21:44:08516 if (!crx_file::id_util::IdIsValid(it.key())) {
517 InstallationFailures::ReportFailure(
518 profile_, it.key(), InstallationFailures::Reason::INVALID_ID);
achuith4607f072017-03-08 11:49:13519 continue;
Sergey Poromov296de0a2018-10-11 21:44:08520 }
achuith4607f072017-03-08 11:49:13521 const base::DictionaryValue* dict_value = nullptr;
522 if (it.value().GetAsDictionary(&dict_value) &&
523 dict_value->GetStringWithoutPathExpansion(
524 ExternalProviderImpl::kExternalUpdateUrl, &update_url)) {
525 internal::IndividualSettings* by_id = AccessById(it.key());
526 by_id->installation_mode = INSTALLATION_FORCED;
527 by_id->update_url = update_url;
528 }
529 }
530}
531
Owen Mina9a13e12018-11-01 20:43:52532void ExtensionManagement::UpdateForcedCloudReportingExtension() {
533 if (!IsCloudReportingPolicyEnabled())
534 return;
535
536 // Adds the Chrome Reporting extension to the force install list if
537 // CloudReportingEnabled policy is set to True. Overrides any existing setting
538 // for that extension from other policies.
539 internal::IndividualSettings* settings =
540 AccessById(extension_misc::kCloudReportingExtensionId);
541 settings->Reset();
542 settings->minimum_version_required.reset();
543 settings->installation_mode = INSTALLATION_FORCED;
544 settings->update_url = extension_urls::kChromeWebstoreUpdateURL;
545}
546
547bool ExtensionManagement::IsCloudReportingPolicyEnabled() const {
548#if !defined(OS_CHROMEOS)
549 const base::Value* policy_value =
550 LoadPreference(prefs::kCloudReportingEnabled,
551 /* force_managed = */ true, base::Value::Type::BOOLEAN);
552 return policy_value && policy_value->GetBool();
553#else
554 return false;
555#endif
556}
557
binjin81d7c552014-10-02 11:47:12558internal::IndividualSettings* ExtensionManagement::AccessById(
binjin5f405ef2014-09-03 21:23:16559 const ExtensionId& id) {
560 DCHECK(crx_file::id_util::IdIsValid(id)) << "Invalid ID: " << id;
avi3ec9c0d2016-12-27 22:38:06561 std::unique_ptr<internal::IndividualSettings>& settings = settings_by_id_[id];
562 if (!settings) {
563 settings =
Jinho Bangb5216cec2018-01-17 19:43:11564 std::make_unique<internal::IndividualSettings>(default_settings_.get());
binjin81d7c552014-10-02 11:47:12565 }
avi3ec9c0d2016-12-27 22:38:06566 return settings.get();
binjin5f405ef2014-09-03 21:23:16567}
568
binjin685ade82014-11-06 09:53:56569internal::IndividualSettings* ExtensionManagement::AccessByUpdateUrl(
570 const std::string& update_url) {
571 DCHECK(GURL(update_url).is_valid()) << "Invalid update URL: " << update_url;
avi3ec9c0d2016-12-27 22:38:06572 std::unique_ptr<internal::IndividualSettings>& settings =
573 settings_by_update_url_[update_url];
574 if (!settings) {
575 settings =
Jinho Bangb5216cec2018-01-17 19:43:11576 std::make_unique<internal::IndividualSettings>(default_settings_.get());
binjin685ade82014-11-06 09:53:56577 }
avi3ec9c0d2016-12-27 22:38:06578 return settings.get();
binjin685ade82014-11-06 09:53:56579}
580
binjin1569c9b2014-09-05 13:33:18581ExtensionManagement* ExtensionManagementFactory::GetForBrowserContext(
582 content::BrowserContext* context) {
583 return static_cast<ExtensionManagement*>(
584 GetInstance()->GetServiceForBrowserContext(context, true));
585}
586
587ExtensionManagementFactory* ExtensionManagementFactory::GetInstance() {
olli.raula36aa8be2015-09-10 11:14:22588 return base::Singleton<ExtensionManagementFactory>::get();
binjin1569c9b2014-09-05 13:33:18589}
590
591ExtensionManagementFactory::ExtensionManagementFactory()
592 : BrowserContextKeyedServiceFactory(
593 "ExtensionManagement",
594 BrowserContextDependencyManager::GetInstance()) {
595}
596
597ExtensionManagementFactory::~ExtensionManagementFactory() {
598}
599
600KeyedService* ExtensionManagementFactory::BuildServiceInstanceFor(
601 content::BrowserContext* context) const {
rkaplowdd66a1342015-03-05 00:31:49602 TRACE_EVENT0("browser,startup",
603 "ExtensionManagementFactory::BuildServiceInstanceFor");
Sergey Poromov741e70702018-10-11 20:11:54604 return new ExtensionManagement(Profile::FromBrowserContext(context));
binjin1569c9b2014-09-05 13:33:18605}
606
binjin9733df12014-09-08 15:21:21607content::BrowserContext* ExtensionManagementFactory::GetBrowserContextToUse(
608 content::BrowserContext* context) const {
609 return chrome::GetBrowserContextRedirectedInIncognito(context);
610}
611
binjinb2454382014-09-22 15:17:43612void ExtensionManagementFactory::RegisterProfilePrefs(
613 user_prefs::PrefRegistrySyncable* user_prefs) {
raymesaa608722015-04-27 03:00:25614 user_prefs->RegisterDictionaryPref(pref_names::kExtensionManagement);
binjinb2454382014-09-22 15:17:43615}
616
binjin5f405ef2014-09-03 21:23:16617} // namespace extensions