[Merge to M60] Added UMA for extension permissions used in public sessions

chrome/browser/chromeos/extensions/device_local_account_management_policy_provider.cc

 // Copyright 2013 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/chromeos/extensions/device_local_account_management_policy_provider.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <string>
 
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/grit/generated_resources.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handlers/app_isolation_info.h"
+#include "extensions/common/permissions/api_permission.h"
+#include "extensions/common/permissions/permissions_info.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace chromeos {
 
 namespace {
 
 namespace emk = extensions::manifest_keys;
 
 // Apps/extensions explicitly whitelisted for use in public sessions.
 const char* const kPublicSessionWhitelist[] = {
@@ skipping 722 matching lines @@
 }
 
 // See http://blogs.msdn.com/b/the1/archive/2004/05/07/128242.aspx for an
 // explanation of array size determination.
 template <size_t N>
 bool ArrayContains(const char* const (&char_array)[N],
                    const std::string& entry) {
   return ArrayContainsImpl(char_array, N, entry);
 }
 
+// Helper method used to log extension permissions UMA stats.
+void LogPermissionUmaStats(const std::string& permission_string) {
+  const auto* permission_info =
+      extensions::PermissionsInfo::GetInstance()->GetByName(permission_string);
+  // Not a permission.
+  if (!permission_info) return;
+
+  UMA_HISTOGRAM_SPARSE_SLOWLY("Enterprise.PublicSession.ExtensionPermissions",
+                              permission_info->id());
+}
+
 // Returns true for extensions that are considered safe for Public Sessions,
 // which among other things requires the manifest top-level entries to be
 // contained in the |kSafeManifestEntries| whitelist and all permissions to be
 // contained in |kSafePermissionStrings| or |kSafePermissionDicts|.  Otherwise
 // returns false and logs all reasons for failure.
 bool IsSafeForPublicSession(const extensions::Extension* extension) {
   bool safe = true;
   if (!extension->is_extension() &&
       !extension->is_hosted_app() &&
       !extension->is_platform_app() &&
@@ skipping 27 matching lines @@
         if (it2->GetAsDictionary(&dict_value)) {
           if (dict_value->size() != 1) {
             LOG(ERROR) << extension->id()
                        << " has dict in permission list with size "
                        << dict_value->size() << ".";
             safe = false;
             continue;
           }
           for (base::DictionaryValue::Iterator it3(*dict_value);
                !it3.IsAtEnd(); it3.Advance()) {
+            // Log permission (dictionary form).
+            LogPermissionUmaStats(it3.key());
             if (!ArrayContains(kSafePermissionDicts, it3.key())) {
               LOG(ERROR) << extension->id()
                          << " has non-whitelisted dict in permission list: "
                          << it3.key();
               safe = false;
               continue;
             }
           }
           continue;
         }
         // Try to read as string.
         std::string permission_string;
         if (!it2->GetAsString(&permission_string)) {
           LOG(ERROR) << extension->id() << ": " << it.key()
                      << " contains a token that's neither a string nor a dict.";
           safe = false;
           continue;
         }
+        // Log permission (usual, string form).
+        LogPermissionUmaStats(permission_string);
         // Accept whitelisted permissions.
         if (ArrayContains(kSafePermissionStrings, permission_string)) {
           continue;
         }
         // Web requests (origin permissions).  Don't include <all_urls> because
         // that also matches file:// schemes.
         if (base::StartsWith(permission_string, "https://",
                              base::CompareCase::SENSITIVE) ||
             base::StartsWith(permission_string, "http://",
                              base::CompareCase::SENSITIVE) ||
@@ skipping 142 matching lines @@
   if (error) {
     *error = l10n_util::GetStringFUTF16(
           IDS_EXTENSION_CANT_INSTALL_IN_DEVICE_LOCAL_ACCOUNT,
           base::UTF8ToUTF16(extension->name()),
           base::UTF8ToUTF16(extension->id()));
   }
   return false;
 }
 
 }  // namespace chromeos