Make installed_loader UMA less wasteful.

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/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 41 matching lines @@
   UNPACKED_DIR,  // Unpacked directory.
   NEEDS_RELOCALIZATION,  // The locale has changed since we read this extension.
   CORRUPT_PREFERENCES,  // The manifest in the preferences is corrupt.
   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,
+  BACKGROUND_PAGE_PERSISTENT,
+  EVENT_PAGE,
+  NUM_BACKGROUND_PAGE_TYPES

[Devlin, 2014/05/21 23:23:37]

nit: New enum values must go above here.

[not at google - send to devlin, 2014/05/21 23:36:05]

done and done and done

 };
 
 // Used in histogram Extensions.ExternalItemState. Values may be added, as
 // long as existing values are not changed.
 enum ExternalItemState {
   DEPRECATED_EXTERNAL_ITEM_DISABLED = 0,
   DEPRECATED_EXTERNAL_ITEM_ENABLED = 1,
   EXTERNAL_ITEM_WEBSTORE_DISABLED = 2,
   EXTERNAL_ITEM_WEBSTORE_ENABLED = 3,
   EXTERNAL_ITEM_NONWEBSTORE_DISABLED = 4,
@@ skipping 75 matching lines @@
         *info.extension_manifest,
         GetCreationFlags(&info),
         &error);
   } else {
     error = errors::kManifestUnreadable;
   }
 
   // Once installed, non-unpacked extensions cannot change their IDs (e.g., by
   // updating the 'key' field in their manifest).
   // TODO(jstritar): migrate preferences when unpacked extensions change IDs.
