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/installed_loader.h"
6
7 #include "base/files/file_path.h"
8 #include "base/metrics/histogram.h"
9 #include "base/strings/stringprintf.h"
10 #include "base/strings/utf_string_conversions.h"
11 #include "base/threading/thread_restrictions.h"
12 #include "base/values.h"
13 #include "chrome/browser/browser_process.h"
14 #include "chrome/browser/extensions/extension_action_manager.h"
15 #include "chrome/browser/extensions/extension_error_reporter.h"
16 #include "chrome/browser/extensions/extension_service.h"
17 #include "chrome/browser/extensions/extension_util.h"
18 #include "chrome/browser/profiles/profile_manager.h"
19 #include "chrome/common/chrome_switches.h"
20 #include "chrome/common/extensions/api/managed_mode_private/managed_mode_handler.h"
21 #include "chrome/common/extensions/extension_constants.h"
22 #include "chrome/common/extensions/manifest_url_handler.h"
23 #include "chrome/common/pref_names.h"
24 #include "content/public/browser/notification_service.h"
25 #include "content/public/browser/user_metrics.h"
26 #include "extensions/browser/api/runtime/runtime_api.h"
27 #include "extensions/browser/extension_prefs.h"
28 #include "extensions/browser/extension_registry.h"
29 #include "extensions/browser/extension_system.h"
30 #include "extensions/browser/management_policy.h"
31 #include "extensions/common/extension.h"
32 #include "extensions/common/extension_l10n_util.h"
33 #include "extensions/common/extension_set.h"
34 #include "extensions/common/file_util.h"
35 #include "extensions/common/manifest.h"
36 #include "extensions/common/manifest_constants.h"
37 #include "extensions/common/manifest_handlers/background_info.h"
38
39 using base::UserMetricsAction;
40 using content::BrowserThread;
41
42 namespace extensions {
43
44 namespace errors = manifest_errors;
45
46 namespace {
47
48 // The following enumeration is used in histograms matching
49 // Extensions.ManifestReload*.
50 enum ManifestReloadReason {
51 NOT_NEEDED = 0, // Reload not needed.
52 UNPACKED_DIR, // Unpacked directory.
53 NEEDS_RELOCALIZATION, // The locale has changed since we read this extension.
54 CORRUPT_PREFERENCES, // The manifest in the preferences is corrupt.
55
56 // New enum values must go above here.
57 NUM_MANIFEST_RELOAD_REASONS
58 };
59
60 // Used in histogram Extension.BackgroundPageType.
61 enum BackgroundPageType {
62 NO_BACKGROUND_PAGE = 0,
63 BACKGROUND_PAGE_PERSISTENT,
64 EVENT_PAGE,
65
66 // New enum values must go above here.
67 NUM_BACKGROUND_PAGE_TYPES
68 };
69
70 // Used in histogram Extensions.ExternalItemState.
71 enum ExternalItemState {
72 DEPRECATED_EXTERNAL_ITEM_DISABLED = 0,
73 DEPRECATED_EXTERNAL_ITEM_ENABLED,
74 EXTERNAL_ITEM_WEBSTORE_DISABLED,
75 EXTERNAL_ITEM_WEBSTORE_ENABLED,
76 EXTERNAL_ITEM_NONWEBSTORE_DISABLED,
77 EXTERNAL_ITEM_NONWEBSTORE_ENABLED,
78 EXTERNAL_ITEM_WEBSTORE_UNINSTALLED,
79 EXTERNAL_ITEM_NONWEBSTORE_UNINSTALLED,
80
81 // New enum values must go above here.
82 EXTERNAL_ITEM_MAX_ITEMS
83 };
84
IsManifestCorrupt(const base::DictionaryValue * manifest)85 bool IsManifestCorrupt(const base::DictionaryValue* manifest) {
86 if (!manifest)
87 return false;
88
89 // Because of bug #272524 sometimes manifests got mangled in the preferences
90 // file, one particularly bad case resulting in having both a background page
91 // and background scripts values. In those situations we want to reload the
92 // manifest from the extension to fix this.
93 const base::Value* background_page;
94 const base::Value* background_scripts;
95 return manifest->Get(manifest_keys::kBackgroundPage, &background_page) &&
96 manifest->Get(manifest_keys::kBackgroundScripts, &background_scripts);
97 }
98
ShouldReloadExtensionManifest(const ExtensionInfo & info)99 ManifestReloadReason ShouldReloadExtensionManifest(const ExtensionInfo& info) {
100 // Always reload manifests of unpacked extensions, because they can change
101 // on disk independent of the manifest in our prefs.
102 if (Manifest::IsUnpackedLocation(info.extension_location))
103 return UNPACKED_DIR;
104
105 // Reload the manifest if it needs to be relocalized.
106 if (extension_l10n_util::ShouldRelocalizeManifest(
107 info.extension_manifest.get()))
108 return NEEDS_RELOCALIZATION;
109
110 // Reload if the copy of the manifest in the preferences is corrupt.
111 if (IsManifestCorrupt(info.extension_manifest.get()))
112 return CORRUPT_PREFERENCES;
113
114 return NOT_NEEDED;
115 }
116
GetBackgroundPageType(const Extension * extension)117 BackgroundPageType GetBackgroundPageType(const Extension* extension) {
118 if (!BackgroundInfo::HasBackgroundPage(extension))
119 return NO_BACKGROUND_PAGE;
120 if (BackgroundInfo::HasPersistentBackgroundPage(extension))
121 return BACKGROUND_PAGE_PERSISTENT;
122 return EVENT_PAGE;
123 }
124
125 // Records the creation flags of an extension grouped by
126 // Extension::InitFromValueFlags.
RecordCreationFlags(const Extension * extension)127 void RecordCreationFlags(const Extension* extension) {
128 for (int i = 0; i < Extension::kInitFromValueFlagBits; ++i) {
129 int flag = 1 << i;
130 if (extension->creation_flags() & flag) {
131 UMA_HISTOGRAM_ENUMERATION(
132 "Extensions.LoadCreationFlags", i, Extension::kInitFromValueFlagBits);
133 }
134 }
135 }
136
137 } // namespace
138
InstalledLoader(ExtensionService * extension_service)139 InstalledLoader::InstalledLoader(ExtensionService* extension_service)
140 : extension_service_(extension_service),
141 extension_registry_(ExtensionRegistry::Get(extension_service->profile())),
142 extension_prefs_(ExtensionPrefs::Get(extension_service->profile())) {}
143
~InstalledLoader()144 InstalledLoader::~InstalledLoader() {
145 }
146
Load(const ExtensionInfo & info,bool write_to_prefs)147 void InstalledLoader::Load(const ExtensionInfo& info, bool write_to_prefs) {
148 std::string error;
149 scoped_refptr<const Extension> extension(NULL);
150 if (info.extension_manifest) {
151 extension = Extension::Create(
152 info.extension_path,
153 info.extension_location,
154 *info.extension_manifest,
155 GetCreationFlags(&info),
156 &error);
157 } else {
158 error = errors::kManifestUnreadable;
159 }
160
161 // Once installed, non-unpacked extensions cannot change their IDs (e.g., by
162 // updating the 'key' field in their manifest).
163 // TODO(jstritar): migrate preferences when unpacked extensions change IDs.
164 if (extension.get() && !Manifest::IsUnpackedLocation(extension->location()) &&
165 info.extension_id != extension->id()) {
166 error = errors::kCannotChangeExtensionID;
167 extension = NULL;
168 }
169
170 // Check policy on every load in case an extension was blacklisted while
171 // Chrome was not running.
172 const ManagementPolicy* policy = extensions::ExtensionSystem::Get(
173 extension_service_->profile())->management_policy();
174 if (extension.get()) {
175 Extension::DisableReason disable_reason = Extension::DISABLE_NONE;
176 bool force_disabled = false;
177 if (!policy->UserMayLoad(extension.get(), NULL)) {
178 // The error message from UserMayInstall() often contains the extension ID
179 // and is therefore not well suited to this UI.
180 error = errors::kDisabledByPolicy;
181 extension = NULL;
182 } else if (!extension_prefs_->IsExtensionDisabled(extension->id()) &&
183 policy->MustRemainDisabled(extension, &disable_reason, NULL)) {
184 extension_prefs_->SetExtensionState(extension->id(), Extension::DISABLED);
185 extension_prefs_->AddDisableReason(extension->id(), disable_reason);
186 force_disabled = true;
187 }
188 UMA_HISTOGRAM_BOOLEAN("ExtensionInstalledLoader.ForceDisabled",
189 force_disabled);
190 }
191
192 if (!extension.get()) {
193 ExtensionErrorReporter::GetInstance()->ReportLoadError(
194 info.extension_path,
195 error,
196 extension_service_->profile(),
197 false); // Be quiet.
198 return;
199 }
200
201 if (write_to_prefs)
202 extension_prefs_->UpdateManifest(extension.get());
203
204 extension_service_->AddExtension(extension.get());
205 }
206
LoadAllExtensions()207 void InstalledLoader::LoadAllExtensions() {
208 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
209
210 base::TimeTicks start_time = base::TimeTicks::Now();
211
212 Profile* profile = extension_service_->profile();
213 scoped_ptr<ExtensionPrefs::ExtensionsInfo> extensions_info(
214 extension_prefs_->GetInstalledExtensionsInfo());
215
216 std::vector<int> reload_reason_counts(NUM_MANIFEST_RELOAD_REASONS, 0);
217 bool should_write_prefs = false;
218
219 for (size_t i = 0; i < extensions_info->size(); ++i) {
220 ExtensionInfo* info = extensions_info->at(i).get();
221
222 // Skip extensions that were loaded from the command-line because we don't
223 // want those to persist across browser restart.
224 if (info->extension_location == Manifest::COMMAND_LINE)
225 continue;
226
227 ManifestReloadReason reload_reason = ShouldReloadExtensionManifest(*info);
228 ++reload_reason_counts[reload_reason];
229
230 if (reload_reason != NOT_NEEDED) {
231 // Reloading an extension reads files from disk. We do this on the
232 // UI thread because reloads should be very rare, and the complexity
233 // added by delaying the time when the extensions service knows about
234 // all extensions is significant. See crbug.com/37548 for details.
235 // |allow_io| disables tests that file operations run on the file
236 // thread.
237 base::ThreadRestrictions::ScopedAllowIO allow_io;
238
239 std::string error;
240 scoped_refptr<const Extension> extension(
241 file_util::LoadExtension(info->extension_path,
242 info->extension_location,
243 GetCreationFlags(info),
244 &error));
245
246 if (!extension.get()) {
247 ExtensionErrorReporter::GetInstance()->ReportLoadError(
248 info->extension_path,
249 error,
250 profile,
251 false); // Be quiet.
252 continue;
253 }
254
255 extensions_info->at(i)->extension_manifest.reset(
256 static_cast<base::DictionaryValue*>(
257 extension->manifest()->value()->DeepCopy()));
258 should_write_prefs = true;
259 }
260 }
261
262 for (size_t i = 0; i < extensions_info->size(); ++i) {
263 if (extensions_info->at(i)->extension_location != Manifest::COMMAND_LINE)
264 Load(*extensions_info->at(i), should_write_prefs);
265 }
266
267 extension_service_->OnLoadedInstalledExtensions();
268
269 // The histograms Extensions.ManifestReload* allow us to validate
270 // the assumption that reloading manifest is a rare event.
271 UMA_HISTOGRAM_COUNTS_100("Extensions.ManifestReloadNotNeeded",
272 reload_reason_counts[NOT_NEEDED]);
273 UMA_HISTOGRAM_COUNTS_100("Extensions.ManifestReloadUnpackedDir",
274 reload_reason_counts[UNPACKED_DIR]);
275 UMA_HISTOGRAM_COUNTS_100("Extensions.ManifestReloadNeedsRelocalization",
276 reload_reason_counts[NEEDS_RELOCALIZATION]);
277
278 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadAll",
279 extension_registry_->enabled_extensions().size());
280 UMA_HISTOGRAM_COUNTS_100("Extensions.Disabled",
281 extension_registry_->disabled_extensions().size());
282
283 UMA_HISTOGRAM_TIMES("Extensions.LoadAllTime",
284 base::TimeTicks::Now() - start_time);
285
286 int app_user_count = 0;
287 int app_external_count = 0;
288 int hosted_app_count = 0;
289 int legacy_packaged_app_count = 0;
290 int platform_app_count = 0;
291 int user_script_count = 0;
292 int content_pack_count = 0;
293 int extension_user_count = 0;
294 int extension_external_count = 0;
295 int theme_count = 0;
296 int page_action_count = 0;
297 int browser_action_count = 0;
298 int disabled_for_permissions_count = 0;
299 int non_webstore_ntp_override_count = 0;
300 int incognito_allowed_count = 0;
301 int incognito_not_allowed_count = 0;
302 int file_access_allowed_count = 0;
303 int file_access_not_allowed_count = 0;
304
305 const ExtensionSet& extensions = extension_registry_->enabled_extensions();
306 ExtensionActionManager* extension_action_manager =
307 ExtensionActionManager::Get(profile);
308 for (ExtensionSet::const_iterator iter = extensions.begin();
309 iter != extensions.end();
310 ++iter) {
311 const Extension* extension = *iter;
312 Manifest::Location location = extension->location();
313 Manifest::Type type = extension->GetType();
314
315 // For the first few metrics, include all extensions and apps (component,
316 // unpacked, etc). It's good to know these locations, and it doesn't
317 // muck up any of the stats. Later, though, we want to omit component and
318 // unpacked, as they are less interesting.
319 if (extension->is_app())
320 UMA_HISTOGRAM_ENUMERATION(
321 "Extensions.AppLocation", location, Manifest::NUM_LOCATIONS);
322 else if (extension->is_extension())
323 UMA_HISTOGRAM_ENUMERATION(
324 "Extensions.ExtensionLocation", location, Manifest::NUM_LOCATIONS);
325
326 if (!ManifestURL::UpdatesFromGallery(extension)) {
327 UMA_HISTOGRAM_ENUMERATION(
328 "Extensions.NonWebstoreLocation", location, Manifest::NUM_LOCATIONS);
329
330 // Check for inconsistencies if the extension was supposedly installed
331 // from the webstore.
332 enum {
333 BAD_UPDATE_URL = 0,
334 // This value was a mistake. Turns out sideloaded extensions can
335 // have the from_webstore bit if they update from the webstore.
336 DEPRECATED_IS_EXTERNAL = 1,
337 };
338 if (extension->from_webstore()) {
339 UMA_HISTOGRAM_ENUMERATION(
340 "Extensions.FromWebstoreInconsistency", BAD_UPDATE_URL, 2);
341 }
342 }
343
344 if (Manifest::IsExternalLocation(location)) {
345 // See loop below for DISABLED.
346 if (ManifestURL::UpdatesFromGallery(extension)) {
347 UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalItemState",
348 EXTERNAL_ITEM_WEBSTORE_ENABLED,
349 EXTERNAL_ITEM_MAX_ITEMS);
350 } else {
351 UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalItemState",
352 EXTERNAL_ITEM_NONWEBSTORE_ENABLED,
353 EXTERNAL_ITEM_MAX_ITEMS);
354 }
355 }
356
357 // From now on, don't count component extensions, since they are only
358 // extensions as an implementation detail. Continue to count unpacked
359 // extensions for a few metrics.
360 if (location == Manifest::COMPONENT)
361 continue;
362
363 // Histogram for non-webstore extensions overriding new tab page should
364 // include unpacked extensions.
365 if (!extension->from_webstore() &&
366 URLOverrides::GetChromeURLOverrides(extension).count("newtab")) {
367 ++non_webstore_ntp_override_count;
368 }
369
370 // Don't count unpacked extensions anymore, either.
371 if (Manifest::IsUnpackedLocation(location))
372 continue;
373
374 UMA_HISTOGRAM_ENUMERATION("Extensions.ManifestVersion",
375 extension->manifest_version(),
376 10); // TODO(kalman): Why 10 manifest versions?
377
378 // We might have wanted to count legacy packaged apps here, too, since they
379 // are effectively extensions. Unfortunately, it's too late, as we don't
380 // want to mess up the existing stats.
381 if (type == Manifest::TYPE_EXTENSION) {
382 UMA_HISTOGRAM_ENUMERATION("Extensions.BackgroundPageType",
383 GetBackgroundPageType(extension),
384 NUM_BACKGROUND_PAGE_TYPES);
385 }
386
387 // Using an enumeration shows us the total installed ratio across all users.
388 // Using the totals per user at each startup tells us the distribution of
389 // usage for each user (e.g. 40% of users have at least one app installed).
390 UMA_HISTOGRAM_ENUMERATION(
391 "Extensions.LoadType", type, Manifest::NUM_LOAD_TYPES);
392 switch (type) {
393 case Manifest::TYPE_THEME:
394 ++theme_count;
395 break;
396 case Manifest::TYPE_USER_SCRIPT:
397 ++user_script_count;
398 break;
399 case Manifest::TYPE_HOSTED_APP:
400 ++hosted_app_count;
401 if (Manifest::IsExternalLocation(location)) {
402 ++app_external_count;
403 } else {
404 ++app_user_count;
405 }
406 break;
407 case Manifest::TYPE_LEGACY_PACKAGED_APP:
408 ++legacy_packaged_app_count;
409 if (Manifest::IsExternalLocation(location)) {
410 ++app_external_count;
411 } else {
412 ++app_user_count;
413 }
414 break;
415 case Manifest::TYPE_PLATFORM_APP:
416 ++platform_app_count;
417 if (Manifest::IsExternalLocation(location)) {
418 ++app_external_count;
419 } else {
420 ++app_user_count;
421 }
422 break;
423 case Manifest::TYPE_EXTENSION:
424 default:
425 if (Manifest::IsExternalLocation(location)) {
426 ++extension_external_count;
427 } else {
428 ++extension_user_count;
429 }
430 break;
431 }
432
433 if (extension_action_manager->GetPageAction(*extension))
434 ++page_action_count;
435
436 if (extension_action_manager->GetBrowserAction(*extension))
437 ++browser_action_count;
438
439 if (ManagedModeInfo::IsContentPack(extension))
440 ++content_pack_count;
441
442 RecordCreationFlags(extension);
443
444 ExtensionService::RecordPermissionMessagesHistogram(
445 extension, "Extensions.Permissions_Load2");
446
447 // For incognito and file access, skip anything that doesn't appear in
448 // settings. Also, policy-installed (and unpacked of course, checked above)
449 // extensions are boring.
450 if (extension->ShouldDisplayInExtensionSettings() &&
451 !Manifest::IsPolicyLocation(extension->location())) {
452 if (extension->can_be_incognito_enabled()) {
453 if (util::IsIncognitoEnabled(extension->id(), profile))
454 ++incognito_allowed_count;
455 else
456 ++incognito_not_allowed_count;
457 }
458 if (extension->wants_file_access()) {
459 if (util::AllowFileAccess(extension->id(), profile))
460 ++file_access_allowed_count;
461 else
462 ++file_access_not_allowed_count;
463 }
464 }
465 }
466
467 const ExtensionSet& disabled_extensions =
468 extension_registry_->disabled_extensions();
469
470 for (ExtensionSet::const_iterator ex = disabled_extensions.begin();
471 ex != disabled_extensions.end();
472 ++ex) {
473 if (extension_prefs_->DidExtensionEscalatePermissions((*ex)->id())) {
474 ++disabled_for_permissions_count;
475 }
476 if (Manifest::IsExternalLocation((*ex)->location())) {
477 // See loop above for ENABLED.
478 if (ManifestURL::UpdatesFromGallery(*ex)) {
479 UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalItemState",
480 EXTERNAL_ITEM_WEBSTORE_DISABLED,
481 EXTERNAL_ITEM_MAX_ITEMS);
482 } else {
483 UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalItemState",
484 EXTERNAL_ITEM_NONWEBSTORE_DISABLED,
485 EXTERNAL_ITEM_MAX_ITEMS);
486 }
487 }
488 }
489
490 scoped_ptr<ExtensionPrefs::ExtensionsInfo> uninstalled_extensions_info(
491 extension_prefs_->GetUninstalledExtensionsInfo());
492 for (size_t i = 0; i < uninstalled_extensions_info->size(); ++i) {
493 ExtensionInfo* info = uninstalled_extensions_info->at(i).get();
494 if (Manifest::IsExternalLocation(info->extension_location)) {
495 std::string update_url;
496 if (info->extension_manifest->GetString("update_url", &update_url) &&
497 extension_urls::IsWebstoreUpdateUrl(GURL(update_url))) {
498 UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalItemState",
499 EXTERNAL_ITEM_WEBSTORE_UNINSTALLED,
500 EXTERNAL_ITEM_MAX_ITEMS);
501 } else {
502 UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalItemState",
503 EXTERNAL_ITEM_NONWEBSTORE_UNINSTALLED,
504 EXTERNAL_ITEM_MAX_ITEMS);
505 }
506 }
507 }
508
509 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadApp",
510 app_user_count + app_external_count);
511 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadAppUser", app_user_count);
512 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadAppExternal", app_external_count);
513 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadHostedApp", hosted_app_count);
514 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadPackagedApp",
515 legacy_packaged_app_count);
516 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadPlatformApp", platform_app_count);
517 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadExtension",
518 extension_user_count + extension_external_count);
519 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadExtensionUser",
520 extension_user_count);
521 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadExtensionExternal",
522 extension_external_count);
523 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadUserScript", user_script_count);
524 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadTheme", theme_count);
525 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadPageAction", page_action_count);
526 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadBrowserAction",
527 browser_action_count);
528 UMA_HISTOGRAM_COUNTS_100("Extensions.LoadContentPack", content_pack_count);
529 UMA_HISTOGRAM_COUNTS_100("Extensions.DisabledForPermissions",
530 disabled_for_permissions_count);
531 UMA_HISTOGRAM_COUNTS_100("Extensions.NonWebStoreNewTabPageOverrides",
532 non_webstore_ntp_override_count);
533 if (incognito_allowed_count + incognito_not_allowed_count > 0) {
534 UMA_HISTOGRAM_COUNTS_100("Extensions.IncognitoAllowed",
535 incognito_allowed_count);
536 UMA_HISTOGRAM_COUNTS_100("Extensions.IncognitoNotAllowed",
537 incognito_not_allowed_count);
538 }
539 if (file_access_allowed_count + file_access_not_allowed_count > 0) {
540 UMA_HISTOGRAM_COUNTS_100("Extensions.FileAccessAllowed",
541 file_access_allowed_count);
542 UMA_HISTOGRAM_COUNTS_100("Extensions.FileAccessNotAllowed",
543 file_access_not_allowed_count);
544 }
545 }
546
GetCreationFlags(const ExtensionInfo * info)547 int InstalledLoader::GetCreationFlags(const ExtensionInfo* info) {
548 int flags = extension_prefs_->GetCreationFlags(info->extension_id);
549 if (!Manifest::IsUnpackedLocation(info->extension_location))
550 flags |= Extension::REQUIRE_KEY;
551 if (extension_prefs_->AllowFileAccess(info->extension_id))
552 flags |= Extension::ALLOW_FILE_ACCESS;
553 return flags;
554 }
555
556 } // namespace extensions
557