Replace all enums with enum classes in permissions code.

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 13 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, action, PERMISSION_ACTION_NUM);     \
-  if (secure_origin) {                                                      \
-    UMA_HISTOGRAM_ENUMERATION(permission_secure, action,                    \
-                              PERMISSION_ACTION_NUM);                       \
-  } else {                                                                  \
-    UMA_HISTOGRAM_ENUMERATION(permission_insecure, action,                  \
-                              PERMISSION_ACTION_NUM);                       \
+#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_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))
 
 #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);                      \
   }
 
 using content::PermissionType;
 
 namespace {
 
 const std::string GetRapporMetric(ContentSettingsType permission,
                                   PermissionAction action) {
   std::string action_str;
   switch (action) {
-    case GRANTED:
+    case PermissionAction::GRANTED:
       action_str = "Granted";
       break;
-    case DENIED:
+    case PermissionAction::DENIED:
       action_str = "Denied";
       break;
-    case DISMISSED:
+    case PermissionAction::DISMISSED:
       action_str = "Dismissed";
       break;
-    case IGNORED:
+    case PermissionAction::IGNORED:
       action_str = "Ignored";
       break;
-    case REVOKED:
+    case PermissionAction::REVOKED:
       action_str = "Revoked";
       break;
     default:
       NOTREACHED();
       break;
   }
 
   std::string permission_str = PermissionUtil::GetPermissionString(permission);
   if (permission_str.empty())
     return "";
@@ skipping 179 matching lines @@
                           profile);
 }
 
 void PermissionUmaUtil::PermissionGranted(
     ContentSettingsType permission,
     PermissionRequestGestureType gesture_type,
     const GURL& requesting_origin,
     Profile* profile) {
   PermissionDecisionAutoBlocker* autoblocker =
       PermissionDecisionAutoBlocker::GetForProfile(profile);
-  RecordPermissionAction(permission, GRANTED, PermissionSourceUI::PROMPT,
-                         gesture_type, requesting_origin, profile);
+  RecordPermissionAction(permission, PermissionAction::GRANTED,
+                         PermissionSourceUI::PROMPT, gesture_type,
+                         requesting_origin, profile);
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptAcceptedPriorDismissCountPrefix,
       autoblocker->GetDismissCount(requesting_origin, permission));
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptAcceptedPriorIgnoreCountPrefix,
       autoblocker->GetIgnoreCount(requesting_origin, permission));
 }
 
 void PermissionUmaUtil::PermissionDenied(
     ContentSettingsType permission,
     PermissionRequestGestureType gesture_type,
     const GURL& requesting_origin,
     Profile* profile) {
   PermissionDecisionAutoBlocker* autoblocker =
       PermissionDecisionAutoBlocker::GetForProfile(profile);
-  RecordPermissionAction(permission, DENIED, PermissionSourceUI::PROMPT,
-                         gesture_type, requesting_origin, profile);
+  RecordPermissionAction(permission, PermissionAction::DENIED,
+                         PermissionSourceUI::PROMPT, gesture_type,
+                         requesting_origin, profile);
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptDeniedPriorDismissCountPrefix,
       autoblocker->GetDismissCount(requesting_origin, permission));
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptDeniedPriorIgnoreCountPrefix,
       autoblocker->GetIgnoreCount(requesting_origin, permission));
 }
 
 void PermissionUmaUtil::PermissionDismissed(
     ContentSettingsType permission,
     PermissionRequestGestureType gesture_type,
     const GURL& requesting_origin,
     Profile* profile) {
   PermissionDecisionAutoBlocker* autoblocker =
       PermissionDecisionAutoBlocker::GetForProfile(profile);
-  RecordPermissionAction(permission, DISMISSED, PermissionSourceUI::PROMPT,
-                         gesture_type, requesting_origin, profile);
+  RecordPermissionAction(permission, PermissionAction::DISMISSED,
+                         PermissionSourceUI::PROMPT, gesture_type,
+                         requesting_origin, profile);
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptDismissedPriorDismissCountPrefix,
       autoblocker->GetDismissCount(requesting_origin, permission));
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptDismissedPriorIgnoreCountPrefix,
       autoblocker->GetIgnoreCount(requesting_origin, permission));
 }
 
 void PermissionUmaUtil::PermissionIgnored(
     ContentSettingsType permission,
     PermissionRequestGestureType gesture_type,
     const GURL& requesting_origin,
     Profile* profile) {
   PermissionDecisionAutoBlocker* autoblocker =
       PermissionDecisionAutoBlocker::GetForProfile(profile);
-  RecordPermissionAction(permission, IGNORED, PermissionSourceUI::PROMPT,
-                         gesture_type, requesting_origin, profile);
+  RecordPermissionAction(permission, PermissionAction::IGNORED,
+                         PermissionSourceUI::PROMPT, gesture_type,
+                         requesting_origin, profile);
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptIgnoredPriorDismissCountPrefix,
       autoblocker->GetDismissCount(requesting_origin, permission));
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptIgnoredPriorIgnoreCountPrefix,
       autoblocker->GetIgnoreCount(requesting_origin, permission));
 
   // RecordPermission* methods need to be called before RecordIgnore in the
   // blocker because they record the number of prior ignore and dismiss values,
   // and we don't want to include the current ignore.
   autoblocker->RecordIgnore(requesting_origin, permission);
 }
 
 void PermissionUmaUtil::PermissionRevoked(ContentSettingsType permission,
                                           PermissionSourceUI source_ui,
                                           const GURL& revoked_origin,
                                           Profile* profile) {
   // TODO(tsergeant): Expand metrics definitions for revocation to include all
   // permissions.
   if (permission == CONTENT_SETTINGS_TYPE_NOTIFICATIONS ||
       permission == CONTENT_SETTINGS_TYPE_GEOLOCATION ||
       permission == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC ||
       permission == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA) {
     // An unknown gesture type is passed in since gesture type is only
     // applicable in prompt UIs where revocations are not possible.
-    RecordPermissionAction(permission, REVOKED, source_ui,
+    RecordPermissionAction(permission, PermissionAction::REVOKED, source_ui,
                            PermissionRequestGestureType::UNKNOWN,
                            revoked_origin, profile);
   }
 }
 
 void PermissionUmaUtil::RecordEmbargoPromptSuppression(
     PermissionEmbargoStatus embargo_status) {
   UMA_HISTOGRAM_ENUMERATION("Permissions.AutoBlocker.EmbargoPromptSuppression",
-                            embargo_status,
-                            PermissionEmbargoStatus::STATUS_NUM);
+                            static_cast<int>(embargo_status),
+                            static_cast<int>(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",
-                            embargo_status,
-                            PermissionEmbargoStatus::STATUS_NUM);
+                            static_cast<int>(embargo_status),
+                            static_cast<int>(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",
-                            response, SafeBrowsingResponse::RESPONSE_NUM);
+                            static_cast<int>(response),
+                            static_cast<int>(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;
@@ skipping 301 matching lines @@
       break;
     case CONTENT_SETTINGS_TYPE_DURABLE_STORAGE:
       PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.DurableStorage",
                             "Permissions.Action.SecureOrigin.DurableStorage",
                             "Permissions.Action.InsecureOrigin.DurableStorage",
                             action);
       break;
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC:
       // Media permissions are disabled on insecure origins, so there's no
       // need to record metrics for secure/insecue.
-      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.AudioCapture", action,
-                                PERMISSION_ACTION_NUM);
+      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.AudioCapture",
+                                static_cast<int>(action),
+                                static_cast<int>(PermissionAction::NUM));
       break;
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA:
-      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.VideoCapture", action,
-                                PERMISSION_ACTION_NUM);
+      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.VideoCapture",
+                                static_cast<int>(action),
+                                static_cast<int>(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 "
@@ skipping 13 matching lines @@
   if (!deprecated_metric.empty() && rappor_service) {
     rappor::SampleDomainAndRegistryFromGURL(rappor_service, deprecated_metric,
                                             requesting_origin);
 
     std::string rappor_metric = deprecated_metric + "2";
     rappor_service->RecordSampleString(
         rappor_metric, rappor::LOW_FREQUENCY_ETLD_PLUS_ONE_RAPPOR_TYPE,
         rappor::GetDomainAndRegistrySampleFromGURL(requesting_origin));
   }
 }