Collect UMA data for extension manifest version and background page type.

chrome/browser/extensions/installed_loader.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/installed_loader.h"
 
 #include "base/files/file_path.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/runtime/runtime_api.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/management_policy.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/managed_mode_private/managed_mode_handler.h"
+#include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 
 using content::BrowserThread;
 using content::UserMetricsAction;
 using extensions::Extension;
 using extensions::ExtensionInfo;
 using extensions::Manifest;
 
 namespace errors = extension_manifest_errors;
 
+namespace extensions {
+
 namespace {
 
 // The following enumeration is used in histograms matching
 // Extensions.ManifestReload* .  Values may be added, as long as existing
 // values are not changed.
 enum ManifestReloadReason {
   NOT_NEEDED = 0,  // Reload not needed.
   UNPACKED_DIR,  // Unpacked directory.
   NEEDS_RELOCALIZATION,  // The locale has changed since we read this extension.
   NUM_MANIFEST_RELOAD_REASONS
 };
 
+// Used in histogram Extension.BackgroundPageType. Values may be added, as
+// long as existing values are not changed.
+enum BackgroundPageType {
+  NO_BACKGROUND_PAGE = 0,
+  BACKGROUND_PAGE_PERSISTENT = 1,
+  EVENT_PAGE = 2,
+};
+
 ManifestReloadReason ShouldReloadExtensionManifest(const ExtensionInfo& info) {
   // Always reload manifests of unpacked extensions, because they can change
   // on disk independent of the manifest in our prefs.
   if (Manifest::IsUnpackedLocation(info.extension_location))
     return UNPACKED_DIR;
 
   // Reload the manifest if it needs to be relocalized.
   if (extension_l10n_util::ShouldRelocalizeManifest(
           info.extension_manifest.get()))
     return NEEDS_RELOCALIZATION;
 
   return NOT_NEEDED;
 }
 
+BackgroundPageType GetBackgroundPageType(const Extension* extension) {
+  if (!BackgroundInfo::HasBackgroundPage(extension))
+    return NO_BACKGROUND_PAGE;
+  if (BackgroundInfo::HasPersistentBackgroundPage(extension))
+    return BACKGROUND_PAGE_PERSISTENT;
+  return EVENT_PAGE;
+}
+
 void DispatchOnInstalledEvent(
     Profile* profile,
     const std::string& extension_id,
     const Version& old_version,
     bool chrome_updated) {
   // profile manager can be NULL in unit tests.
   if (!g_browser_process->profile_manager())
     return;
   if (!g_browser_process->profile_manager()->IsValidProfile(profile))
     return;
 
   extensions::RuntimeEventRouter::DispatchOnInstalledEvent(
       profile, extension_id, old_version, chrome_updated);
 }
 
 }  // namespace
 
-namespace extensions {
-
 InstalledLoader::InstalledLoader(ExtensionService* extension_service)
     : extension_service_(extension_service),
       extension_prefs_(extension_service->extension_prefs()) {
 }
 
 InstalledLoader::~InstalledLoader() {
 }
 
 void InstalledLoader::Load(const ExtensionInfo& info, bool write_to_prefs) {
   std::string error;
@@ skipping 179 matching lines @@
     // Don't count component extensions, since they are only extensions as an
     // implementation detail.
     if (location == Manifest::COMPONENT)
       continue;
 
     // Don't count unpacked extensions, since they're a developer-specific
     // feature.
     if (Manifest::IsUnpackedLocation(location))
       continue;
 
+    UMA_HISTOGRAM_ENUMERATION("Extensions.ManifestVersion",
+                              (*ex)->manifest_version(), 10);
+
+    if (type == Manifest::TYPE_EXTENSION) {
+      BackgroundPageType background_page_type = GetBackgroundPageType(*ex);
+      UMA_HISTOGRAM_ENUMERATION("Extensions.BackgroundPageType",
+                                background_page_type, 10);
+    }
+
     // Using an enumeration shows us the total installed ratio across all users.
     // Using the totals per user at each startup tells us the distribution of
     // usage for each user (e.g. 40% of users have at least one app installed).
     UMA_HISTOGRAM_ENUMERATION("Extensions.LoadType", type, 100);
     switch (type) {
       case Manifest::TYPE_THEME:
         ++theme_count;
         break;
       case Manifest::TYPE_USER_SCRIPT:
         ++user_script_count;
@@ skipping 84 matching lines @@
 int InstalledLoader::GetCreationFlags(const ExtensionInfo* info) {
   int flags = extension_prefs_->GetCreationFlags(info->extension_id);
   if (!Manifest::IsUnpackedLocation(info->extension_location))
     flags |= Extension::REQUIRE_KEY;
   if (extension_prefs_->AllowFileAccess(info->extension_id))
     flags |= Extension::ALLOW_FILE_ACCESS;
   return flags;
 }
 
 }  // namespace extensions