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);
   }
 
   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());
+  const ExtensionSet& enabled = extension_registry_->enabled_extensions();
+
+  UMA_HISTOGRAM_COUNTS_100("Extensions.LoadAll", enabled.size());
   UMA_HISTOGRAM_COUNTS_100("Extensions.Disabled",
                            extension_registry_->disabled_extensions().size());
 
+  // Gather stats about the extensions which have/have-not been enabled for
+  // incognito and file access in chrome://extensions.
+  size_t incognito = 0;
+  size_t not_incognito = 0;

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

nit of all nits: 0u, not 0, to avoid an implicit cast.

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

Done. sort of. you're right, but right below there is a bunch of counting.
speaking of which, I'm moving it down a bit :)

+  size_t file_access = 0;
+  size_t not_file_access = 0;
+
+  for (ExtensionSet::const_iterator it = enabled.begin();
+       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
+        ++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;
   int content_pack_count = 0;
@@ skipping 207 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