Add UMA to track the extensions (and friends) which have been allowed in

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"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_util.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/manifest_url_handler.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 #include "extensions/browser/api/runtime/runtime_api.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_l10n_util.h"
+#include "extensions/common/extension_set.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 
 using base::UserMetricsAction;
 using content::BrowserThread;
 
 namespace extensions {
 
@@ skipping 143 matching lines @@
     extension_prefs_->UpdateManifest(extension.get());
 
   extension_service_->AddExtension(extension.get());
 }
 
 void InstalledLoader::LoadAllExtensions() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::TimeTicks start_time = base::TimeTicks::Now();
 
+  Profile* profile = extension_service_->profile();
   scoped_ptr<ExtensionPrefs::ExtensionsInfo> extensions_info(
       extension_prefs_->GetInstalledExtensionsInfo());
 
   std::vector<int> reload_reason_counts(NUM_MANIFEST_RELOAD_REASONS, 0);
   bool should_write_prefs = false;
 
   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
@@ skipping 19 matching lines @@
       scoped_refptr<const Extension> extension(
           file_util::LoadExtension(info->extension_path,
                                    info->extension_location,
                                    GetCreationFlags(info),
                                    &error));
 
       if (!extension.get()) {
         ExtensionErrorReporter::GetInstance()->ReportLoadError(
             info->extension_path,
             error,
-            extension_service_->profile(),
+            profile,
             false);  // Be quiet.
         continue;
       }
 
       extensions_info->at(i)->extension_manifest.reset(
           static_cast<base::DictionaryValue*>(
               extension->manifest()->value()->DeepCopy()));
       should_write_prefs = true;
     }
   }
 
   for (size_t i = 0; i < extensions_info->size(); ++i) {
-    if (extensions_info->at(i)->extension_location == Manifest::COMMAND_LINE)
-      continue;
-    Load(*extensions_info->at(i), should_write_prefs);
+    if (extensions_info->at(i)->extension_location != Manifest::COMMAND_LINE)
+      Load(*extensions_info->at(i), should_write_prefs);
   }
 
   extension_service_->OnLoadedInstalledExtensions();
 
   // The histograms Extensions.ManifestReload* allow us to validate
   // the assumption that reloading manifest is a rare event.
   UMA_HISTOGRAM_COUNTS_100("Extensions.ManifestReloadNotNeeded",
                            reload_reason_counts[NOT_NEEDED]);
   UMA_HISTOGRAM_COUNTS_100("Extensions.ManifestReloadUnpackedDir",
                            reload_reason_counts[UNPACKED_DIR]);
@@ skipping 16 matching lines @@
   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();
-  ExtensionSet::const_iterator ex;
-  for (ex = extensions.begin(); ex != extensions.end(); ++ex) {
+
+  for (ExtensionSet::const_iterator ex = extensions.begin();
+       ex != extensions.end();
+       ++ex) {
     Manifest::Location location = (*ex)->location();
     Manifest::Type type = (*ex)->GetType();
     if ((*ex)->is_app()) {

[Devlin, 2014/05/09 23:29:12]

nit: I liked your const Extension* e = *iter to save us from writing *ex
everywhere.

       UMA_HISTOGRAM_ENUMERATION("Extensions.AppLocation",
                                 location, 100);
     } else if (type == Manifest::TYPE_EXTENSION) {
       UMA_HISTOGRAM_ENUMERATION("Extensions.ExtensionLocation",
                                 location, 100);
     }
     if (!ManifestURL::UpdatesFromGallery(*ex)) {
       UMA_HISTOGRAM_ENUMERATION("Extensions.NonWebstoreLocation",
                                 location, 100);
     }
@@ skipping 24 matching lines @@
       }
     }
 
     // Don't count component extensions, since they are only extensions as an
     // implementation detail.
     if (location == Manifest::COMPONENT)
       continue;
     // Histogram for non-webstore extensions overriding new tab page should
     // include unpacked extensions.
     if (!(*ex)->from_webstore()) {
       const extensions::URLOverrides::URLOverrideMap& override_map =

[Devlin, 2014/05/09 23:29:12]

don't need extensions:: prefix.

           extensions::URLOverrides::GetChromeURLOverrides(ex->get());
       if (override_map.find("newtab") != override_map.end()) {
         ++non_webstore_ntp_override_count;
       }
     }
 
     // Don't count unpacked extensions, since they're a developer-specific
     // feature.
     if (Manifest::IsUnpackedLocation(location))
       continue;
