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"

[Devlin, 2014/05/09 22:45:25]

extension_set.h

[not at google - send to devlin, 2014/05/09 22:58:56]

Done.

 #include "extensions/common/extension_l10n_util.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 144 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);
   }
 
   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]);
   UMA_HISTOGRAM_COUNTS_100("Extensions.ManifestReloadNeedsRelocalization",
                            reload_reason_counts[NEEDS_RELOCALIZATION]);
 
-  UMA_HISTOGRAM_COUNTS_100("Extensions.LoadAll",
-                           extension_registry_->enabled_extensions().size());
-  UMA_HISTOGRAM_COUNTS_100("Extensions.Disabled",
-                           extension_registry_->disabled_extensions().size());
+  const ExtensionSet& enabled = extension_registry_->enabled_extensions();
+  const ExtensionSet& disabled = extension_registry_->disabled_extensions();

[Devlin, 2014/05/09 22:45:25]

why store disabled?  Only used on line 268, right?

[not at google - send to devlin, 2014/05/09 22:58:56]

harmony. but I can revert.

+
+  UMA_HISTOGRAM_COUNTS_100("Extensions.LoadAll", enabled.size());
+  UMA_HISTOGRAM_COUNTS_100("Extensions.Disabled", disabled.size());
+
+  // Gather stats about the extensions which have/have-not been enabled for
+  // incognito and file access in chrome://extensions.
+  int incognito = 0, not_incognito = 0, file_access = 0, not_file_access = 0;

[Devlin, 2014/05/09 22:45:25]

chrome style: one variable per line.

[Devlin, 2014/05/09 22:45:25]

nit: seems like these are conceptually a size_t.

[not at google - send to devlin, 2014/05/09 22:58:56]

Done, though I'm not totally sure about this one.

+
+  for (ExtensionSet::const_iterator it = enabled.begin();

[Devlin, 2014/05/09 22:45:25]

Do we only care about enabled extensions?

[not at google - send to devlin, 2014/05/09 22:58:56]

Yeah I was thinking about this. I wasn't entirely certain and it could go either
way (i.e. the data should be fairly similar, just more exaggerated). Ultimately
I'm interested in the number of extensions each startup which the user has opted
into running in incognito mode or file:// URLs, and that means enabled.

+       it != enabled.end();
+       ++it) {
+    const Extension& e = **it;
+
+    // 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 (e.location() == Manifest::UNPACKED ||
+        !e.ShouldDisplayInExtensionSettings()) {
+      continue;
+    }
+
+    if (e.can_be_incognito_enabled()) {
+      if (util::IsIncognitoEnabled(e.id(), profile)) {
+        ++incognito;
+      } else {

[Devlin, 2014/05/09 22:45:25]

nit: no braces around single-line ifs/elses

[not at google - send to devlin, 2014/05/09 22:58:56]

haha

If you insist.

+        ++not_incognito;
+      }
+    }
+
+    if (e.wants_file_access()) {
+      if (util::AllowFileAccess(e.id(), profile)) {
+        ++file_access;
+      } else {
+        ++not_file_access;
+      }
+    }
+  }
+
+  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);
 
   UMA_HISTOGRAM_TIMES("Extensions.LoadAllTime",
                       base::TimeTicks::Now() - start_time);
 
   int app_user_count = 0;
   int app_external_count = 0;
   int hosted_app_count = 0;
   int legacy_packaged_app_count = 0;
   int platform_app_count = 0;
   int user_script_count = 0;
@@ skipping 208 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