| 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 #include "chrome/browser/extensions/extension_prefs.h" | |
| 6 | |
| 7 #include <iterator> | |
| 8 | |
| 9 #include "base/command_line.h" | |
| 10 #include "base/prefs/pref_notifier.h" | |
| 11 #include "base/prefs/pref_service.h" | |
| 12 #include "base/strings/string_number_conversions.h" | |
| 13 #include "base/strings/string_util.h" | |
| 14 #include "base/value_conversions.h" | |
| 15 #include "chrome/browser/extensions/api/content_settings/content_settings_store.
h" | |
| 16 #include "chrome/browser/extensions/api/preference/preference_api.h" | |
| 17 #include "chrome/browser/extensions/extension_pref_store.h" | |
| 18 #include "chrome/browser/extensions/extension_prefs_factory.h" | |
| 19 #include "components/user_prefs/pref_registry_syncable.h" | |
| 20 #include "extensions/browser/admin_policy.h" | |
| 21 #include "extensions/browser/app_sorting.h" | |
| 22 #include "extensions/browser/event_router.h" | |
| 23 #include "extensions/browser/pref_names.h" | |
| 24 #include "extensions/common/feature_switch.h" | |
| 25 #include "extensions/common/manifest.h" | |
| 26 #include "extensions/common/permissions/permission_set.h" | |
| 27 #include "extensions/common/permissions/permissions_info.h" | |
| 28 #include "extensions/common/url_pattern.h" | |
| 29 #include "extensions/common/user_script.h" | |
| 30 #include "grit/generated_resources.h" | |
| 31 #include "ui/base/l10n/l10n_util.h" | |
| 32 | |
| 33 using base::Value; | |
| 34 using base::DictionaryValue; | |
| 35 using base::ListValue; | |
| 36 | |
| 37 namespace extensions { | |
| 38 | |
| 39 namespace { | |
| 40 | |
| 41 // Additional preferences keys, which are not needed by external clients. | |
| 42 | |
| 43 // True if this extension is running. Note this preference stops getting updated | |
| 44 // during Chrome shutdown (and won't be updated on a browser crash) and so can | |
| 45 // be used at startup to determine whether the extension was running when Chrome | |
| 46 // was last terminated. | |
| 47 const char kPrefRunning[] = "running"; | |
| 48 | |
| 49 // Whether this extension had windows when it was last running. | |
| 50 const char kIsActive[] = "is_active"; | |
| 51 | |
| 52 // Where an extension was installed from. (see Manifest::Location) | |
| 53 const char kPrefLocation[] = "location"; | |
| 54 | |
| 55 // Enabled, disabled, killed, etc. (see Extension::State) | |
| 56 const char kPrefState[] = "state"; | |
| 57 | |
| 58 // The path to the current version's manifest file. | |
| 59 const char kPrefPath[] = "path"; | |
| 60 | |
| 61 // The dictionary containing the extension's manifest. | |
| 62 const char kPrefManifest[] = "manifest"; | |
| 63 | |
| 64 // The version number. | |
| 65 const char kPrefVersion[] = "manifest.version"; | |
| 66 | |
| 67 // Indicates whether an extension is blacklisted. | |
| 68 const char kPrefBlacklist[] = "blacklist"; | |
| 69 | |
| 70 // The count of how many times we prompted the user to acknowledge an | |
| 71 // extension. | |
| 72 const char kPrefAcknowledgePromptCount[] = "ack_prompt_count"; | |
| 73 | |
| 74 // Indicates whether the user has acknowledged various types of extensions. | |
| 75 const char kPrefExternalAcknowledged[] = "ack_external"; | |
| 76 const char kPrefBlacklistAcknowledged[] = "ack_blacklist"; | |
| 77 const char kPrefWipeoutAcknowledged[] = "ack_wiped"; | |
| 78 | |
| 79 // Indicates whether the external extension was installed during the first | |
| 80 // run of this profile. | |
| 81 const char kPrefExternalInstallFirstRun[] = "external_first_run"; | |
| 82 | |
| 83 // Indicates whether to show an install warning when the user enables. | |
| 84 const char kExtensionDidEscalatePermissions[] = "install_warning_on_enable"; | |
| 85 | |
| 86 // DO NOT USE, use kPrefDisableReasons instead. | |
| 87 // Indicates whether the extension was updated while it was disabled. | |
| 88 const char kDeprecatedPrefDisableReason[] = "disable_reason"; | |
| 89 | |
| 90 // A bitmask of all the reasons an extension is disabled. | |
| 91 const char kPrefDisableReasons[] = "disable_reasons"; | |
| 92 | |
| 93 // The key for a serialized Time value indicating the start of the day (from the | |
| 94 // server's perspective) an extension last included a "ping" parameter during | |
| 95 // its update check. | |
| 96 const char kLastPingDay[] = "lastpingday"; | |
| 97 | |
| 98 // Similar to kLastPingDay, but for "active" instead of "rollcall" pings. | |
| 99 const char kLastActivePingDay[] = "last_active_pingday"; | |
| 100 | |
| 101 // A bit we use to keep track of whether we need to do an "active" ping. | |
| 102 const char kActiveBit[] = "active_bit"; | |
| 103 | |
| 104 // Path for settings specific to blacklist update. | |
| 105 const char kExtensionsBlacklistUpdate[] = "extensions.blacklistupdate"; | |
| 106 | |
| 107 // Path for the delayed install info dictionary preference. The actual string | |
| 108 // value is a legacy artifact for when delayed installs only pertained to | |
| 109 // updates that were waiting for idle. | |
| 110 const char kDelayedInstallInfo[] = "idle_install_info"; | |
| 111 | |
| 112 // Reason why the extension's install was delayed. | |
| 113 const char kDelayedInstallReason[] = "delay_install_reason"; | |
| 114 | |
| 115 // Path for the suggested page ordinal of a delayed extension install. | |
| 116 const char kPrefSuggestedPageOrdinal[] = "suggested_page_ordinal"; | |
| 117 | |
| 118 // A preference that, if true, will allow this extension to run in incognito | |
| 119 // mode. | |
| 120 const char kPrefIncognitoEnabled[] = "incognito"; | |
| 121 | |
| 122 // A preference to control whether an extension is allowed to inject script in | |
| 123 // pages with file URLs. | |
| 124 const char kPrefAllowFileAccess[] = "newAllowFileAccess"; | |
| 125 // TODO(jstritar): As part of fixing http://crbug.com/91577, we revoked all | |
| 126 // extension file access by renaming the pref. We should eventually clean up | |
| 127 // the old flag and possibly go back to that name. | |
| 128 // const char kPrefAllowFileAccessOld[] = "allowFileAccess"; | |
| 129 | |
| 130 // A preference specifying if the user dragged the app on the NTP. | |
| 131 const char kPrefUserDraggedApp[] = "user_dragged_app_ntp"; | |
| 132 | |
| 133 // Preferences that hold which permissions the user has granted the extension. | |
| 134 // We explicitly keep track of these so that extensions can contain unknown | |
| 135 // permissions, for backwards compatibility reasons, and we can still prompt | |
| 136 // the user to accept them once recognized. We store the active permission | |
| 137 // permissions because they may differ from those defined in the manifest. | |
| 138 const char kPrefActivePermissions[] = "active_permissions"; | |
| 139 const char kPrefGrantedPermissions[] = "granted_permissions"; | |
| 140 | |
| 141 // The preference names for PermissionSet values. | |
| 142 const char kPrefAPIs[] = "api"; | |
| 143 const char kPrefManifestPermissions[] = "manifest_permissions"; | |
| 144 const char kPrefExplicitHosts[] = "explicit_host"; | |
| 145 const char kPrefScriptableHosts[] = "scriptable_host"; | |
| 146 | |
| 147 // The preference names for the old granted permissions scheme. | |
| 148 const char kPrefOldGrantedFullAccess[] = "granted_permissions.full"; | |
| 149 const char kPrefOldGrantedHosts[] = "granted_permissions.host"; | |
| 150 const char kPrefOldGrantedAPIs[] = "granted_permissions.api"; | |
| 151 | |
| 152 // A preference that indicates when an extension was installed. | |
| 153 const char kPrefInstallTime[] = "install_time"; | |
| 154 | |
| 155 // A preference which saves the creation flags for extensions. | |
| 156 const char kPrefCreationFlags[] = "creation_flags"; | |
| 157 | |
| 158 // A preference that indicates whether the extension was installed from the | |
| 159 // Chrome Web Store. | |
| 160 const char kPrefFromWebStore[] = "from_webstore"; | |
| 161 | |
| 162 // A preference that indicates whether the extension was installed from a | |
| 163 // mock App created from a bookmark. | |
| 164 const char kPrefFromBookmark[] = "from_bookmark"; | |
| 165 | |
| 166 // A preference that indicates whether the extension was installed as | |
| 167 // default apps. | |
| 168 const char kPrefWasInstalledByDefault[] = "was_installed_by_default"; | |
| 169 | |
| 170 // Key for Geometry Cache preference. | |
| 171 const char kPrefGeometryCache[] = "geometry_cache"; | |
| 172 | |
| 173 // A preference that indicates when an extension is last launched. | |
| 174 const char kPrefLastLaunchTime[] = "last_launch_time"; | |
| 175 | |
| 176 // A list of installed ids and a signature. | |
| 177 const char kInstallSignature[] = "extensions.install_signature"; | |
| 178 | |
| 179 // Provider of write access to a dictionary storing extension prefs. | |
| 180 class ScopedExtensionPrefUpdate : public DictionaryPrefUpdate { | |
| 181 public: | |
| 182 ScopedExtensionPrefUpdate(PrefService* service, | |
| 183 const std::string& extension_id) : | |
| 184 DictionaryPrefUpdate(service, pref_names::kExtensions), | |
| 185 extension_id_(extension_id) {} | |
| 186 | |
| 187 virtual ~ScopedExtensionPrefUpdate() { | |
| 188 } | |
| 189 | |
| 190 // DictionaryPrefUpdate overrides: | |
| 191 virtual base::DictionaryValue* Get() OVERRIDE { | |
| 192 base::DictionaryValue* dict = DictionaryPrefUpdate::Get(); | |
| 193 base::DictionaryValue* extension = NULL; | |
| 194 if (!dict->GetDictionary(extension_id_, &extension)) { | |
| 195 // Extension pref does not exist, create it. | |
| 196 extension = new base::DictionaryValue(); | |
| 197 dict->SetWithoutPathExpansion(extension_id_, extension); | |
| 198 } | |
| 199 return extension; | |
| 200 } | |
| 201 | |
| 202 private: | |
| 203 const std::string extension_id_; | |
| 204 | |
| 205 DISALLOW_COPY_AND_ASSIGN(ScopedExtensionPrefUpdate); | |
| 206 }; | |
| 207 | |
| 208 std::string JoinPrefs(const std::string& parent, const char* child) { | |
| 209 return parent + "." + child; | |
| 210 } | |
| 211 | |
| 212 // Checks if kPrefBlacklist is set to true in the base::DictionaryValue. | |
| 213 // Return false if the value is false or kPrefBlacklist does not exist. | |
| 214 // This is used to decide if an extension is blacklisted. | |
| 215 bool IsBlacklistBitSet(const base::DictionaryValue* ext) { | |
| 216 bool bool_value; | |
| 217 return ext->GetBoolean(kPrefBlacklist, &bool_value) && bool_value; | |
| 218 } | |
| 219 | |
| 220 } // namespace | |
| 221 | |
| 222 // | |
| 223 // TimeProvider | |
| 224 // | |
| 225 | |
| 226 ExtensionPrefs::TimeProvider::TimeProvider() { | |
| 227 } | |
| 228 | |
| 229 ExtensionPrefs::TimeProvider::~TimeProvider() { | |
| 230 } | |
| 231 | |
| 232 base::Time ExtensionPrefs::TimeProvider::GetCurrentTime() const { | |
| 233 return base::Time::Now(); | |
| 234 } | |
| 235 | |
| 236 // | |
| 237 // ScopedUpdate | |
| 238 // | |
| 239 template <typename T, base::Value::Type type_enum_value> | |
| 240 ExtensionPrefs::ScopedUpdate<T, type_enum_value>::ScopedUpdate( | |
| 241 ExtensionPrefs* prefs, | |
| 242 const std::string& extension_id, | |
| 243 const std::string& key) | |
| 244 : update_(prefs->pref_service(), pref_names::kExtensions), | |
| 245 extension_id_(extension_id), | |
| 246 key_(key) { | |
| 247 DCHECK(Extension::IdIsValid(extension_id_)); | |
| 248 } | |
| 249 | |
| 250 template <typename T, base::Value::Type type_enum_value> | |
| 251 ExtensionPrefs::ScopedUpdate<T, type_enum_value>::~ScopedUpdate() { | |
| 252 } | |
| 253 | |
| 254 template <typename T, base::Value::Type type_enum_value> | |
| 255 T* ExtensionPrefs::ScopedUpdate<T, type_enum_value>::Get() { | |
| 256 base::DictionaryValue* dict = update_.Get(); | |
| 257 base::DictionaryValue* extension = NULL; | |
| 258 base::Value* key_value = NULL; | |
| 259 if (!dict->GetDictionary(extension_id_, &extension) || | |
| 260 !extension->Get(key_, &key_value)) { | |
| 261 return NULL; | |
| 262 } | |
| 263 return key_value->GetType() == type_enum_value ? | |
| 264 static_cast<T*>(key_value) : | |
| 265 NULL; | |
| 266 } | |
| 267 | |
| 268 template <typename T, base::Value::Type type_enum_value> | |
| 269 T* ExtensionPrefs::ScopedUpdate<T, type_enum_value>::Create() { | |
| 270 base::DictionaryValue* dict = update_.Get(); | |
| 271 base::DictionaryValue* extension = NULL; | |
| 272 base::Value* key_value = NULL; | |
| 273 T* value_as_t = NULL; | |
| 274 if (!dict->GetDictionary(extension_id_, &extension)) { | |
| 275 extension = new base::DictionaryValue; | |
| 276 dict->SetWithoutPathExpansion(extension_id_, extension); | |
| 277 } | |
| 278 if (!extension->Get(key_, &key_value)) { | |
| 279 value_as_t = new T; | |
| 280 extension->SetWithoutPathExpansion(key_, value_as_t); | |
| 281 } else { | |
| 282 CHECK(key_value->GetType() == type_enum_value); | |
| 283 value_as_t = static_cast<T*>(key_value); | |
| 284 } | |
| 285 return value_as_t; | |
| 286 } | |
| 287 | |
| 288 // Explicit instantiations for Dictionary and List value types. | |
| 289 template class ExtensionPrefs::ScopedUpdate<base::DictionaryValue, | |
| 290 base::Value::TYPE_DICTIONARY>; | |
| 291 template class ExtensionPrefs::ScopedUpdate<base::ListValue, | |
| 292 base::Value::TYPE_LIST>; | |
| 293 | |
| 294 // | |
| 295 // ExtensionPrefs | |
| 296 // | |
| 297 | |
| 298 // static | |
| 299 ExtensionPrefs* ExtensionPrefs::Create( | |
| 300 PrefService* prefs, | |
| 301 const base::FilePath& root_dir, | |
| 302 ExtensionPrefValueMap* extension_pref_value_map, | |
| 303 scoped_ptr<AppSorting> app_sorting, | |
| 304 bool extensions_disabled) { | |
| 305 return ExtensionPrefs::Create(prefs, | |
| 306 root_dir, | |
| 307 extension_pref_value_map, | |
| 308 app_sorting.Pass(), | |
| 309 extensions_disabled, | |
| 310 make_scoped_ptr(new TimeProvider())); | |
| 311 } | |
| 312 | |
| 313 // static | |
| 314 ExtensionPrefs* ExtensionPrefs::Create( | |
| 315 PrefService* pref_service, | |
| 316 const base::FilePath& root_dir, | |
| 317 ExtensionPrefValueMap* extension_pref_value_map, | |
| 318 scoped_ptr<AppSorting> app_sorting, | |
| 319 bool extensions_disabled, | |
| 320 scoped_ptr<TimeProvider> time_provider) { | |
| 321 return new ExtensionPrefs(pref_service, | |
| 322 root_dir, | |
| 323 extension_pref_value_map, | |
| 324 app_sorting.Pass(), | |
| 325 time_provider.Pass(), | |
| 326 extensions_disabled); | |
| 327 } | |
| 328 | |
| 329 ExtensionPrefs::~ExtensionPrefs() { | |
| 330 } | |
| 331 | |
| 332 // static | |
| 333 ExtensionPrefs* ExtensionPrefs::Get(content::BrowserContext* context) { | |
| 334 return ExtensionPrefsFactory::GetInstance()->GetForBrowserContext(context); | |
| 335 } | |
| 336 | |
| 337 static base::FilePath::StringType MakePathRelative(const base::FilePath& parent, | |
| 338 const base::FilePath& child) { | |
| 339 if (!parent.IsParent(child)) | |
| 340 return child.value(); | |
| 341 | |
| 342 base::FilePath::StringType retval = child.value().substr( | |
| 343 parent.value().length()); | |
| 344 if (base::FilePath::IsSeparator(retval[0])) | |
| 345 return retval.substr(1); | |
| 346 else | |
| 347 return retval; | |
| 348 } | |
| 349 | |
| 350 void ExtensionPrefs::MakePathsRelative() { | |
| 351 const base::DictionaryValue* dict = | |
| 352 prefs_->GetDictionary(pref_names::kExtensions); | |
| 353 if (!dict || dict->empty()) | |
| 354 return; | |
| 355 | |
| 356 // Collect all extensions ids with absolute paths in |absolute_keys|. | |
| 357 std::set<std::string> absolute_keys; | |
| 358 for (base::DictionaryValue::Iterator i(*dict); !i.IsAtEnd(); i.Advance()) { | |
| 359 const base::DictionaryValue* extension_dict = NULL; | |
| 360 if (!i.value().GetAsDictionary(&extension_dict)) | |
| 361 continue; | |
| 362 int location_value; | |
| 363 if (extension_dict->GetInteger(kPrefLocation, &location_value) && | |
| 364 Manifest::IsUnpackedLocation( | |
| 365 static_cast<Manifest::Location>(location_value))) { | |
| 366 // Unpacked extensions can have absolute paths. | |
| 367 continue; | |
| 368 } | |
| 369 base::FilePath::StringType path_string; | |
| 370 if (!extension_dict->GetString(kPrefPath, &path_string)) | |
| 371 continue; | |
| 372 base::FilePath path(path_string); | |
| 373 if (path.IsAbsolute()) | |
| 374 absolute_keys.insert(i.key()); | |
| 375 } | |
| 376 if (absolute_keys.empty()) | |
| 377 return; | |
| 378 | |
| 379 // Fix these paths. | |
| 380 DictionaryPrefUpdate update(prefs_, pref_names::kExtensions); | |
| 381 base::DictionaryValue* update_dict = update.Get(); | |
| 382 for (std::set<std::string>::iterator i = absolute_keys.begin(); | |
| 383 i != absolute_keys.end(); ++i) { | |
| 384 base::DictionaryValue* extension_dict = NULL; | |
| 385 if (!update_dict->GetDictionaryWithoutPathExpansion(*i, &extension_dict)) { | |
| 386 NOTREACHED() << "Control should never reach here for extension " << *i; | |
| 387 continue; | |
| 388 } | |
| 389 base::FilePath::StringType path_string; | |
| 390 extension_dict->GetString(kPrefPath, &path_string); | |
| 391 base::FilePath path(path_string); | |
| 392 extension_dict->SetString(kPrefPath, | |
| 393 MakePathRelative(install_directory_, path)); | |
| 394 } | |
| 395 } | |
| 396 | |
| 397 const base::DictionaryValue* ExtensionPrefs::GetExtensionPref( | |
| 398 const std::string& extension_id) const { | |
| 399 const base::DictionaryValue* extensions = | |
| 400 prefs_->GetDictionary(pref_names::kExtensions); | |
| 401 const base::DictionaryValue* extension_dict = NULL; | |
| 402 if (!extensions || | |
| 403 !extensions->GetDictionary(extension_id, &extension_dict)) { | |
| 404 return NULL; | |
| 405 } | |
| 406 return extension_dict; | |
| 407 } | |
| 408 | |
| 409 void ExtensionPrefs::UpdateExtensionPref(const std::string& extension_id, | |
| 410 const std::string& key, | |
| 411 base::Value* data_value) { | |
| 412 if (!Extension::IdIsValid(extension_id)) { | |
| 413 NOTREACHED() << "Invalid extension_id " << extension_id; | |
| 414 return; | |
| 415 } | |
| 416 ScopedExtensionPrefUpdate update(prefs_, extension_id); | |
| 417 if (data_value) | |
| 418 update->Set(key, data_value); | |
| 419 else | |
| 420 update->Remove(key, NULL); | |
| 421 } | |
| 422 | |
| 423 void ExtensionPrefs::DeleteExtensionPrefs(const std::string& extension_id) { | |
| 424 extension_pref_value_map_->UnregisterExtension(extension_id); | |
| 425 content_settings_store_->UnregisterExtension(extension_id); | |
| 426 DictionaryPrefUpdate update(prefs_, pref_names::kExtensions); | |
| 427 base::DictionaryValue* dict = update.Get(); | |
| 428 dict->Remove(extension_id, NULL); | |
| 429 } | |
| 430 | |
| 431 bool ExtensionPrefs::ReadPrefAsBoolean(const std::string& extension_id, | |
| 432 const std::string& pref_key, | |
| 433 bool* out_value) const { | |
| 434 const base::DictionaryValue* ext = GetExtensionPref(extension_id); | |
| 435 if (!ext || !ext->GetBoolean(pref_key, out_value)) | |
| 436 return false; | |
| 437 | |
| 438 return true; | |
| 439 } | |
| 440 | |
| 441 bool ExtensionPrefs::ReadPrefAsInteger(const std::string& extension_id, | |
| 442 const std::string& pref_key, | |
| 443 int* out_value) const { | |
| 444 const base::DictionaryValue* ext = GetExtensionPref(extension_id); | |
| 445 if (!ext || !ext->GetInteger(pref_key, out_value)) | |
| 446 return false; | |
| 447 | |
| 448 return true; | |
| 449 } | |
| 450 | |
| 451 bool ExtensionPrefs::ReadPrefAsString(const std::string& extension_id, | |
| 452 const std::string& pref_key, | |
| 453 std::string* out_value) const { | |
| 454 const base::DictionaryValue* ext = GetExtensionPref(extension_id); | |
| 455 if (!ext || !ext->GetString(pref_key, out_value)) | |
| 456 return false; | |
| 457 | |
| 458 return true; | |
| 459 } | |
| 460 | |
| 461 bool ExtensionPrefs::ReadPrefAsList(const std::string& extension_id, | |
| 462 const std::string& pref_key, | |
| 463 const base::ListValue** out_value) const { | |
| 464 const base::DictionaryValue* ext = GetExtensionPref(extension_id); | |
| 465 const base::ListValue* out = NULL; | |
| 466 if (!ext || !ext->GetList(pref_key, &out)) | |
| 467 return false; | |
| 468 if (out_value) | |
| 469 *out_value = out; | |
| 470 | |
| 471 return true; | |
| 472 } | |
| 473 | |
| 474 bool ExtensionPrefs::ReadPrefAsDictionary( | |
| 475 const std::string& extension_id, | |
| 476 const std::string& pref_key, | |
| 477 const base::DictionaryValue** out_value) const { | |
| 478 const base::DictionaryValue* ext = GetExtensionPref(extension_id); | |
| 479 const base::DictionaryValue* out = NULL; | |
| 480 if (!ext || !ext->GetDictionary(pref_key, &out)) | |
| 481 return false; | |
| 482 if (out_value) | |
| 483 *out_value = out; | |
| 484 | |
| 485 return true; | |
| 486 } | |
| 487 | |
| 488 bool ExtensionPrefs::HasPrefForExtension( | |
| 489 const std::string& extension_id) const { | |
| 490 return GetExtensionPref(extension_id) != NULL; | |
| 491 } | |
| 492 | |
| 493 bool ExtensionPrefs::ReadPrefAsURLPatternSet(const std::string& extension_id, | |
| 494 const std::string& pref_key, | |
| 495 URLPatternSet* result, | |
| 496 int valid_schemes) { | |
| 497 const base::ListValue* value = NULL; | |
| 498 if (!ReadPrefAsList(extension_id, pref_key, &value)) | |
| 499 return false; | |
| 500 | |
| 501 bool allow_file_access = AllowFileAccess(extension_id); | |
| 502 return result->Populate(*value, valid_schemes, allow_file_access, NULL); | |
| 503 } | |
| 504 | |
| 505 void ExtensionPrefs::SetExtensionPrefURLPatternSet( | |
| 506 const std::string& extension_id, | |
| 507 const std::string& pref_key, | |
| 508 const URLPatternSet& new_value) { | |
| 509 UpdateExtensionPref(extension_id, pref_key, new_value.ToValue().release()); | |
| 510 } | |
| 511 | |
| 512 bool ExtensionPrefs::ReadPrefAsBooleanAndReturn( | |
| 513 const std::string& extension_id, | |
| 514 const std::string& pref_key) const { | |
| 515 bool out_value = false; | |
| 516 return ReadPrefAsBoolean(extension_id, pref_key, &out_value) && out_value; | |
| 517 } | |
| 518 | |
| 519 PermissionSet* ExtensionPrefs::ReadPrefAsPermissionSet( | |
| 520 const std::string& extension_id, | |
| 521 const std::string& pref_key) { | |
| 522 if (!GetExtensionPref(extension_id)) | |
| 523 return NULL; | |
| 524 | |
| 525 // Retrieve the API permissions. Please refer SetExtensionPrefPermissionSet() | |
| 526 // for api_values format. | |
| 527 APIPermissionSet apis; | |
| 528 const base::ListValue* api_values = NULL; | |
| 529 std::string api_pref = JoinPrefs(pref_key, kPrefAPIs); | |
| 530 if (ReadPrefAsList(extension_id, api_pref, &api_values)) { | |
| 531 APIPermissionSet::ParseFromJSON(api_values, | |
| 532 APIPermissionSet::kAllowInternalPermissions, | |
| 533 &apis, NULL, NULL); | |
| 534 } | |
| 535 | |
| 536 // Retrieve the Manifest Keys permissions. Please refer to | |
| 537 // |SetExtensionPrefPermissionSet| for manifest_permissions_values format. | |
| 538 ManifestPermissionSet manifest_permissions; | |
| 539 const base::ListValue* manifest_permissions_values = NULL; | |
| 540 std::string manifest_permission_pref = | |
| 541 JoinPrefs(pref_key, kPrefManifestPermissions); | |
| 542 if (ReadPrefAsList(extension_id, manifest_permission_pref, | |
| 543 &manifest_permissions_values)) { | |
| 544 ManifestPermissionSet::ParseFromJSON( | |
| 545 manifest_permissions_values, &manifest_permissions, NULL, NULL); | |
| 546 } | |
| 547 | |
| 548 // Retrieve the explicit host permissions. | |
| 549 URLPatternSet explicit_hosts; | |
| 550 ReadPrefAsURLPatternSet( | |
| 551 extension_id, JoinPrefs(pref_key, kPrefExplicitHosts), | |
| 552 &explicit_hosts, Extension::kValidHostPermissionSchemes); | |
| 553 | |
| 554 // Retrieve the scriptable host permissions. | |
| 555 URLPatternSet scriptable_hosts; | |
| 556 ReadPrefAsURLPatternSet( | |
| 557 extension_id, JoinPrefs(pref_key, kPrefScriptableHosts), | |
| 558 &scriptable_hosts, UserScript::ValidUserScriptSchemes()); | |
| 559 | |
| 560 return new PermissionSet( | |
| 561 apis, manifest_permissions, explicit_hosts, scriptable_hosts); | |
| 562 } | |
| 563 | |
| 564 // Set the API or Manifest permissions. | |
| 565 // The format of api_values is: | |
| 566 // [ "permission_name1", // permissions do not support detail. | |
| 567 // "permission_name2", | |
| 568 // {"permission_name3": value }, | |
| 569 // // permission supports detail, permission detail will be stored in value. | |
| 570 // ... | |
| 571 // ] | |
| 572 template<typename T> | |
| 573 static base::ListValue* CreatePermissionList(const T& permissions) { | |
| 574 base::ListValue* values = new base::ListValue(); | |
| 575 for (typename T::const_iterator i = permissions.begin(); | |
| 576 i != permissions.end(); ++i) { | |
| 577 scoped_ptr<base::Value> detail(i->ToValue()); | |
| 578 if (detail) { | |
| 579 base::DictionaryValue* tmp = new base::DictionaryValue(); | |
| 580 tmp->Set(i->name(), detail.release()); | |
| 581 values->Append(tmp); | |
| 582 } else { | |
| 583 values->Append(new base::StringValue(i->name())); | |
| 584 } | |
| 585 } | |
| 586 return values; | |
| 587 } | |
| 588 | |
| 589 void ExtensionPrefs::SetExtensionPrefPermissionSet( | |
| 590 const std::string& extension_id, | |
| 591 const std::string& pref_key, | |
| 592 const PermissionSet* new_value) { | |
| 593 std::string api_pref = JoinPrefs(pref_key, kPrefAPIs); | |
| 594 base::ListValue* api_values = CreatePermissionList(new_value->apis()); | |
| 595 UpdateExtensionPref(extension_id, api_pref, api_values); | |
| 596 | |
| 597 std::string manifest_permissions_pref = | |
| 598 JoinPrefs(pref_key, kPrefManifestPermissions); | |
| 599 base::ListValue* manifest_permissions_values = CreatePermissionList( | |
| 600 new_value->manifest_permissions()); | |
| 601 UpdateExtensionPref(extension_id, | |
| 602 manifest_permissions_pref, | |
| 603 manifest_permissions_values); | |
| 604 | |
| 605 // Set the explicit host permissions. | |
| 606 if (!new_value->explicit_hosts().is_empty()) { | |
| 607 SetExtensionPrefURLPatternSet(extension_id, | |
| 608 JoinPrefs(pref_key, kPrefExplicitHosts), | |
| 609 new_value->explicit_hosts()); | |
| 610 } | |
| 611 | |
| 612 // Set the scriptable host permissions. | |
| 613 if (!new_value->scriptable_hosts().is_empty()) { | |
| 614 SetExtensionPrefURLPatternSet(extension_id, | |
| 615 JoinPrefs(pref_key, kPrefScriptableHosts), | |
| 616 new_value->scriptable_hosts()); | |
| 617 } | |
| 618 } | |
| 619 | |
| 620 int ExtensionPrefs::IncrementAcknowledgePromptCount( | |
| 621 const std::string& extension_id) { | |
| 622 int count = 0; | |
| 623 ReadPrefAsInteger(extension_id, kPrefAcknowledgePromptCount, &count); | |
| 624 ++count; | |
| 625 UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, | |
| 626 new base::FundamentalValue(count)); | |
| 627 return count; | |
| 628 } | |
| 629 | |
| 630 bool ExtensionPrefs::IsExternalExtensionAcknowledged( | |
| 631 const std::string& extension_id) { | |
| 632 return ReadPrefAsBooleanAndReturn(extension_id, kPrefExternalAcknowledged); | |
| 633 } | |
| 634 | |
| 635 void ExtensionPrefs::AcknowledgeExternalExtension( | |
| 636 const std::string& extension_id) { | |
| 637 DCHECK(Extension::IdIsValid(extension_id)); | |
| 638 UpdateExtensionPref(extension_id, kPrefExternalAcknowledged, | |
| 639 new base::FundamentalValue(true)); | |
| 640 UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, NULL); | |
| 641 } | |
| 642 | |
| 643 bool ExtensionPrefs::IsBlacklistedExtensionAcknowledged( | |
| 644 const std::string& extension_id) { | |
| 645 return ReadPrefAsBooleanAndReturn(extension_id, kPrefBlacklistAcknowledged); | |
| 646 } | |
| 647 | |
| 648 void ExtensionPrefs::AcknowledgeBlacklistedExtension( | |
| 649 const std::string& extension_id) { | |
| 650 DCHECK(Extension::IdIsValid(extension_id)); | |
| 651 UpdateExtensionPref(extension_id, kPrefBlacklistAcknowledged, | |
| 652 new base::FundamentalValue(true)); | |
| 653 UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, NULL); | |
| 654 } | |
| 655 | |
| 656 bool ExtensionPrefs::IsExternalInstallFirstRun( | |
| 657 const std::string& extension_id) { | |
| 658 return ReadPrefAsBooleanAndReturn(extension_id, kPrefExternalInstallFirstRun); | |
| 659 } | |
| 660 | |
| 661 void ExtensionPrefs::SetExternalInstallFirstRun( | |
| 662 const std::string& extension_id) { | |
| 663 DCHECK(Extension::IdIsValid(extension_id)); | |
| 664 UpdateExtensionPref(extension_id, kPrefExternalInstallFirstRun, | |
| 665 new base::FundamentalValue(true)); | |
| 666 } | |
| 667 | |
| 668 bool ExtensionPrefs::HasWipeoutBeenAcknowledged( | |
| 669 const std::string& extension_id) { | |
| 670 return ReadPrefAsBooleanAndReturn(extension_id, kPrefWipeoutAcknowledged); | |
| 671 } | |
| 672 | |
| 673 void ExtensionPrefs::SetWipeoutAcknowledged( | |
| 674 const std::string& extension_id, | |
| 675 bool value) { | |
| 676 UpdateExtensionPref(extension_id, kPrefWipeoutAcknowledged, | |
| 677 value ? base::Value::CreateBooleanValue(value) : NULL); | |
| 678 } | |
| 679 | |
| 680 bool ExtensionPrefs::SetAlertSystemFirstRun() { | |
| 681 if (prefs_->GetBoolean(pref_names::kAlertsInitialized)) { | |
| 682 return true; | |
| 683 } | |
| 684 prefs_->SetBoolean(pref_names::kAlertsInitialized, true); | |
| 685 return false; | |
| 686 } | |
| 687 | |
| 688 bool ExtensionPrefs::ExtensionsBlacklistedByDefault() const { | |
| 689 return admin_policy::BlacklistedByDefault( | |
| 690 prefs_->GetList(pref_names::kInstallDenyList)); | |
| 691 } | |
| 692 | |
| 693 bool ExtensionPrefs::DidExtensionEscalatePermissions( | |
| 694 const std::string& extension_id) { | |
| 695 return ReadPrefAsBooleanAndReturn(extension_id, | |
| 696 kExtensionDidEscalatePermissions); | |
| 697 } | |
| 698 | |
| 699 void ExtensionPrefs::SetDidExtensionEscalatePermissions( | |
| 700 const Extension* extension, bool did_escalate) { | |
| 701 UpdateExtensionPref(extension->id(), kExtensionDidEscalatePermissions, | |
| 702 new base::FundamentalValue(did_escalate)); | |
| 703 } | |
| 704 | |
| 705 int ExtensionPrefs::GetDisableReasons(const std::string& extension_id) const { | |
| 706 int value = -1; | |
| 707 if (ReadPrefAsInteger(extension_id, kPrefDisableReasons, &value) && | |
| 708 value >= 0) { | |
| 709 return value; | |
| 710 } | |
| 711 return Extension::DISABLE_NONE; | |
| 712 } | |
| 713 | |
| 714 void ExtensionPrefs::AddDisableReason(const std::string& extension_id, | |
| 715 Extension::DisableReason disable_reason) { | |
| 716 int new_value = GetDisableReasons(extension_id) | | |
| 717 static_cast<int>(disable_reason); | |
| 718 UpdateExtensionPref(extension_id, kPrefDisableReasons, | |
| 719 new base::FundamentalValue(new_value)); | |
| 720 } | |
| 721 | |
| 722 void ExtensionPrefs::RemoveDisableReason( | |
| 723 const std::string& extension_id, | |
| 724 Extension::DisableReason disable_reason) { | |
| 725 int new_value = GetDisableReasons(extension_id) & | |
| 726 ~static_cast<int>(disable_reason); | |
| 727 if (new_value == Extension::DISABLE_NONE) { | |
| 728 UpdateExtensionPref(extension_id, kPrefDisableReasons, NULL); | |
| 729 } else { | |
| 730 UpdateExtensionPref(extension_id, kPrefDisableReasons, | |
| 731 new base::FundamentalValue(new_value)); | |
| 732 } | |
| 733 } | |
| 734 | |
| 735 void ExtensionPrefs::ClearDisableReasons(const std::string& extension_id) { | |
| 736 UpdateExtensionPref(extension_id, kPrefDisableReasons, NULL); | |
| 737 } | |
| 738 | |
| 739 std::set<std::string> ExtensionPrefs::GetBlacklistedExtensions() { | |
| 740 std::set<std::string> ids; | |
| 741 | |
| 742 const base::DictionaryValue* extensions = | |
| 743 prefs_->GetDictionary(pref_names::kExtensions); | |
| 744 if (!extensions) | |
| 745 return ids; | |
| 746 | |
| 747 for (base::DictionaryValue::Iterator it(*extensions); | |
| 748 !it.IsAtEnd(); it.Advance()) { | |
| 749 if (!it.value().IsType(base::Value::TYPE_DICTIONARY)) { | |
| 750 NOTREACHED() << "Invalid pref for extension " << it.key(); | |
| 751 continue; | |
| 752 } | |
| 753 if (IsBlacklistBitSet( | |
| 754 static_cast<const base::DictionaryValue*>(&it.value()))) { | |
| 755 ids.insert(it.key()); | |
| 756 } | |
| 757 } | |
| 758 | |
| 759 return ids; | |
| 760 } | |
| 761 | |
| 762 void ExtensionPrefs::SetExtensionBlacklisted(const std::string& extension_id, | |
| 763 bool is_blacklisted) { | |
| 764 bool currently_blacklisted = IsExtensionBlacklisted(extension_id); | |
| 765 if (is_blacklisted == currently_blacklisted) { | |
| 766 NOTREACHED() << extension_id << " is " << | |
| 767 (currently_blacklisted ? "already" : "not") << | |
| 768 " blacklisted"; | |
| 769 return; | |
| 770 } | |
| 771 | |
| 772 // Always make sure the "acknowledged" bit is cleared since the blacklist bit | |
| 773 // is changing. | |
| 774 UpdateExtensionPref(extension_id, kPrefBlacklistAcknowledged, NULL); | |
| 775 | |
| 776 if (is_blacklisted) { | |
| 777 UpdateExtensionPref(extension_id, | |
| 778 kPrefBlacklist, | |
| 779 new base::FundamentalValue(true)); | |
| 780 } else { | |
| 781 UpdateExtensionPref(extension_id, kPrefBlacklist, NULL); | |
| 782 const base::DictionaryValue* dict = GetExtensionPref(extension_id); | |
| 783 if (dict && dict->empty()) | |
| 784 DeleteExtensionPrefs(extension_id); | |
| 785 } | |
| 786 } | |
| 787 | |
| 788 bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& id) const { | |
| 789 const base::DictionaryValue* ext_prefs = GetExtensionPref(id); | |
| 790 return ext_prefs && IsBlacklistBitSet(ext_prefs); | |
| 791 } | |
| 792 | |
| 793 namespace { | |
| 794 | |
| 795 // Serializes |time| as a string value mapped to |key| in |dictionary|. | |
| 796 void SaveTime(base::DictionaryValue* dictionary, | |
| 797 const char* key, | |
| 798 const base::Time& time) { | |
| 799 if (!dictionary) | |
| 800 return; | |
| 801 std::string string_value = base::Int64ToString(time.ToInternalValue()); | |
| 802 dictionary->SetString(key, string_value); | |
| 803 } | |
| 804 | |
| 805 // The opposite of SaveTime. If |key| is not found, this returns an empty Time | |
| 806 // (is_null() will return true). | |
| 807 base::Time ReadTime(const base::DictionaryValue* dictionary, const char* key) { | |
| 808 if (!dictionary) | |
| 809 return base::Time(); | |
| 810 std::string string_value; | |
| 811 int64 value; | |
| 812 if (dictionary->GetString(key, &string_value)) { | |
| 813 if (base::StringToInt64(string_value, &value)) { | |
| 814 return base::Time::FromInternalValue(value); | |
| 815 } | |
| 816 } | |
| 817 return base::Time(); | |
| 818 } | |
| 819 | |
| 820 } // namespace | |
| 821 | |
| 822 base::Time ExtensionPrefs::LastPingDay(const std::string& extension_id) const { | |
| 823 DCHECK(Extension::IdIsValid(extension_id)); | |
| 824 return ReadTime(GetExtensionPref(extension_id), kLastPingDay); | |
| 825 } | |
| 826 | |
| 827 void ExtensionPrefs::SetLastPingDay(const std::string& extension_id, | |
| 828 const base::Time& time) { | |
| 829 DCHECK(Extension::IdIsValid(extension_id)); | |
| 830 ScopedExtensionPrefUpdate update(prefs_, extension_id); | |
| 831 SaveTime(update.Get(), kLastPingDay, time); | |
| 832 } | |
| 833 | |
| 834 base::Time ExtensionPrefs::BlacklistLastPingDay() const { | |
| 835 return ReadTime(prefs_->GetDictionary(kExtensionsBlacklistUpdate), | |
| 836 kLastPingDay); | |
| 837 } | |
| 838 | |
| 839 void ExtensionPrefs::SetBlacklistLastPingDay(const base::Time& time) { | |
| 840 DictionaryPrefUpdate update(prefs_, kExtensionsBlacklistUpdate); | |
| 841 SaveTime(update.Get(), kLastPingDay, time); | |
| 842 } | |
| 843 | |
| 844 base::Time ExtensionPrefs::LastActivePingDay(const std::string& extension_id) { | |
| 845 DCHECK(Extension::IdIsValid(extension_id)); | |
| 846 return ReadTime(GetExtensionPref(extension_id), kLastActivePingDay); | |
| 847 } | |
| 848 | |
| 849 void ExtensionPrefs::SetLastActivePingDay(const std::string& extension_id, | |
| 850 const base::Time& time) { | |
| 851 DCHECK(Extension::IdIsValid(extension_id)); | |
| 852 ScopedExtensionPrefUpdate update(prefs_, extension_id); | |
| 853 SaveTime(update.Get(), kLastActivePingDay, time); | |
| 854 } | |
| 855 | |
| 856 bool ExtensionPrefs::GetActiveBit(const std::string& extension_id) { | |
| 857 const base::DictionaryValue* dictionary = GetExtensionPref(extension_id); | |
| 858 bool result = false; | |
| 859 if (dictionary && dictionary->GetBoolean(kActiveBit, &result)) | |
| 860 return result; | |
| 861 return false; | |
| 862 } | |
| 863 | |
| 864 void ExtensionPrefs::SetActiveBit(const std::string& extension_id, | |
| 865 bool active) { | |
| 866 UpdateExtensionPref(extension_id, kActiveBit, | |
| 867 new base::FundamentalValue(active)); | |
| 868 } | |
| 869 | |
| 870 void ExtensionPrefs::MigratePermissions(const ExtensionIdList& extension_ids) { | |
| 871 PermissionsInfo* info = PermissionsInfo::GetInstance(); | |
| 872 for (ExtensionIdList::const_iterator ext_id = | |
| 873 extension_ids.begin(); ext_id != extension_ids.end(); ++ext_id) { | |
| 874 | |
| 875 // An extension's granted permissions need to be migrated if the | |
| 876 // full_access bit is present. This bit was always present in the previous | |
| 877 // scheme and is never present now. | |
| 878 bool full_access; | |
| 879 const base::DictionaryValue* ext = GetExtensionPref(*ext_id); | |
| 880 if (!ext || !ext->GetBoolean(kPrefOldGrantedFullAccess, &full_access)) | |
| 881 continue; | |
| 882 | |
| 883 // Remove the full access bit (empty list will get trimmed). | |
| 884 UpdateExtensionPref( | |
| 885 *ext_id, kPrefOldGrantedFullAccess, new base::ListValue()); | |
| 886 | |
| 887 // Add the plugin permission if the full access bit was set. | |
| 888 if (full_access) { | |
| 889 const base::ListValue* apis = NULL; | |
| 890 base::ListValue* new_apis = NULL; | |
| 891 | |
| 892 std::string granted_apis = | |
| 893 JoinPrefs(kPrefGrantedPermissions, kPrefAPIs); | |
| 894 if (ext->GetList(kPrefOldGrantedAPIs, &apis)) | |
| 895 new_apis = apis->DeepCopy(); | |
| 896 else | |
| 897 new_apis = new base::ListValue(); | |
| 898 | |
| 899 std::string plugin_name = info->GetByID( | |
| 900 APIPermission::kPlugin)->name(); | |
| 901 new_apis->Append(new base::StringValue(plugin_name)); | |
| 902 UpdateExtensionPref(*ext_id, granted_apis, new_apis); | |
| 903 } | |
| 904 | |
| 905 // The granted permissions originally only held the effective hosts, | |
| 906 // which are a combination of host and user script host permissions. | |
| 907 // We now maintain these lists separately. For migration purposes, it | |
| 908 // does not matter how we treat the old effective hosts as long as the | |
| 909 // new effective hosts will be the same, so we move them to explicit | |
| 910 // host permissions. | |
| 911 const base::ListValue* hosts = NULL; | |
| 912 std::string explicit_hosts = | |
| 913 JoinPrefs(kPrefGrantedPermissions, kPrefExplicitHosts); | |
| 914 if (ext->GetList(kPrefOldGrantedHosts, &hosts)) { | |
| 915 UpdateExtensionPref( | |
| 916 *ext_id, explicit_hosts, hosts->DeepCopy()); | |
| 917 | |
| 918 // We can get rid of the old one by setting it to an empty list. | |
| 919 UpdateExtensionPref(*ext_id, kPrefOldGrantedHosts, new base::ListValue()); | |
| 920 } | |
| 921 } | |
| 922 } | |
| 923 | |
| 924 void ExtensionPrefs::MigrateDisableReasons( | |
| 925 const ExtensionIdList& extension_ids) { | |
| 926 for (ExtensionIdList::const_iterator ext_id = | |
| 927 extension_ids.begin(); ext_id != extension_ids.end(); ++ext_id) { | |
| 928 int value = -1; | |
| 929 if (ReadPrefAsInteger(*ext_id, kDeprecatedPrefDisableReason, &value)) { | |
| 930 int new_value = Extension::DISABLE_NONE; | |
| 931 switch (value) { | |
| 932 case Extension::DEPRECATED_DISABLE_USER_ACTION: | |
| 933 new_value = Extension::DISABLE_USER_ACTION; | |
| 934 break; | |
| 935 case Extension::DEPRECATED_DISABLE_PERMISSIONS_INCREASE: | |
| 936 new_value = Extension::DISABLE_PERMISSIONS_INCREASE; | |
| 937 break; | |
| 938 case Extension::DEPRECATED_DISABLE_RELOAD: | |
| 939 new_value = Extension::DISABLE_RELOAD; | |
| 940 break; | |
| 941 } | |
| 942 | |
| 943 UpdateExtensionPref(*ext_id, kPrefDisableReasons, | |
| 944 new base::FundamentalValue(new_value)); | |
| 945 // Remove the old disable reason. | |
| 946 UpdateExtensionPref(*ext_id, kDeprecatedPrefDisableReason, NULL); | |
| 947 } | |
| 948 } | |
| 949 } | |
| 950 | |
| 951 PermissionSet* ExtensionPrefs::GetGrantedPermissions( | |
| 952 const std::string& extension_id) { | |
| 953 CHECK(Extension::IdIsValid(extension_id)); | |
| 954 return ReadPrefAsPermissionSet(extension_id, kPrefGrantedPermissions); | |
| 955 } | |
| 956 | |
| 957 void ExtensionPrefs::AddGrantedPermissions( | |
| 958 const std::string& extension_id, | |
| 959 const PermissionSet* permissions) { | |
| 960 CHECK(Extension::IdIsValid(extension_id)); | |
| 961 | |
| 962 scoped_refptr<PermissionSet> granted_permissions( | |
| 963 GetGrantedPermissions(extension_id)); | |
| 964 | |
| 965 // The new granted permissions are the union of the already granted | |
| 966 // permissions and the newly granted permissions. | |
| 967 scoped_refptr<PermissionSet> new_perms( | |
| 968 PermissionSet::CreateUnion( | |
| 969 permissions, granted_permissions.get())); | |
| 970 | |
| 971 SetExtensionPrefPermissionSet( | |
| 972 extension_id, kPrefGrantedPermissions, new_perms.get()); | |
| 973 } | |
| 974 | |
| 975 void ExtensionPrefs::RemoveGrantedPermissions( | |
| 976 const std::string& extension_id, | |
| 977 const PermissionSet* permissions) { | |
| 978 CHECK(Extension::IdIsValid(extension_id)); | |
| 979 | |
| 980 scoped_refptr<PermissionSet> granted_permissions( | |
| 981 GetGrantedPermissions(extension_id)); | |
| 982 | |
| 983 // The new granted permissions are the difference of the already granted | |
| 984 // permissions and the newly ungranted permissions. | |
| 985 scoped_refptr<PermissionSet> new_perms( | |
| 986 PermissionSet::CreateDifference( | |
| 987 granted_permissions.get(), permissions)); | |
| 988 | |
| 989 SetExtensionPrefPermissionSet( | |
| 990 extension_id, kPrefGrantedPermissions, new_perms.get()); | |
| 991 } | |
| 992 | |
| 993 PermissionSet* ExtensionPrefs::GetActivePermissions( | |
| 994 const std::string& extension_id) { | |
| 995 CHECK(Extension::IdIsValid(extension_id)); | |
| 996 return ReadPrefAsPermissionSet(extension_id, kPrefActivePermissions); | |
| 997 } | |
| 998 | |
| 999 void ExtensionPrefs::SetActivePermissions( | |
| 1000 const std::string& extension_id, | |
| 1001 const PermissionSet* permissions) { | |
| 1002 SetExtensionPrefPermissionSet( | |
| 1003 extension_id, kPrefActivePermissions, permissions); | |
| 1004 } | |
| 1005 | |
| 1006 void ExtensionPrefs::SetExtensionRunning(const std::string& extension_id, | |
| 1007 bool is_running) { | |
| 1008 base::Value* value = new base::FundamentalValue(is_running); | |
| 1009 UpdateExtensionPref(extension_id, kPrefRunning, value); | |
| 1010 } | |
| 1011 | |
| 1012 bool ExtensionPrefs::IsExtensionRunning(const std::string& extension_id) { | |
| 1013 const base::DictionaryValue* extension = GetExtensionPref(extension_id); | |
| 1014 if (!extension) | |
| 1015 return false; | |
| 1016 bool running = false; | |
| 1017 extension->GetBoolean(kPrefRunning, &running); | |
| 1018 return running; | |
| 1019 } | |
| 1020 | |
| 1021 void ExtensionPrefs::SetIsActive(const std::string& extension_id, | |
| 1022 bool is_active) { | |
| 1023 base::Value* value = new base::FundamentalValue(is_active); | |
| 1024 UpdateExtensionPref(extension_id, kIsActive, value); | |
| 1025 } | |
| 1026 | |
| 1027 bool ExtensionPrefs::IsActive(const std::string& extension_id) { | |
| 1028 const base::DictionaryValue* extension = GetExtensionPref(extension_id); | |
| 1029 if (!extension) | |
| 1030 return false; | |
| 1031 bool is_active = false; | |
| 1032 extension->GetBoolean(kIsActive, &is_active); | |
| 1033 return is_active; | |
| 1034 } | |
| 1035 | |
| 1036 bool ExtensionPrefs::IsIncognitoEnabled(const std::string& extension_id) const { | |
| 1037 return ReadPrefAsBooleanAndReturn(extension_id, kPrefIncognitoEnabled); | |
| 1038 } | |
| 1039 | |
| 1040 void ExtensionPrefs::SetIsIncognitoEnabled(const std::string& extension_id, | |
| 1041 bool enabled) { | |
| 1042 UpdateExtensionPref(extension_id, kPrefIncognitoEnabled, | |
| 1043 new base::FundamentalValue(enabled)); | |
| 1044 } | |
| 1045 | |
| 1046 bool ExtensionPrefs::AllowFileAccess(const std::string& extension_id) const { | |
| 1047 return ReadPrefAsBooleanAndReturn(extension_id, kPrefAllowFileAccess); | |
| 1048 } | |
| 1049 | |
| 1050 void ExtensionPrefs::SetAllowFileAccess(const std::string& extension_id, | |
| 1051 bool allow) { | |
| 1052 UpdateExtensionPref(extension_id, kPrefAllowFileAccess, | |
| 1053 new base::FundamentalValue(allow)); | |
| 1054 } | |
| 1055 | |
| 1056 bool ExtensionPrefs::HasAllowFileAccessSetting( | |
| 1057 const std::string& extension_id) const { | |
| 1058 const base::DictionaryValue* ext = GetExtensionPref(extension_id); | |
| 1059 return ext && ext->HasKey(kPrefAllowFileAccess); | |
| 1060 } | |
| 1061 | |
| 1062 bool ExtensionPrefs::DoesExtensionHaveState( | |
| 1063 const std::string& id, Extension::State check_state) const { | |
| 1064 const base::DictionaryValue* extension = GetExtensionPref(id); | |
| 1065 int state = -1; | |
| 1066 if (!extension || !extension->GetInteger(kPrefState, &state)) | |
| 1067 return false; | |
| 1068 | |
| 1069 if (state < 0 || state >= Extension::NUM_STATES) { | |
| 1070 LOG(ERROR) << "Bad pref 'state' for extension '" << id << "'"; | |
| 1071 return false; | |
| 1072 } | |
| 1073 | |
| 1074 return state == check_state; | |
| 1075 } | |
| 1076 | |
| 1077 bool ExtensionPrefs::IsExternalExtensionUninstalled( | |
| 1078 const std::string& id) const { | |
| 1079 return DoesExtensionHaveState(id, Extension::EXTERNAL_EXTENSION_UNINSTALLED); | |
| 1080 } | |
| 1081 | |
| 1082 bool ExtensionPrefs::IsExtensionDisabled( | |
| 1083 const std::string& id) const { | |
| 1084 return DoesExtensionHaveState(id, Extension::DISABLED); | |
| 1085 } | |
| 1086 | |
| 1087 ExtensionIdList ExtensionPrefs::GetToolbarOrder() { | |
| 1088 ExtensionIdList id_list_out; | |
| 1089 GetUserExtensionPrefIntoContainer(pref_names::kToolbar, &id_list_out); | |
| 1090 return id_list_out; | |
| 1091 } | |
| 1092 | |
| 1093 void ExtensionPrefs::SetToolbarOrder(const ExtensionIdList& extension_ids) { | |
| 1094 SetExtensionPrefFromContainer(pref_names::kToolbar, extension_ids); | |
| 1095 } | |
| 1096 | |
| 1097 bool ExtensionPrefs::GetKnownDisabled(ExtensionIdSet* id_set_out) { | |
| 1098 return GetUserExtensionPrefIntoContainer(pref_names::kKnownDisabled, | |
| 1099 id_set_out); | |
| 1100 } | |
| 1101 | |
| 1102 void ExtensionPrefs::SetKnownDisabled(const ExtensionIdSet& extension_ids) { | |
| 1103 SetExtensionPrefFromContainer(pref_names::kKnownDisabled, extension_ids); | |
| 1104 } | |
| 1105 | |
| 1106 void ExtensionPrefs::OnExtensionInstalled( | |
| 1107 const Extension* extension, | |
| 1108 Extension::State initial_state, | |
| 1109 bool blacklisted_for_malware, | |
| 1110 const syncer::StringOrdinal& page_ordinal) { | |
| 1111 ScopedExtensionPrefUpdate update(prefs_, extension->id()); | |
| 1112 base::DictionaryValue* extension_dict = update.Get(); | |
| 1113 const base::Time install_time = time_provider_->GetCurrentTime(); | |
| 1114 PopulateExtensionInfoPrefs(extension, install_time, initial_state, | |
| 1115 blacklisted_for_malware, extension_dict); | |
| 1116 FinishExtensionInfoPrefs(extension->id(), install_time, | |
| 1117 extension->RequiresSortOrdinal(), | |
| 1118 page_ordinal, extension_dict); | |
| 1119 } | |
| 1120 | |
| 1121 void ExtensionPrefs::OnExtensionUninstalled(const std::string& extension_id, | |
| 1122 const Manifest::Location& location, | |
| 1123 bool external_uninstall) { | |
| 1124 app_sorting_->ClearOrdinals(extension_id); | |
| 1125 | |
| 1126 // For external extensions, we save a preference reminding ourself not to try | |
| 1127 // and install the extension anymore (except when |external_uninstall| is | |
| 1128 // true, which signifies that the registry key was deleted or the pref file | |
| 1129 // no longer lists the extension). | |
| 1130 if (!external_uninstall && Manifest::IsExternalLocation(location)) { | |
| 1131 UpdateExtensionPref(extension_id, kPrefState, | |
| 1132 new base::FundamentalValue( | |
| 1133 Extension::EXTERNAL_EXTENSION_UNINSTALLED)); | |
| 1134 extension_pref_value_map_->SetExtensionState(extension_id, false); | |
| 1135 content_settings_store_->SetExtensionState(extension_id, false); | |
| 1136 } else { | |
| 1137 DeleteExtensionPrefs(extension_id); | |
| 1138 } | |
| 1139 } | |
| 1140 | |
| 1141 void ExtensionPrefs::SetExtensionState(const std::string& extension_id, | |
| 1142 Extension::State state) { | |
| 1143 UpdateExtensionPref(extension_id, kPrefState, | |
| 1144 new base::FundamentalValue(state)); | |
| 1145 bool enabled = (state == Extension::ENABLED); | |
| 1146 extension_pref_value_map_->SetExtensionState(extension_id, enabled); | |
| 1147 content_settings_store_->SetExtensionState(extension_id, enabled); | |
| 1148 } | |
| 1149 | |
| 1150 std::string ExtensionPrefs::GetVersionString(const std::string& extension_id) { | |
| 1151 const base::DictionaryValue* extension = GetExtensionPref(extension_id); | |
| 1152 if (!extension) | |
| 1153 return std::string(); | |
| 1154 | |
| 1155 std::string version; | |
| 1156 extension->GetString(kPrefVersion, &version); | |
| 1157 | |
| 1158 return version; | |
| 1159 } | |
| 1160 | |
| 1161 void ExtensionPrefs::UpdateManifest(const Extension* extension) { | |
| 1162 if (!Manifest::IsUnpackedLocation(extension->location())) { | |
| 1163 const base::DictionaryValue* extension_dict = | |
| 1164 GetExtensionPref(extension->id()); | |
| 1165 if (!extension_dict) | |
| 1166 return; | |
| 1167 const base::DictionaryValue* old_manifest = NULL; | |
| 1168 bool update_required = | |
| 1169 !extension_dict->GetDictionary(kPrefManifest, &old_manifest) || | |
| 1170 !extension->manifest()->value()->Equals(old_manifest); | |
| 1171 if (update_required) { | |
| 1172 UpdateExtensionPref(extension->id(), kPrefManifest, | |
| 1173 extension->manifest()->value()->DeepCopy()); | |
| 1174 } | |
| 1175 } | |
| 1176 } | |
| 1177 | |
| 1178 base::FilePath ExtensionPrefs::GetExtensionPath( | |
| 1179 const std::string& extension_id) { | |
| 1180 const base::DictionaryValue* dict = GetExtensionPref(extension_id); | |
| 1181 if (!dict) | |
| 1182 return base::FilePath(); | |
| 1183 | |
| 1184 std::string path; | |
| 1185 if (!dict->GetString(kPrefPath, &path)) | |
| 1186 return base::FilePath(); | |
| 1187 | |
| 1188 return install_directory_.Append(base::FilePath::FromUTF8Unsafe(path)); | |
| 1189 } | |
| 1190 | |
| 1191 scoped_ptr<ExtensionInfo> ExtensionPrefs::GetInstalledInfoHelper( | |
| 1192 const std::string& extension_id, | |
| 1193 const base::DictionaryValue* extension) const { | |
| 1194 int location_value; | |
| 1195 if (!extension->GetInteger(kPrefLocation, &location_value)) | |
| 1196 return scoped_ptr<ExtensionInfo>(); | |
| 1197 | |
| 1198 base::FilePath::StringType path; | |
| 1199 if (!extension->GetString(kPrefPath, &path)) | |
| 1200 return scoped_ptr<ExtensionInfo>(); | |
| 1201 | |
| 1202 // Make path absolute. Unpacked extensions will already have absolute paths, | |
| 1203 // otherwise make it so. | |
| 1204 Manifest::Location location = static_cast<Manifest::Location>(location_value); | |
| 1205 if (!Manifest::IsUnpackedLocation(location)) { | |
| 1206 DCHECK(location == Manifest::COMPONENT || | |
| 1207 !base::FilePath(path).IsAbsolute()); | |
| 1208 path = install_directory_.Append(path).value(); | |
| 1209 } | |
| 1210 | |
| 1211 // Only the following extension types have data saved in the preferences. | |
| 1212 if (location != Manifest::INTERNAL && | |
| 1213 !Manifest::IsUnpackedLocation(location) && | |
| 1214 !Manifest::IsExternalLocation(location)) { | |
| 1215 NOTREACHED(); | |
| 1216 return scoped_ptr<ExtensionInfo>(); | |
| 1217 } | |
| 1218 | |
| 1219 const base::DictionaryValue* manifest = NULL; | |
| 1220 if (!Manifest::IsUnpackedLocation(location) && | |
| 1221 !extension->GetDictionary(kPrefManifest, &manifest)) { | |
| 1222 LOG(WARNING) << "Missing manifest for extension " << extension_id; | |
| 1223 // Just a warning for now. | |
| 1224 } | |
| 1225 | |
| 1226 return scoped_ptr<ExtensionInfo>(new ExtensionInfo( | |
| 1227 manifest, extension_id, base::FilePath(path), location)); | |
| 1228 } | |
| 1229 | |
| 1230 scoped_ptr<ExtensionInfo> ExtensionPrefs::GetInstalledExtensionInfo( | |
| 1231 const std::string& extension_id) const { | |
| 1232 const base::DictionaryValue* ext = NULL; | |
| 1233 const base::DictionaryValue* extensions = | |
| 1234 prefs_->GetDictionary(pref_names::kExtensions); | |
| 1235 if (!extensions || | |
| 1236 !extensions->GetDictionaryWithoutPathExpansion(extension_id, &ext)) | |
| 1237 return scoped_ptr<ExtensionInfo>(); | |
| 1238 int state_value; | |
| 1239 if (!ext->GetInteger(kPrefState, &state_value) || | |
| 1240 state_value == Extension::ENABLED_COMPONENT) { | |
| 1241 // Old preferences files may not have kPrefState for component extensions. | |
| 1242 return scoped_ptr<ExtensionInfo>(); | |
| 1243 } | |
| 1244 | |
| 1245 if (state_value == Extension::EXTERNAL_EXTENSION_UNINSTALLED) { | |
| 1246 LOG(WARNING) << "External extension with id " << extension_id | |
| 1247 << " has been uninstalled by the user"; | |
| 1248 return scoped_ptr<ExtensionInfo>(); | |
| 1249 } | |
| 1250 | |
| 1251 return GetInstalledInfoHelper(extension_id, ext); | |
| 1252 } | |
| 1253 | |
| 1254 scoped_ptr<ExtensionPrefs::ExtensionsInfo> | |
| 1255 ExtensionPrefs::GetInstalledExtensionsInfo() const { | |
| 1256 scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo); | |
| 1257 | |
| 1258 const base::DictionaryValue* extensions = | |
| 1259 prefs_->GetDictionary(pref_names::kExtensions); | |
| 1260 for (base::DictionaryValue::Iterator extension_id(*extensions); | |
| 1261 !extension_id.IsAtEnd(); extension_id.Advance()) { | |
| 1262 if (!Extension::IdIsValid(extension_id.key())) | |
| 1263 continue; | |
| 1264 | |
| 1265 scoped_ptr<ExtensionInfo> info = | |
| 1266 GetInstalledExtensionInfo(extension_id.key()); | |
| 1267 if (info) | |
| 1268 extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release())); | |
| 1269 } | |
| 1270 | |
| 1271 return extensions_info.Pass(); | |
| 1272 } | |
| 1273 | |
| 1274 scoped_ptr<ExtensionPrefs::ExtensionsInfo> | |
| 1275 ExtensionPrefs::GetUninstalledExtensionsInfo() const { | |
| 1276 scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo); | |
| 1277 | |
| 1278 const base::DictionaryValue* extensions = | |
| 1279 prefs_->GetDictionary(pref_names::kExtensions); | |
| 1280 for (base::DictionaryValue::Iterator extension_id(*extensions); | |
| 1281 !extension_id.IsAtEnd(); extension_id.Advance()) { | |
| 1282 const base::DictionaryValue* ext = NULL; | |
| 1283 if (!Extension::IdIsValid(extension_id.key()) || | |
| 1284 !IsExternalExtensionUninstalled(extension_id.key()) || | |
| 1285 !extension_id.value().GetAsDictionary(&ext)) | |
| 1286 continue; | |
| 1287 | |
| 1288 scoped_ptr<ExtensionInfo> info = | |
| 1289 GetInstalledInfoHelper(extension_id.key(), ext); | |
| 1290 if (info) | |
| 1291 extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release())); | |
| 1292 } | |
| 1293 | |
| 1294 return extensions_info.Pass(); | |
| 1295 } | |
| 1296 | |
| 1297 void ExtensionPrefs::SetDelayedInstallInfo( | |
| 1298 const Extension* extension, | |
| 1299 Extension::State initial_state, | |
| 1300 bool blacklisted_for_malware, | |
| 1301 DelayReason delay_reason, | |
| 1302 const syncer::StringOrdinal& page_ordinal) { | |
| 1303 base::DictionaryValue* extension_dict = new base::DictionaryValue(); | |
| 1304 PopulateExtensionInfoPrefs(extension, time_provider_->GetCurrentTime(), | |
| 1305 initial_state, blacklisted_for_malware, | |
| 1306 extension_dict); | |
| 1307 | |
| 1308 // Add transient data that is needed by FinishDelayedInstallInfo(), but | |
| 1309 // should not be in the final extension prefs. All entries here should have | |
| 1310 // a corresponding Remove() call in FinishDelayedInstallInfo(). | |
| 1311 if (extension->RequiresSortOrdinal()) { | |
| 1312 extension_dict->SetString( | |
| 1313 kPrefSuggestedPageOrdinal, | |
| 1314 page_ordinal.IsValid() ? page_ordinal.ToInternalValue() | |
| 1315 : std::string()); | |
| 1316 } | |
| 1317 extension_dict->SetInteger(kDelayedInstallReason, | |
| 1318 static_cast<int>(delay_reason)); | |
| 1319 | |
| 1320 UpdateExtensionPref(extension->id(), kDelayedInstallInfo, extension_dict); | |
| 1321 } | |
| 1322 | |
| 1323 bool ExtensionPrefs::RemoveDelayedInstallInfo( | |
| 1324 const std::string& extension_id) { | |
| 1325 if (!GetExtensionPref(extension_id)) | |
| 1326 return false; | |
| 1327 ScopedExtensionPrefUpdate update(prefs_, extension_id); | |
| 1328 bool result = update->Remove(kDelayedInstallInfo, NULL); | |
| 1329 return result; | |
| 1330 } | |
| 1331 | |
| 1332 bool ExtensionPrefs::FinishDelayedInstallInfo( | |
| 1333 const std::string& extension_id) { | |
| 1334 CHECK(Extension::IdIsValid(extension_id)); | |
| 1335 ScopedExtensionPrefUpdate update(prefs_, extension_id); | |
| 1336 base::DictionaryValue* extension_dict = update.Get(); | |
| 1337 base::DictionaryValue* pending_install_dict = NULL; | |
| 1338 if (!extension_dict->GetDictionary(kDelayedInstallInfo, | |
| 1339 &pending_install_dict)) { | |
| 1340 return false; | |
| 1341 } | |
| 1342 | |
| 1343 // Retrieve and clear transient values populated by SetDelayedInstallInfo(). | |
| 1344 // Also do any other data cleanup that makes sense. | |
| 1345 std::string serialized_ordinal; | |
| 1346 syncer::StringOrdinal suggested_page_ordinal; | |
| 1347 bool needs_sort_ordinal = false; | |
| 1348 if (pending_install_dict->GetString(kPrefSuggestedPageOrdinal, | |
| 1349 &serialized_ordinal)) { | |
| 1350 suggested_page_ordinal = syncer::StringOrdinal(serialized_ordinal); | |
| 1351 needs_sort_ordinal = true; | |
| 1352 pending_install_dict->Remove(kPrefSuggestedPageOrdinal, NULL); | |
| 1353 } | |
| 1354 pending_install_dict->Remove(kDelayedInstallReason, NULL); | |
| 1355 | |
| 1356 const base::Time install_time = time_provider_->GetCurrentTime(); | |
| 1357 pending_install_dict->Set( | |
| 1358 kPrefInstallTime, | |
| 1359 new base::StringValue( | |
| 1360 base::Int64ToString(install_time.ToInternalValue()))); | |
| 1361 | |
| 1362 // Commit the delayed install data. | |
| 1363 for (base::DictionaryValue::Iterator it(*pending_install_dict); !it.IsAtEnd(); | |
| 1364 it.Advance()) { | |
| 1365 extension_dict->Set(it.key(), it.value().DeepCopy()); | |
| 1366 } | |
| 1367 FinishExtensionInfoPrefs(extension_id, install_time, needs_sort_ordinal, | |
| 1368 suggested_page_ordinal, extension_dict); | |
| 1369 return true; | |
| 1370 } | |
| 1371 | |
| 1372 scoped_ptr<ExtensionInfo> ExtensionPrefs::GetDelayedInstallInfo( | |
| 1373 const std::string& extension_id) const { | |
| 1374 const base::DictionaryValue* extension_prefs = | |
| 1375 GetExtensionPref(extension_id); | |
| 1376 if (!extension_prefs) | |
| 1377 return scoped_ptr<ExtensionInfo>(); | |
| 1378 | |
| 1379 const base::DictionaryValue* ext = NULL; | |
| 1380 if (!extension_prefs->GetDictionary(kDelayedInstallInfo, &ext)) | |
| 1381 return scoped_ptr<ExtensionInfo>(); | |
| 1382 | |
| 1383 return GetInstalledInfoHelper(extension_id, ext); | |
| 1384 } | |
| 1385 | |
| 1386 ExtensionPrefs::DelayReason ExtensionPrefs::GetDelayedInstallReason( | |
| 1387 const std::string& extension_id) const { | |
| 1388 const base::DictionaryValue* extension_prefs = | |
| 1389 GetExtensionPref(extension_id); | |
| 1390 if (!extension_prefs) | |
| 1391 return DELAY_REASON_NONE; | |
| 1392 | |
| 1393 const base::DictionaryValue* ext = NULL; | |
| 1394 if (!extension_prefs->GetDictionary(kDelayedInstallInfo, &ext)) | |
| 1395 return DELAY_REASON_NONE; | |
| 1396 | |
| 1397 int delay_reason; | |
| 1398 if (!ext->GetInteger(kDelayedInstallReason, &delay_reason)) | |
| 1399 return DELAY_REASON_NONE; | |
| 1400 | |
| 1401 return static_cast<DelayReason>(delay_reason); | |
| 1402 } | |
| 1403 | |
| 1404 scoped_ptr<ExtensionPrefs::ExtensionsInfo> ExtensionPrefs:: | |
| 1405 GetAllDelayedInstallInfo() const { | |
| 1406 scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo); | |
| 1407 | |
| 1408 const base::DictionaryValue* extensions = | |
| 1409 prefs_->GetDictionary(pref_names::kExtensions); | |
| 1410 for (base::DictionaryValue::Iterator extension_id(*extensions); | |
| 1411 !extension_id.IsAtEnd(); extension_id.Advance()) { | |
| 1412 if (!Extension::IdIsValid(extension_id.key())) | |
| 1413 continue; | |
| 1414 | |
| 1415 scoped_ptr<ExtensionInfo> info = GetDelayedInstallInfo(extension_id.key()); | |
| 1416 if (info) | |
| 1417 extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release())); | |
| 1418 } | |
| 1419 | |
| 1420 return extensions_info.Pass(); | |
| 1421 } | |
| 1422 | |
| 1423 bool ExtensionPrefs::WasAppDraggedByUser(const std::string& extension_id) { | |
| 1424 return ReadPrefAsBooleanAndReturn(extension_id, kPrefUserDraggedApp); | |
| 1425 } | |
| 1426 | |
| 1427 void ExtensionPrefs::SetAppDraggedByUser(const std::string& extension_id) { | |
| 1428 UpdateExtensionPref(extension_id, kPrefUserDraggedApp, | |
| 1429 new base::FundamentalValue(true)); | |
| 1430 } | |
| 1431 | |
| 1432 bool ExtensionPrefs::IsFromWebStore( | |
| 1433 const std::string& extension_id) const { | |
| 1434 const base::DictionaryValue* dictionary = GetExtensionPref(extension_id); | |
| 1435 bool result = false; | |
| 1436 if (dictionary && dictionary->GetBoolean(kPrefFromWebStore, &result)) | |
| 1437 return result; | |
| 1438 return false; | |
| 1439 } | |
| 1440 | |
| 1441 bool ExtensionPrefs::IsFromBookmark( | |
| 1442 const std::string& extension_id) const { | |
| 1443 const base::DictionaryValue* dictionary = GetExtensionPref(extension_id); | |
| 1444 bool result = false; | |
| 1445 if (dictionary && dictionary->GetBoolean(kPrefFromBookmark, &result)) | |
| 1446 return result; | |
| 1447 return false; | |
| 1448 } | |
| 1449 | |
| 1450 int ExtensionPrefs::GetCreationFlags(const std::string& extension_id) const { | |
| 1451 int creation_flags = Extension::NO_FLAGS; | |
| 1452 if (!ReadPrefAsInteger(extension_id, kPrefCreationFlags, &creation_flags)) { | |
| 1453 // Since kPrefCreationFlags was added later, it will be missing for | |
| 1454 // previously installed extensions. | |
| 1455 if (IsFromBookmark(extension_id)) | |
| 1456 creation_flags |= Extension::FROM_BOOKMARK; | |
| 1457 if (IsFromWebStore(extension_id)) | |
| 1458 creation_flags |= Extension::FROM_WEBSTORE; | |
| 1459 if (WasInstalledByDefault(extension_id)) | |
| 1460 creation_flags |= Extension::WAS_INSTALLED_BY_DEFAULT; | |
| 1461 } | |
| 1462 return creation_flags; | |
| 1463 } | |
| 1464 | |
| 1465 int ExtensionPrefs::GetDelayedInstallCreationFlags( | |
| 1466 const std::string& extension_id) const { | |
| 1467 int creation_flags = Extension::NO_FLAGS; | |
| 1468 const base::DictionaryValue* delayed_info = NULL; | |
| 1469 if (ReadPrefAsDictionary(extension_id, kDelayedInstallInfo, &delayed_info)) { | |
| 1470 delayed_info->GetInteger(kPrefCreationFlags, &creation_flags); | |
| 1471 } | |
| 1472 return creation_flags; | |
| 1473 } | |
| 1474 | |
| 1475 bool ExtensionPrefs::WasInstalledByDefault( | |
| 1476 const std::string& extension_id) const { | |
| 1477 const base::DictionaryValue* dictionary = GetExtensionPref(extension_id); | |
| 1478 bool result = false; | |
| 1479 if (dictionary && | |
| 1480 dictionary->GetBoolean(kPrefWasInstalledByDefault, &result)) | |
| 1481 return result; | |
| 1482 return false; | |
| 1483 } | |
| 1484 | |
| 1485 base::Time ExtensionPrefs::GetInstallTime( | |
| 1486 const std::string& extension_id) const { | |
| 1487 const base::DictionaryValue* extension = GetExtensionPref(extension_id); | |
| 1488 if (!extension) { | |
| 1489 NOTREACHED(); | |
| 1490 return base::Time(); | |
| 1491 } | |
| 1492 std::string install_time_str; | |
| 1493 if (!extension->GetString(kPrefInstallTime, &install_time_str)) | |
| 1494 return base::Time(); | |
| 1495 int64 install_time_i64 = 0; | |
| 1496 if (!base::StringToInt64(install_time_str, &install_time_i64)) | |
| 1497 return base::Time(); | |
| 1498 return base::Time::FromInternalValue(install_time_i64); | |
| 1499 } | |
| 1500 | |
| 1501 base::Time ExtensionPrefs::GetLastLaunchTime( | |
| 1502 const std::string& extension_id) const { | |
| 1503 const base::DictionaryValue* extension = GetExtensionPref(extension_id); | |
| 1504 if (!extension) | |
| 1505 return base::Time(); | |
| 1506 | |
| 1507 std::string launch_time_str; | |
| 1508 if (!extension->GetString(kPrefLastLaunchTime, &launch_time_str)) | |
| 1509 return base::Time(); | |
| 1510 int64 launch_time_i64 = 0; | |
| 1511 if (!base::StringToInt64(launch_time_str, &launch_time_i64)) | |
| 1512 return base::Time(); | |
| 1513 return base::Time::FromInternalValue(launch_time_i64); | |
| 1514 } | |
| 1515 | |
| 1516 void ExtensionPrefs::SetLastLaunchTime(const std::string& extension_id, | |
| 1517 const base::Time& time) { | |
| 1518 DCHECK(Extension::IdIsValid(extension_id)); | |
| 1519 ScopedExtensionPrefUpdate update(prefs_, extension_id); | |
| 1520 SaveTime(update.Get(), kPrefLastLaunchTime, time); | |
| 1521 } | |
| 1522 | |
| 1523 void ExtensionPrefs::GetExtensions(ExtensionIdList* out) { | |
| 1524 CHECK(out); | |
| 1525 | |
| 1526 scoped_ptr<ExtensionsInfo> extensions_info(GetInstalledExtensionsInfo()); | |
| 1527 | |
| 1528 for (size_t i = 0; i < extensions_info->size(); ++i) { | |
| 1529 ExtensionInfo* info = extensions_info->at(i).get(); | |
| 1530 out->push_back(info->extension_id); | |
| 1531 } | |
| 1532 } | |
| 1533 | |
| 1534 // static | |
| 1535 ExtensionIdList ExtensionPrefs::GetExtensionsFrom( | |
| 1536 const PrefService* pref_service) { | |
| 1537 ExtensionIdList result; | |
| 1538 | |
| 1539 const base::DictionaryValue* extension_prefs = NULL; | |
| 1540 const base::Value* extension_prefs_value = | |
| 1541 pref_service->GetUserPrefValue(pref_names::kExtensions); | |
| 1542 if (!extension_prefs_value || | |
| 1543 !extension_prefs_value->GetAsDictionary(&extension_prefs)) { | |
| 1544 return result; // Empty set | |
| 1545 } | |
| 1546 | |
| 1547 for (base::DictionaryValue::Iterator it(*extension_prefs); !it.IsAtEnd(); | |
| 1548 it.Advance()) { | |
| 1549 const base::DictionaryValue* ext = NULL; | |
| 1550 if (!it.value().GetAsDictionary(&ext)) { | |
| 1551 NOTREACHED() << "Invalid pref for extension " << it.key(); | |
| 1552 continue; | |
| 1553 } | |
| 1554 if (!IsBlacklistBitSet(ext)) | |
| 1555 result.push_back(it.key()); | |
| 1556 } | |
| 1557 return result; | |
| 1558 } | |
| 1559 | |
| 1560 void ExtensionPrefs::FixMissingPrefs(const ExtensionIdList& extension_ids) { | |
| 1561 // Fix old entries that did not get an installation time entry when they | |
| 1562 // were installed or don't have a preferences field. | |
| 1563 for (ExtensionIdList::const_iterator ext_id = extension_ids.begin(); | |
| 1564 ext_id != extension_ids.end(); ++ext_id) { | |
| 1565 if (GetInstallTime(*ext_id) == base::Time()) { | |
| 1566 VLOG(1) << "Could not parse installation time of extension " | |
| 1567 << *ext_id << ". It was probably installed before setting " | |
| 1568 << kPrefInstallTime << " was introduced. Updating " | |
| 1569 << kPrefInstallTime << " to the current time."; | |
| 1570 const base::Time install_time = time_provider_->GetCurrentTime(); | |
| 1571 UpdateExtensionPref(*ext_id, | |
| 1572 kPrefInstallTime, | |
| 1573 new base::StringValue(base::Int64ToString( | |
| 1574 install_time.ToInternalValue()))); | |
| 1575 } | |
| 1576 } | |
| 1577 } | |
| 1578 | |
| 1579 void ExtensionPrefs::InitPrefStore() { | |
| 1580 if (extensions_disabled_) { | |
| 1581 extension_pref_value_map_->NotifyInitializationCompleted(); | |
| 1582 return; | |
| 1583 } | |
| 1584 | |
| 1585 // When this is called, the PrefService is initialized and provides access | |
| 1586 // to the user preferences stored in a JSON file. | |
| 1587 ExtensionIdList extension_ids; | |
| 1588 GetExtensions(&extension_ids); | |
| 1589 // Create empty preferences dictionary for each extension (these dictionaries | |
| 1590 // are pruned when persisting the preferences to disk). | |
| 1591 for (ExtensionIdList::iterator ext_id = extension_ids.begin(); | |
| 1592 ext_id != extension_ids.end(); ++ext_id) { | |
| 1593 ScopedExtensionPrefUpdate update(prefs_, *ext_id); | |
| 1594 // This creates an empty dictionary if none is stored. | |
| 1595 update.Get(); | |
| 1596 } | |
| 1597 | |
| 1598 FixMissingPrefs(extension_ids); | |
| 1599 MigratePermissions(extension_ids); | |
| 1600 MigrateDisableReasons(extension_ids); | |
| 1601 app_sorting_->Initialize(extension_ids); | |
| 1602 | |
| 1603 PreferenceAPI::InitExtensionControlledPrefs(this, extension_pref_value_map_); | |
| 1604 | |
| 1605 extension_pref_value_map_->NotifyInitializationCompleted(); | |
| 1606 } | |
| 1607 | |
| 1608 bool ExtensionPrefs::HasIncognitoPrefValue(const std::string& pref_key) { | |
| 1609 bool has_incognito_pref_value = false; | |
| 1610 extension_pref_value_map_->GetEffectivePrefValue(pref_key, | |
| 1611 true, | |
| 1612 &has_incognito_pref_value); | |
| 1613 return has_incognito_pref_value; | |
| 1614 } | |
| 1615 | |
| 1616 URLPatternSet ExtensionPrefs::GetAllowedInstallSites() { | |
| 1617 URLPatternSet result; | |
| 1618 const base::ListValue* list = | |
| 1619 prefs_->GetList(pref_names::kAllowedInstallSites); | |
| 1620 CHECK(list); | |
| 1621 | |
| 1622 for (size_t i = 0; i < list->GetSize(); ++i) { | |
| 1623 std::string entry_string; | |
| 1624 URLPattern entry(URLPattern::SCHEME_ALL); | |
| 1625 if (!list->GetString(i, &entry_string) || | |
| 1626 entry.Parse(entry_string) != URLPattern::PARSE_SUCCESS) { | |
| 1627 LOG(ERROR) << "Invalid value for preference: " | |
| 1628 << pref_names::kAllowedInstallSites << "." << i; | |
| 1629 continue; | |
| 1630 } | |
| 1631 result.AddPattern(entry); | |
| 1632 } | |
| 1633 | |
| 1634 return result; | |
| 1635 } | |
| 1636 | |
| 1637 const base::DictionaryValue* ExtensionPrefs::GetGeometryCache( | |
| 1638 const std::string& extension_id) const { | |
| 1639 const base::DictionaryValue* extension_prefs = GetExtensionPref(extension_id); | |
| 1640 if (!extension_prefs) | |
| 1641 return NULL; | |
| 1642 | |
| 1643 const base::DictionaryValue* ext = NULL; | |
| 1644 if (!extension_prefs->GetDictionary(kPrefGeometryCache, &ext)) | |
| 1645 return NULL; | |
| 1646 | |
| 1647 return ext; | |
| 1648 } | |
| 1649 | |
| 1650 void ExtensionPrefs::SetGeometryCache( | |
| 1651 const std::string& extension_id, | |
| 1652 scoped_ptr<base::DictionaryValue> cache) { | |
| 1653 UpdateExtensionPref(extension_id, kPrefGeometryCache, cache.release()); | |
| 1654 } | |
| 1655 | |
| 1656 const base::DictionaryValue* ExtensionPrefs::GetInstallSignature() { | |
| 1657 return prefs_->GetDictionary(kInstallSignature); | |
| 1658 } | |
| 1659 | |
| 1660 void ExtensionPrefs::SetInstallSignature( | |
| 1661 const base::DictionaryValue* signature) { | |
| 1662 if (signature) { | |
| 1663 prefs_->Set(kInstallSignature, *signature); | |
| 1664 DVLOG(1) << "SetInstallSignature - saving"; | |
| 1665 } else { | |
| 1666 DVLOG(1) << "SetInstallSignature - clearing"; | |
| 1667 prefs_->ClearPref(kInstallSignature); | |
| 1668 } | |
| 1669 } | |
| 1670 | |
| 1671 | |
| 1672 ExtensionPrefs::ExtensionPrefs( | |
| 1673 PrefService* prefs, | |
| 1674 const base::FilePath& root_dir, | |
| 1675 ExtensionPrefValueMap* extension_pref_value_map, | |
| 1676 scoped_ptr<AppSorting> app_sorting, | |
| 1677 scoped_ptr<TimeProvider> time_provider, | |
| 1678 bool extensions_disabled) | |
| 1679 : prefs_(prefs), | |
| 1680 install_directory_(root_dir), | |
| 1681 extension_pref_value_map_(extension_pref_value_map), | |
| 1682 app_sorting_(app_sorting.Pass()), | |
| 1683 content_settings_store_(new ContentSettingsStore()), | |
| 1684 time_provider_(time_provider.Pass()), | |
| 1685 extensions_disabled_(extensions_disabled) { | |
| 1686 app_sorting_->SetExtensionScopedPrefs(this), | |
| 1687 MakePathsRelative(); | |
| 1688 InitPrefStore(); | |
| 1689 } | |
| 1690 | |
| 1691 void ExtensionPrefs::SetNeedsStorageGarbageCollection(bool value) { | |
| 1692 prefs_->SetBoolean(pref_names::kStorageGarbageCollect, value); | |
| 1693 } | |
| 1694 | |
| 1695 bool ExtensionPrefs::NeedsStorageGarbageCollection() { | |
| 1696 return prefs_->GetBoolean(pref_names::kStorageGarbageCollect); | |
| 1697 } | |
| 1698 | |
| 1699 // static | |
| 1700 void ExtensionPrefs::RegisterProfilePrefs( | |
| 1701 user_prefs::PrefRegistrySyncable* registry) { | |
| 1702 registry->RegisterDictionaryPref( | |
| 1703 pref_names::kExtensions, | |
| 1704 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1705 registry->RegisterListPref(pref_names::kToolbar, | |
| 1706 user_prefs::PrefRegistrySyncable::SYNCABLE_PREF); | |
| 1707 registry->RegisterIntegerPref( | |
| 1708 pref_names::kToolbarSize, | |
| 1709 -1, // default value | |
| 1710 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1711 registry->RegisterDictionaryPref( | |
| 1712 kExtensionsBlacklistUpdate, | |
| 1713 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1714 registry->RegisterListPref(pref_names::kInstallAllowList, | |
| 1715 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1716 registry->RegisterListPref(pref_names::kInstallDenyList, | |
| 1717 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1718 registry->RegisterDictionaryPref( | |
| 1719 pref_names::kInstallForceList, | |
| 1720 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1721 registry->RegisterListPref(pref_names::kAllowedTypes, | |
| 1722 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1723 registry->RegisterBooleanPref( | |
| 1724 pref_names::kStorageGarbageCollect, | |
| 1725 false, // default value | |
| 1726 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1727 registry->RegisterInt64Pref( | |
| 1728 pref_names::kLastUpdateCheck, | |
| 1729 0, // default value | |
| 1730 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1731 registry->RegisterInt64Pref( | |
| 1732 pref_names::kNextUpdateCheck, | |
| 1733 0, // default value | |
| 1734 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1735 registry->RegisterListPref(pref_names::kAllowedInstallSites, | |
| 1736 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1737 registry->RegisterStringPref( | |
| 1738 pref_names::kLastChromeVersion, | |
| 1739 std::string(), // default value | |
| 1740 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1741 registry->RegisterListPref(pref_names::kKnownDisabled, | |
| 1742 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1743 #if defined(TOOLKIT_VIEWS) | |
| 1744 registry->RegisterIntegerPref( | |
| 1745 pref_names::kBrowserActionContainerWidth, | |
| 1746 0, | |
| 1747 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1748 #endif | |
| 1749 registry->RegisterDictionaryPref( | |
| 1750 kInstallSignature, | |
| 1751 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1752 | |
| 1753 registry->RegisterListPref(pref_names::kNativeMessagingBlacklist, | |
| 1754 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1755 registry->RegisterListPref(pref_names::kNativeMessagingWhitelist, | |
| 1756 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); | |
| 1757 } | |
| 1758 | |
| 1759 template <class ExtensionIdContainer> | |
| 1760 bool ExtensionPrefs::GetUserExtensionPrefIntoContainer( | |
| 1761 const char* pref, | |
| 1762 ExtensionIdContainer* id_container_out) { | |
| 1763 DCHECK(id_container_out->empty()); | |
| 1764 | |
| 1765 const base::Value* user_pref_value = prefs_->GetUserPrefValue(pref); | |
| 1766 const base::ListValue* user_pref_as_list; | |
| 1767 if (!user_pref_value || !user_pref_value->GetAsList(&user_pref_as_list)) | |
| 1768 return false; | |
| 1769 | |
| 1770 std::insert_iterator<ExtensionIdContainer> insert_iterator( | |
| 1771 *id_container_out, id_container_out->end()); | |
| 1772 std::string extension_id; | |
| 1773 for (base::ListValue::const_iterator value_it = user_pref_as_list->begin(); | |
| 1774 value_it != user_pref_as_list->end(); ++value_it) { | |
| 1775 if (!(*value_it)->GetAsString(&extension_id)) { | |
| 1776 NOTREACHED(); | |
| 1777 continue; | |
| 1778 } | |
| 1779 insert_iterator = extension_id; | |
| 1780 } | |
| 1781 return true; | |
| 1782 } | |
| 1783 | |
| 1784 template <class ExtensionIdContainer> | |
| 1785 void ExtensionPrefs::SetExtensionPrefFromContainer( | |
| 1786 const char* pref, | |
| 1787 const ExtensionIdContainer& strings) { | |
| 1788 ListPrefUpdate update(prefs_, pref); | |
| 1789 base::ListValue* list_of_values = update.Get(); | |
| 1790 list_of_values->Clear(); | |
| 1791 for (typename ExtensionIdContainer::const_iterator iter = strings.begin(); | |
| 1792 iter != strings.end(); ++iter) { | |
| 1793 list_of_values->Append(new base::StringValue(*iter)); | |
| 1794 } | |
| 1795 } | |
| 1796 | |
| 1797 void ExtensionPrefs::PopulateExtensionInfoPrefs( | |
| 1798 const Extension* extension, | |
| 1799 const base::Time install_time, | |
| 1800 Extension::State initial_state, | |
| 1801 bool blacklisted_for_malware, | |
| 1802 base::DictionaryValue* extension_dict) { | |
| 1803 // Leave the state blank for component extensions so that old chrome versions | |
| 1804 // loading new profiles do not fail in GetInstalledExtensionInfo. Older | |
| 1805 // Chrome versions would only check for an omitted state. | |
| 1806 if (initial_state != Extension::ENABLED_COMPONENT) | |
| 1807 extension_dict->Set(kPrefState, new base::FundamentalValue(initial_state)); | |
| 1808 | |
| 1809 extension_dict->Set(kPrefLocation, | |
| 1810 new base::FundamentalValue(extension->location())); | |
| 1811 extension_dict->Set(kPrefCreationFlags, | |
| 1812 new base::FundamentalValue(extension->creation_flags())); | |
| 1813 extension_dict->Set(kPrefFromWebStore, | |
| 1814 new base::FundamentalValue(extension->from_webstore())); | |
| 1815 extension_dict->Set(kPrefFromBookmark, | |
| 1816 new base::FundamentalValue(extension->from_bookmark())); | |
| 1817 extension_dict->Set( | |
| 1818 kPrefWasInstalledByDefault, | |
| 1819 new base::FundamentalValue(extension->was_installed_by_default())); | |
| 1820 extension_dict->Set(kPrefInstallTime, | |
| 1821 new base::StringValue( | |
| 1822 base::Int64ToString(install_time.ToInternalValue()))); | |
| 1823 if (blacklisted_for_malware) | |
| 1824 extension_dict->Set(kPrefBlacklist, new base::FundamentalValue(true)); | |
| 1825 | |
| 1826 base::FilePath::StringType path = MakePathRelative(install_directory_, | |
| 1827 extension->path()); | |
| 1828 extension_dict->Set(kPrefPath, new base::StringValue(path)); | |
| 1829 // We store prefs about LOAD extensions, but don't cache their manifest | |
| 1830 // since it may change on disk. | |
| 1831 if (!Manifest::IsUnpackedLocation(extension->location())) { | |
| 1832 extension_dict->Set(kPrefManifest, | |
| 1833 extension->manifest()->value()->DeepCopy()); | |
| 1834 } | |
| 1835 } | |
| 1836 | |
| 1837 void ExtensionPrefs::FinishExtensionInfoPrefs( | |
| 1838 const std::string& extension_id, | |
| 1839 const base::Time install_time, | |
| 1840 bool needs_sort_ordinal, | |
| 1841 const syncer::StringOrdinal& suggested_page_ordinal, | |
| 1842 base::DictionaryValue* extension_dict) { | |
| 1843 // Reinitializes various preferences with empty dictionaries. | |
| 1844 if (!extension_dict->HasKey(pref_names::kPrefPreferences)) { | |
| 1845 extension_dict->Set(pref_names::kPrefPreferences, | |
| 1846 new base::DictionaryValue); | |
| 1847 } | |
| 1848 | |
| 1849 if (!extension_dict->HasKey(pref_names::kPrefIncognitoPreferences)) { | |
| 1850 extension_dict->Set(pref_names::kPrefIncognitoPreferences, | |
| 1851 new base::DictionaryValue); | |
| 1852 } | |
| 1853 | |
| 1854 if (!extension_dict->HasKey(pref_names::kPrefRegularOnlyPreferences)) { | |
| 1855 extension_dict->Set(pref_names::kPrefRegularOnlyPreferences, | |
| 1856 new base::DictionaryValue); | |
| 1857 } | |
| 1858 | |
| 1859 if (!extension_dict->HasKey(pref_names::kPrefContentSettings)) | |
| 1860 extension_dict->Set(pref_names::kPrefContentSettings, new base::ListValue); | |
| 1861 | |
| 1862 if (!extension_dict->HasKey(pref_names::kPrefIncognitoContentSettings)) { | |
| 1863 extension_dict->Set(pref_names::kPrefIncognitoContentSettings, | |
| 1864 new base::ListValue); | |
| 1865 } | |
| 1866 | |
| 1867 // If this point has been reached, any pending installs should be considered | |
| 1868 // out of date. | |
| 1869 extension_dict->Remove(kDelayedInstallInfo, NULL); | |
| 1870 | |
| 1871 // Clear state that may be registered from a previous install. | |
| 1872 extension_dict->Remove(EventRouter::kRegisteredEvents, NULL); | |
| 1873 | |
| 1874 // FYI, all code below here races on sudden shutdown because |extension_dict|, | |
| 1875 // |app_sorting_|, |extension_pref_value_map_|, and |content_settings_store_| | |
| 1876 // are updated non-transactionally. This is probably not fixable without | |
| 1877 // nested transactional updates to pref dictionaries. | |
| 1878 if (needs_sort_ordinal) | |
| 1879 app_sorting_->EnsureValidOrdinals(extension_id, suggested_page_ordinal); | |
| 1880 | |
| 1881 bool is_enabled = false; | |
| 1882 int initial_state; | |
| 1883 if (extension_dict->GetInteger(kPrefState, &initial_state)) { | |
| 1884 is_enabled = initial_state == Extension::ENABLED; | |
| 1885 } | |
| 1886 | |
| 1887 extension_pref_value_map_->RegisterExtension(extension_id, install_time, | |
| 1888 is_enabled); | |
| 1889 content_settings_store_->RegisterExtension(extension_id, install_time, | |
| 1890 is_enabled); | |
| 1891 } | |
| 1892 | |
| 1893 } // namespace extensions | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 46853004:
Move ExtensionPrefs and friends to extensions/ directory. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src