Remove static_casts from PermissionUmaUtil histogram calls.

chrome/browser/permissions/permission_uma_util.cc

 // Copyright 2014 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/permissions/permission_uma_util.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 12 matching lines @@
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/prefs/pref_service.h"
 #include "components/rappor/public/rappor_utils.h"
 #include "components/rappor/rappor_service_impl.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/common/origin_util.h"
 #include "url/gurl.h"
 
 // UMA keys need to be statically initialized so plain function would not
 // work. Use macros instead.
-#define PERMISSION_ACTION_UMA(secure_origin, permission, permission_secure,  \
-                              permission_insecure, action)                   \
-  UMA_HISTOGRAM_ENUMERATION(permission, static_cast<int>(action),            \
-                            static_cast<int>(PermissionAction::NUM));        \
-  if (secure_origin) {                                                       \
-    UMA_HISTOGRAM_ENUMERATION(permission_secure, static_cast<int>(action),   \
-                              static_cast<int>(PermissionAction::NUM));      \
-  } else {                                                                   \
-    UMA_HISTOGRAM_ENUMERATION(permission_insecure, static_cast<int>(action), \
-                              static_cast<int>(PermissionAction::NUM));      \
+#define PERMISSION_ACTION_UMA(secure_origin, permission, permission_secure, \
+                              permission_insecure, action)                  \
+  UMA_HISTOGRAM_ENUMERATION(permission, action, PermissionAction::NUM);     \
+  if (secure_origin) {                                                      \
+    UMA_HISTOGRAM_ENUMERATION(permission_secure, action,                    \
+                              PermissionAction::NUM);                       \
+  } else {                                                                  \
+    UMA_HISTOGRAM_ENUMERATION(permission_insecure, action,                  \
+                              PermissionAction::NUM);                       \
   }
 
 #define PERMISSION_BUBBLE_TYPE_UMA(metric_name, permission_bubble_type) \
-  UMA_HISTOGRAM_ENUMERATION(                                            \
-      metric_name,                                                      \
-      static_cast<base::HistogramBase::Sample>(permission_bubble_type), \
-      static_cast<base::HistogramBase::Sample>(PermissionRequestType::NUM))
+  UMA_HISTOGRAM_ENUMERATION(metric_name, permission_bubble_type,        \
+                            PermissionRequestType::NUM)
 
 #define PERMISSION_BUBBLE_GESTURE_TYPE_UMA(gesture_metric_name,              \
                                            no_gesture_metric_name,           \
                                            gesture_type,                     \
                                            permission_bubble_type)           \
   if (gesture_type == PermissionRequestGestureType::GESTURE) {               \
     PERMISSION_BUBBLE_TYPE_UMA(gesture_metric_name, permission_bubble_type); \
   } else if (gesture_type == PermissionRequestGestureType::NO_GESTURE) {     \
     PERMISSION_BUBBLE_TYPE_UMA(no_gesture_metric_name,                       \
                                permission_bubble_type);                      \
@@ skipping 64 matching lines @@
           rappor::LOW_FREQUENCY_ETLD_PLUS_ONE_RAPPOR_TYPE,
           rappor::GetDomainAndRegistrySampleFromGURL(requesting_origin));
     }
   }
 
   PermissionType permission;
   bool success = PermissionUtil::GetPermissionType(content_type, &permission);
   DCHECK(success);
 
   bool secure_origin = content::IsOriginSecure(requesting_origin);