-  if (extension.get() && !Manifest::IsUnpackedLocation(extension->location()) &&
+  if (extension.get() &&
+      !Manifest::IsUnpackedLocation(extension->location()) &&
       info.extension_id != extension->id()) {
     error = errors::kCannotChangeExtensionID;
     extension = NULL;
-    content::RecordAction(UserMetricsAction("Extensions.IDChangedError"));
   }
 
   // Check policy on every load in case an extension was blacklisted while
   // Chrome was not running.
   const ManagementPolicy* policy = extensions::ExtensionSystem::Get(
       extension_service_->profile())->management_policy();
   if (extension.get()) {
     Extension::DisableReason disable_reason = Extension::DISABLE_NONE;
     bool force_disabled = false;
     if (!policy->UserMayLoad(extension.get(), NULL)) {
@@ skipping 41 matching lines @@
   for (size_t i = 0; i < extensions_info->size(); ++i) {
     ExtensionInfo* info = extensions_info->at(i).get();
 
     // Skip extensions that were loaded from the command-line because we don't
     // want those to persist across browser restart.
     if (info->extension_location == Manifest::COMMAND_LINE)
       continue;
 
     ManifestReloadReason reload_reason = ShouldReloadExtensionManifest(*info);
     ++reload_reason_counts[reload_reason];
-    UMA_HISTOGRAM_ENUMERATION("Extensions.ManifestReloadEnumValue",
-                              reload_reason, 100);
 
     if (reload_reason != NOT_NEEDED) {
       // Reloading an extension reads files from disk.  We do this on the
       // UI thread because reloads should be very rare, and the complexity
       // added by delaying the time when the extensions service knows about
       // all extensions is significant.  See crbug.com/37548 for details.
       // |allow_io| disables tests that file operations run on the file
       // thread.
       base::ThreadRestrictions::ScopedAllowIO allow_io;
 
@@ skipping 50 matching lines @@
   int legacy_packaged_app_count = 0;
   int platform_app_count = 0;
   int user_script_count = 0;
   int content_pack_count = 0;
   int extension_user_count = 0;
   int extension_external_count = 0;
   int theme_count = 0;
   int page_action_count = 0;
   int browser_action_count = 0;
   int disabled_for_permissions_count = 0;
-  int item_user_count = 0;
   int non_webstore_ntp_override_count = 0;
   int incognito = 0;
   int not_incognito = 0;
   int file_access = 0;
   int not_file_access = 0;
 
   const ExtensionSet& extensions = extension_registry_->enabled_extensions();
   ExtensionActionManager* extension_action_manager =
       ExtensionActionManager::Get(profile);
   for (ExtensionSet::const_iterator iter = extensions.begin();
        iter != extensions.end();
        ++iter) {
     const Extension* extension = *iter;
     Manifest::Location location = extension->location();
     Manifest::Type type = extension->GetType();
 
     // For the first few metrics, include all extensions and apps (component,
     // unpacked, etc). It's good to know these locations, and it doesn't
     // muck up any of the stats. Later, though, we want to omit component and
     // unpacked, as they are less interesting.
     if (extension->is_app())
-      UMA_HISTOGRAM_ENUMERATION("Extensions.AppLocation", location, 100);
+      UMA_HISTOGRAM_ENUMERATION(
+          "Extensions.AppLocation", location, Manifest::NUM_LOCATIONS);
     else if (extension->is_extension())
-      UMA_HISTOGRAM_ENUMERATION("Extensions.ExtensionLocation", location, 100);
+      UMA_HISTOGRAM_ENUMERATION(
+          "Extensions.ExtensionLocation", location, Manifest::NUM_LOCATIONS);
 
     if (!ManifestURL::UpdatesFromGallery(extension)) {
       UMA_HISTOGRAM_ENUMERATION(
-          "Extensions.NonWebstoreLocation", location, 100);
+          "Extensions.NonWebstoreLocation", location, Manifest::NUM_LOCATIONS);
 
       // Check for inconsistencies if the extension was supposedly installed
       // from the webstore.
       enum {
         BAD_UPDATE_URL = 0,
         // This value was a mistake. Turns out sideloaded extensions can
         // have the from_webstore bit if they update from the webstore.
         DEPRECATED_IS_EXTERNAL = 1,
       };
       if (extension->from_webstore()) {
@@ skipping 27 matching lines @@
         URLOverrides::GetChromeURLOverrides(extension).count("newtab")) {
       ++non_webstore_ntp_override_count;
     }
 
     // Don't count unpacked extensions anymore, either.
     if (Manifest::IsUnpackedLocation(location))
       continue;
 
     UMA_HISTOGRAM_ENUMERATION("Extensions.ManifestVersion",
                               extension->manifest_version(),
-                              10);
+                              10);  // TODO(kalman): Why 10 manifest versions?
 
     // We might have wanted to count legacy packaged apps here, too, since they
     // are effectively extensions. Unfortunately, it's too late, as we don't
     // want to mess up the existing stats.
     if (type == Manifest::TYPE_EXTENSION) {
       UMA_HISTOGRAM_ENUMERATION("Extensions.BackgroundPageType",
                                 GetBackgroundPageType(extension),
-                                10);
+                                NUM_BACKGROUND_PAGE_TYPES);
     }
 
     // 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);
+    UMA_HISTOGRAM_ENUMERATION(
+        "Extensions.LoadType", type, Manifest::NUM_LOAD_TYPES);
     switch (type) {
       case Manifest::TYPE_THEME:
         ++theme_count;
         break;
       case Manifest::TYPE_USER_SCRIPT:
         ++user_script_count;
         break;
       case Manifest::TYPE_HOSTED_APP:
         ++hosted_app_count;
         if (Manifest::IsExternalLocation(location)) {
@@ skipping 20 matching lines @@
         break;
       case Manifest::TYPE_EXTENSION:
       default:
         if (Manifest::IsExternalLocation(location)) {
           ++extension_external_count;
         } else {
           ++extension_user_count;
         }
         break;
     }
-    if (!Manifest::IsExternalLocation(location))
-      ++item_user_count;
 
     if (extension_action_manager->GetPageAction(*extension))
       ++page_action_count;
 
     if (extension_action_manager->GetBrowserAction(*extension))
       ++browser_action_count;
 
     if (ManagedModeInfo::IsContentPack(extension))
       ++content_pack_count;
 
@@ skipping 55 matching lines @@
                                   EXTERNAL_ITEM_WEBSTORE_UNINSTALLED,
                                   EXTERNAL_ITEM_MAX_ITEMS);
       } else {
         UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalItemState",
                                   EXTERNAL_ITEM_NONWEBSTORE_UNINSTALLED,
                                   EXTERNAL_ITEM_MAX_ITEMS);
       }
     }
   }
 
-  UMA_HISTOGRAM_COUNTS_100("Extensions.LoadAllUser", item_user_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadApp",
                            app_user_count + app_external_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadAppUser", app_user_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadAppExternal", app_external_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadHostedApp", hosted_app_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadPackagedApp",
                            legacy_packaged_app_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadPlatformApp", platform_app_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadExtension",
                            extension_user_count + extension_external_count);
@@ skipping 20 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