@@ skipping 30 matching lines @@
       case Manifest::TYPE_LEGACY_PACKAGED_APP:
         ++legacy_packaged_app_count;
         if (Manifest::IsExternalLocation(location)) {
           ++app_external_count;
         } else {
           ++app_user_count;
         }
         break;
       case Manifest::TYPE_PLATFORM_APP:
         ++platform_app_count;
         if (Manifest::IsExternalLocation(location)) {

[Devlin, 2014/05/09 23:29:12]

gah.
bool is_external_location = Manifest::IsExternalLocation(location);
%s/Manifest::IsExternalLocation(location)/is_external_location/gc

           ++app_external_count;
         } else {
           ++app_user_count;
         }
         break;
       case Manifest::TYPE_EXTENSION:
       default:
         if (Manifest::IsExternalLocation(location)) {
           ++extension_external_count;
         } else {
           ++extension_user_count;
         }
         break;
     }
     if (!Manifest::IsExternalLocation((*ex)->location()))

[Devlin, 2014/05/09 23:29:12]

location, not ex->location.

       ++item_user_count;
     ExtensionActionManager* extension_action_manager =

[Devlin, 2014/05/09 23:29:12]

move this outside the for-loop, so we don't have to re-get it each extension.

         ExtensionActionManager::Get(extension_service_->profile());
     if (extension_action_manager->GetPageAction(*ex->get()))
       ++page_action_count;
     if (extension_action_manager->GetBrowserAction(*ex->get()))
       ++browser_action_count;
 
     if (extensions::ManagedModeInfo::IsContentPack(ex->get()))
       ++content_pack_count;
 
     extension_service_->RecordPermissionMessagesHistogram(
         ex->get(), "Extensions.Permissions_Load");
+
+    // For incognito and file access, skip unpacked extensions because they get
+    // file access up-front, and the data isn't useful. Skip anything that
+    // doesn't appear in settings.
+    if ((*ex)->location() != Manifest::UNPACKED &&

[Devlin, 2014/05/09 23:29:12]

location, not ex->location.
Also, we already skipped all component extensions and all unpacked extensions on
line 353.

+        (*ex)->ShouldDisplayInExtensionSettings()) {
+      if ((*ex)->can_be_incognito_enabled()) {
+        if (util::IsIncognitoEnabled((*ex)->id(), profile))
+          ++incognito;
+        else
+          ++not_incognito;
+      }
+      if ((*ex)->wants_file_access()) {
+        if (util::AllowFileAccess((*ex)->id(), profile))
+          ++file_access;
+        else
+          ++not_file_access;
+      }
+    }
   }
 
   const ExtensionSet& disabled_extensions =
       extension_registry_->disabled_extensions();
-  for (ex = disabled_extensions.begin(); ex != disabled_extensions.end();
+
+  for (ExtensionSet::const_iterator ex = disabled_extensions.begin();
+       ex != disabled_extensions.end();
        ++ex) {
     if (extension_prefs_->DidExtensionEscalatePermissions((*ex)->id())) {
       ++disabled_for_permissions_count;
     }
     if (Manifest::IsExternalLocation((*ex)->location())) {
       // See loop above for ENABLED.
       if (ManifestURL::UpdatesFromGallery(*ex)) {
         UMA_HISTOGRAM_ENUMERATION("Extensions.ExternalItemState",
                                   EXTERNAL_ITEM_WEBSTORE_DISABLED,
                                   EXTERNAL_ITEM_MAX_ITEMS);
@@ skipping 42 matching lines @@
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadUserScript", user_script_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadTheme", theme_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadPageAction", page_action_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadBrowserAction",
                            browser_action_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.LoadContentPack", content_pack_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.DisabledForPermissions",
                            disabled_for_permissions_count);
   UMA_HISTOGRAM_COUNTS_100("Extensions.NonWebStoreNewTabPageOverrides",
                            non_webstore_ntp_override_count);
+  UMA_HISTOGRAM_COUNTS_100("Extensions.IncognitoAllowed", incognito);
+  UMA_HISTOGRAM_COUNTS_100("Extensions.IncognitoNotAllowed", not_incognito);
+  UMA_HISTOGRAM_COUNTS_100("Extensions.FileAccessAllowed", file_access);
+  UMA_HISTOGRAM_COUNTS_100("Extensions.FileAccessNotAllowed", not_file_access);
 }
 
 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