-  UMA_HISTOGRAM_ENUMERATION(
-      "ContentSettings.PermissionRequested",
-      static_cast<base::HistogramBase::Sample>(permission),
-      static_cast<base::HistogramBase::Sample>(PermissionType::NUM));
+  UMA_HISTOGRAM_ENUMERATION("ContentSettings.PermissionRequested", permission,
+                            PermissionType::NUM);
   if (secure_origin) {
     UMA_HISTOGRAM_ENUMERATION(
-        "ContentSettings.PermissionRequested_SecureOrigin",
-        static_cast<base::HistogramBase::Sample>(permission),
-        static_cast<base::HistogramBase::Sample>(PermissionType::NUM));
+        "ContentSettings.PermissionRequested_SecureOrigin", permission,
+        PermissionType::NUM);
   } else {
     UMA_HISTOGRAM_ENUMERATION(
-        "ContentSettings.PermissionRequested_InsecureOrigin",
-        static_cast<base::HistogramBase::Sample>(permission),
-        static_cast<base::HistogramBase::Sample>(PermissionType::NUM));
+        "ContentSettings.PermissionRequested_InsecureOrigin", permission,
+        PermissionType::NUM);
   }
 }
 
 }  // anonymous namespace
 
 // PermissionReportInfo -------------------------------------------------------
 PermissionReportInfo::PermissionReportInfo(
     const GURL& origin,
     ContentSettingsType permission,
     PermissionAction action,
@@ skipping 165 matching lines @@
     // applicable in prompt UIs where revocations are not possible.
     RecordPermissionAction(permission, PermissionAction::REVOKED, source_ui,
                            PermissionRequestGestureType::UNKNOWN,
                            revoked_origin, profile);
   }
 }
 
 void PermissionUmaUtil::RecordEmbargoPromptSuppression(
     PermissionEmbargoStatus embargo_status) {
   UMA_HISTOGRAM_ENUMERATION("Permissions.AutoBlocker.EmbargoPromptSuppression",
-                            static_cast<int>(embargo_status),
-                            static_cast<int>(PermissionEmbargoStatus::NUM));
+                            embargo_status, PermissionEmbargoStatus::NUM);
 }
 
 void PermissionUmaUtil::RecordEmbargoPromptSuppressionFromSource(
     PermissionStatusSource source) {
   // Explicitly switch to ensure that any new PermissionStatusSource values are
   // dealt with appropriately.
   switch (source) {
     case PermissionStatusSource::MULTIPLE_DISMISSALS:
       PermissionUmaUtil::RecordEmbargoPromptSuppression(
           PermissionEmbargoStatus::REPEATED_DISMISSALS);
       break;
     case PermissionStatusSource::SAFE_BROWSING_BLACKLIST:
       PermissionUmaUtil::RecordEmbargoPromptSuppression(
           PermissionEmbargoStatus::PERMISSIONS_BLACKLISTING);
       break;
     case PermissionStatusSource::UNSPECIFIED:
     case PermissionStatusSource::KILL_SWITCH:
       // The permission wasn't under embargo, so don't record anything. We may
       // embargo it later.
       break;
   }
 }
 
 void PermissionUmaUtil::RecordEmbargoStatus(
     PermissionEmbargoStatus embargo_status) {
   UMA_HISTOGRAM_ENUMERATION("Permissions.AutoBlocker.EmbargoStatus",
-                            static_cast<int>(embargo_status),
-                            static_cast<int>(PermissionEmbargoStatus::NUM));
+                            embargo_status, PermissionEmbargoStatus::NUM);
 }
 
 void PermissionUmaUtil::RecordSafeBrowsingResponse(
     base::TimeDelta response_time,
     SafeBrowsingResponse response) {
   UMA_HISTOGRAM_TIMES("Permissions.AutoBlocker.SafeBrowsingResponseTime",
                       response_time);
   UMA_HISTOGRAM_ENUMERATION("Permissions.AutoBlocker.SafeBrowsingResponse",
-                            static_cast<int>(response),
-                            static_cast<int>(SafeBrowsingResponse::NUM));
+                            response, SafeBrowsingResponse::NUM);
 }
 
 void PermissionUmaUtil::PermissionPromptShown(
     const std::vector<PermissionRequest*>& requests) {
   DCHECK(!requests.empty());
 
   PermissionRequestType permission_prompt_type =
       PermissionRequestType::MULTIPLE;
   PermissionRequestGestureType permission_gesture_type =
       PermissionRequestGestureType::UNKNOWN;
   if (requests.size() == 1) {
     permission_prompt_type = requests[0]->GetPermissionRequestType();
     permission_gesture_type = requests[0]->GetGestureType();
   }
 
   RecordPermissionPromptShown(permission_prompt_type, permission_gesture_type);
 
-  UMA_HISTOGRAM_ENUMERATION(
-      kPermissionsPromptRequestsPerPrompt,
-      static_cast<base::HistogramBase::Sample>(requests.size()),
-      static_cast<base::HistogramBase::Sample>(10));
+  UMA_HISTOGRAM_ENUMERATION(kPermissionsPromptRequestsPerPrompt,
+                            requests.size(), 10);
 
   if (requests.size() > 1) {
     for (const auto* request : requests) {
       PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptMergedBubbleTypes,
                                  request->GetPermissionRequestType());
     }
   }
 }
 
 void PermissionUmaUtil::PermissionPromptAccepted(
@@ skipping 245 matching lines @@
         ->ui_manager()->ReportPermissionAction(report_info);
   }
 
   bool secure_origin = content::IsOriginSecure(requesting_origin);
 
   switch (permission) {
     // Geolocation, MidiSysEx, Push, Durable Storage, and Media permissions are
     // disabled on insecure origins, so there's no need to record metrics for
     // secure/insecue.
     case CONTENT_SETTINGS_TYPE_GEOLOCATION:
-      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.Geolocation",
-                                static_cast<int>(action),
-                                static_cast<int>(PermissionAction::NUM));
+      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.Geolocation", action,
+                                PermissionAction::NUM);
       break;
     case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.Notifications",
                             "Permissions.Action.SecureOrigin.Notifications",
                             "Permissions.Action.InsecureOrigin.Notifications",
                             action);
       break;
     case CONTENT_SETTINGS_TYPE_MIDI_SYSEX:
-      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.MidiSysEx",
-                                static_cast<int>(action),
-                                static_cast<int>(PermissionAction::NUM));
+      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.MidiSysEx", action,
+                                PermissionAction::NUM);
       break;
     case CONTENT_SETTINGS_TYPE_PUSH_MESSAGING:
-      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.PushMessaging",
-                                static_cast<int>(action),
-                                static_cast<int>(PermissionAction::NUM));
+      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.PushMessaging", action,
+                                PermissionAction::NUM);
       break;
     case CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER:
       PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.ProtectedMedia",
                             "Permissions.Action.SecureOrigin.ProtectedMedia",
                             "Permissions.Action.InsecureOrigin.ProtectedMedia",
                             action);
       break;
     case CONTENT_SETTINGS_TYPE_DURABLE_STORAGE:
-      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.DurableStorage",
-                                static_cast<int>(action),
-                                static_cast<int>(PermissionAction::NUM));
+      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.DurableStorage", action,
+                                PermissionAction::NUM);
       break;
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC:
-      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.AudioCapture",
-                                static_cast<int>(action),
-                                static_cast<int>(PermissionAction::NUM));
+      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.AudioCapture", action,
+                                PermissionAction::NUM);
       break;
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA:
-      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.VideoCapture",
-                                static_cast<int>(action),
-                                static_cast<int>(PermissionAction::NUM));
+      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.VideoCapture", action,
+                                PermissionAction::NUM);
       break;
     case CONTENT_SETTINGS_TYPE_PLUGINS:
       PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.Flash",
                             "Permissions.Action.SecureOrigin.Flash",
                             "Permissions.Action.InsecureOrigin.Flash", action);
       break;
     // The user is not prompted for these permissions, thus there is no
     // permission action recorded for them.
     default:
       NOTREACHED() << "PERMISSION "
                    << PermissionUtil::GetPermissionString(permission)
                    << " not accounted for";
   }
 
   const std::string rappor_metric = GetRapporMetric(permission, action);
   rappor::RapporServiceImpl* rappor_service =
       g_browser_process->rappor_service();
   if (!rappor_metric.empty() && rappor_service) {
     rappor_service->RecordSampleString(
         rappor_metric, rappor::LOW_FREQUENCY_ETLD_PLUS_ONE_RAPPOR_TYPE,
         rappor::GetDomainAndRegistrySampleFromGURL(requesting_origin));
   }
 }