Replace PermissionType in chrome/ with ContentSettingsType

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 44 matching lines @@
     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(PermissionType permission,
+const std::string GetRapporMetric(ContentSettingsType permission,
                                   PermissionAction action) {
   std::string action_str;
   switch (action) {
     case GRANTED:
       action_str = "Granted";
       break;
     case DENIED:
       action_str = "Denied";
       break;
     case DISMISSED:
@@ skipping 104 matching lines @@
         static_cast<base::HistogramBase::Sample>(permission),
         static_cast<base::HistogramBase::Sample>(PermissionType::NUM));
   }
 }
 
 }  // anonymous namespace
 
 // PermissionReportInfo -------------------------------------------------------
 PermissionReportInfo::PermissionReportInfo(
     const GURL& origin,
-    PermissionType permission,
+    ContentSettingsType permission,
     PermissionAction action,
     PermissionSourceUI source_ui,
     PermissionRequestGestureType gesture_type,
     PermissionPersistDecision persist_decision,
     int num_prior_dismissals,
     int num_prior_ignores)
     : origin(origin), permission(permission), action(action),
       source_ui(source_ui), gesture_type(gesture_type),
       persist_decision(persist_decision),
       num_prior_dismissals(num_prior_dismissals),
@@ skipping 50 matching lines @@
         "Permissions.Prompt.Dismissed.PriorIgnoreCount.";
 const char
     PermissionUmaUtil::kPermissionsPromptIgnoredPriorDismissCountPrefix[] =
         "Permissions.Prompt.Ignored.PriorDismissCount.";
 const char
     PermissionUmaUtil::kPermissionsPromptIgnoredPriorIgnoreCountPrefix[] =
         "Permissions.Prompt.Ignored.PriorIgnoreCount.";
 
 // Make sure you update histograms.xml permission histogram_suffix if you
 // add new permission
 void PermissionUmaUtil::PermissionRequested(PermissionType permission,

[raymes, 2017/02/07 04:46:15]

Is this version of the function still used externally? If not we could make it
private.

[Timothy Loh, 2017/02/08 04:01:06]

This one is used by PermissionManager::RequestPermissions for the MIDI case.

[raymes, 2017/02/09 00:39:56]

I see, so I guess we should be able to remove it when we add MIDI

                                             const GURL& requesting_origin,
                                             const GURL& embedding_origin,
                                             Profile* profile) {
   RecordPermissionRequest(permission, requesting_origin, embedding_origin,
                           profile);
 }
 
+void PermissionUmaUtil::PermissionRequested(ContentSettingsType content_type,
+                                            const GURL& requesting_origin,
+                                            const GURL& embedding_origin,
+                                            Profile* profile) {
+  PermissionType permission;
+  CHECK(PermissionUtil::GetPermissionType(content_type, &permission));
+  RecordPermissionRequest(permission, requesting_origin, embedding_origin,
+                          profile);
+}
+
 void PermissionUmaUtil::PermissionGranted(
-    PermissionType permission,
+    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);
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptAcceptedPriorDismissCountPrefix,
       autoblocker->GetDismissCount(requesting_origin, permission));
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptAcceptedPriorIgnoreCountPrefix,
       autoblocker->GetIgnoreCount(requesting_origin, permission));
 }
 
 void PermissionUmaUtil::PermissionDenied(
-    PermissionType permission,
+    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);
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptDeniedPriorDismissCountPrefix,
       autoblocker->GetDismissCount(requesting_origin, permission));
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptDeniedPriorIgnoreCountPrefix,
       autoblocker->GetIgnoreCount(requesting_origin, permission));
 }
 
 void PermissionUmaUtil::PermissionDismissed(
-    PermissionType permission,
+    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);
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptDismissedPriorDismissCountPrefix,
       autoblocker->GetDismissCount(requesting_origin, permission));
   RecordPermissionPromptPriorCount(
       permission, kPermissionsPromptDismissedPriorIgnoreCountPrefix,
       autoblocker->GetIgnoreCount(requesting_origin, permission));
 }
 
 void PermissionUmaUtil::PermissionIgnored(
-    PermissionType permission,
+    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);
   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(PermissionType 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 == PermissionType::NOTIFICATIONS ||
-      permission == PermissionType::GEOLOCATION ||
-      permission == PermissionType::AUDIO_CAPTURE ||
-      permission == PermissionType::VIDEO_CAPTURE) {
+  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,
                            PermissionRequestGestureType::UNKNOWN,
                            revoked_origin, profile);
   }
 }
 
 void PermissionUmaUtil::PermissionPromptShown(
     const std::vector<PermissionRequest*>& requests) {
@@ skipping 89 matching lines @@
 void PermissionUmaUtil::RecordPermissionPromptDenied(
     PermissionRequestType request_type,
     PermissionRequestGestureType gesture_type) {
   PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptDenied, request_type);
   PERMISSION_BUBBLE_GESTURE_TYPE_UMA(kPermissionsPromptDeniedGesture,
                                      kPermissionsPromptDeniedNoGesture,
                                      gesture_type, request_type);
 }
 
 void PermissionUmaUtil::RecordPermissionPromptPriorCount(
-    content::PermissionType permission,
+    ContentSettingsType permission,
     const std::string& prefix,
     int count) {
-  // The user is not prompted for these permissions, thus there is no prompt
+  // The user is not prompted for this permissions, thus there is no prompt
   // event to record a prior count for.
-  DCHECK_NE(PermissionType::MIDI, permission);
-  DCHECK_NE(PermissionType::BACKGROUND_SYNC, permission);
-  DCHECK_NE(PermissionType::NUM, permission);
+  DCHECK_NE(CONTENT_SETTINGS_TYPE_BACKGROUND_SYNC, permission);
 
   // Expand UMA_HISTOGRAM_COUNTS_100 so that we can use a dynamically suffixed
   // histogram name.
   base::Histogram::FactoryGet(
       prefix + PermissionUtil::GetPermissionString(permission), 1, 100, 50,
       base::HistogramBase::kUmaTargetedHistogramFlag)
       ->Add(count);
 }
 
 void PermissionUmaUtil::PermissionPromptAcceptedWithPersistenceToggle(
-    content::PermissionType permission,
+    ContentSettingsType permission,
     bool toggle_enabled) {
   switch (permission) {
-    case PermissionType::GEOLOCATION:
+    case CONTENT_SETTINGS_TYPE_GEOLOCATION:
       UMA_HISTOGRAM_BOOLEAN("Permissions.Prompt.Accepted.Persisted.Geolocation",
                             toggle_enabled);
       break;
-    case PermissionType::NOTIFICATIONS:
+    case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       UMA_HISTOGRAM_BOOLEAN(
           "Permissions.Prompt.Accepted.Persisted.Notifications",
           toggle_enabled);
       break;
-    case PermissionType::MIDI_SYSEX:
+    case CONTENT_SETTINGS_TYPE_MIDI_SYSEX:
       UMA_HISTOGRAM_BOOLEAN("Permissions.Prompt.Accepted.Persisted.MidiSysEx",
                             toggle_enabled);
       break;
-    case PermissionType::PUSH_MESSAGING:
+    case CONTENT_SETTINGS_TYPE_PUSH_MESSAGING:
       UMA_HISTOGRAM_BOOLEAN(
           "Permissions.Prompt.Accepted.Persisted.PushMessaging",
           toggle_enabled);
       break;
-    case PermissionType::PROTECTED_MEDIA_IDENTIFIER:
+    case CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER:
       UMA_HISTOGRAM_BOOLEAN(
           "Permissions.Prompt.Accepted.Persisted.ProtectedMedia",
           toggle_enabled);
       break;
-    case PermissionType::DURABLE_STORAGE:
+    case CONTENT_SETTINGS_TYPE_DURABLE_STORAGE:
       UMA_HISTOGRAM_BOOLEAN(
           "Permissions.Prompt.Accepted.Persisted.DurableStorage",
           toggle_enabled);
       break;
-    case PermissionType::AUDIO_CAPTURE:
+    case CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC:
       UMA_HISTOGRAM_BOOLEAN(
           "Permissions.Prompt.Accepted.Persisted.AudioCapture", toggle_enabled);
       break;
-    case PermissionType::VIDEO_CAPTURE:
+    case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA:
       UMA_HISTOGRAM_BOOLEAN(
           "Permissions.Prompt.Accepted.Persisted.VideoCapture", toggle_enabled);
       break;
-    case PermissionType::FLASH:
+    case CONTENT_SETTINGS_TYPE_PLUGINS:
       UMA_HISTOGRAM_BOOLEAN("Permissions.Prompt.Accepted.Persisted.Flash",
                             toggle_enabled);
       break;
     // The user is not prompted for these permissions, thus there is no accept
     // recorded for them.
-    case PermissionType::MIDI:
-    case PermissionType::BACKGROUND_SYNC:
-    case PermissionType::NUM:
+    default:
       NOTREACHED() << "PERMISSION "
                    << PermissionUtil::GetPermissionString(permission)
                    << " not accounted for";
   }
 }
 
 void PermissionUmaUtil::PermissionPromptDeniedWithPersistenceToggle(
-    content::PermissionType permission,
+    ContentSettingsType permission,
     bool toggle_enabled) {
   switch (permission) {
-    case PermissionType::GEOLOCATION:
+    case CONTENT_SETTINGS_TYPE_GEOLOCATION:
       UMA_HISTOGRAM_BOOLEAN("Permissions.Prompt.Denied.Persisted.Geolocation",
                             toggle_enabled);
       break;
-    case PermissionType::NOTIFICATIONS:
+    case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       UMA_HISTOGRAM_BOOLEAN("Permissions.Prompt.Denied.Persisted.Notifications",
                             toggle_enabled);
       break;
-    case PermissionType::MIDI_SYSEX:
+    case CONTENT_SETTINGS_TYPE_MIDI_SYSEX:
       UMA_HISTOGRAM_BOOLEAN("Permissions.Prompt.Denied.Persisted.MidiSysEx",
                             toggle_enabled);
       break;
-    case PermissionType::PUSH_MESSAGING:
+    case CONTENT_SETTINGS_TYPE_PUSH_MESSAGING:
       UMA_HISTOGRAM_BOOLEAN("Permissions.Prompt.Denied.Persisted.PushMessaging",
                             toggle_enabled);
       break;
-    case PermissionType::PROTECTED_MEDIA_IDENTIFIER:
+    case CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER:
       UMA_HISTOGRAM_BOOLEAN(
           "Permissions.Prompt.Denied.Persisted.ProtectedMedia", toggle_enabled);
       break;
-    case PermissionType::DURABLE_STORAGE:
+    case CONTENT_SETTINGS_TYPE_DURABLE_STORAGE:
       UMA_HISTOGRAM_BOOLEAN(
           "Permissions.Prompt.Denied.Persisted.DurableStorage", toggle_enabled);
       break;
-    case PermissionType::AUDIO_CAPTURE:
+    case CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC:
       UMA_HISTOGRAM_BOOLEAN("Permissions.Prompt.Denied.Persisted.AudioCapture",
                             toggle_enabled);
       break;
-    case PermissionType::VIDEO_CAPTURE:
+    case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA:
       UMA_HISTOGRAM_BOOLEAN("Permissions.Prompt.Denied.Persisted.VideoCapture",
                             toggle_enabled);
       break;
-    case PermissionType::FLASH:
+    case CONTENT_SETTINGS_TYPE_PLUGINS:
       UMA_HISTOGRAM_BOOLEAN("Permissions.Prompt.Denied.Persisted.Flash",
                             toggle_enabled);
       break;
     // The user is not prompted for these permissions, thus there is no deny
     // recorded for them.
-    case PermissionType::MIDI:
-    case PermissionType::BACKGROUND_SYNC:
-    case PermissionType::NUM:
+    default:
       NOTREACHED() << "PERMISSION "
                    << PermissionUtil::GetPermissionString(permission)
                    << " not accounted for";
   }
 }
 
 bool PermissionUmaUtil::IsOptedIntoPermissionActionReporting(Profile* profile) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePermissionActionReporting)) {
     return false;
@@ skipping 25 matching lines @@
       profile_sync_service->GetPreferredDataTypes();
   if (!(preferred_data_types.Has(syncer::PROXY_TABS) &&
         preferred_data_types.Has(syncer::PRIORITY_PREFERENCES))) {
     return false;
   }
 
   return true;
 }
 
 void PermissionUmaUtil::RecordPermissionAction(
-    PermissionType permission,
+    ContentSettingsType permission,
     PermissionAction action,
     PermissionSourceUI source_ui,
     PermissionRequestGestureType gesture_type,
     const GURL& requesting_origin,
     Profile* profile) {
   if (IsOptedIntoPermissionActionReporting(profile)) {
     PermissionDecisionAutoBlocker* autoblocker =
         PermissionDecisionAutoBlocker::GetForProfile(profile);
     // TODO(kcarattini): Pass in the actual persist decision when it becomes
     // available.
     PermissionReportInfo report_info(
         requesting_origin, permission, action, source_ui, gesture_type,
         PermissionPersistDecision::UNSPECIFIED,
         autoblocker->GetDismissCount(requesting_origin, permission),
         autoblocker->GetIgnoreCount(requesting_origin, permission));
     g_browser_process->safe_browsing_service()
         ->ui_manager()->ReportPermissionAction(report_info);
   }
 
   bool secure_origin = content::IsOriginSecure(requesting_origin);
 
   switch (permission) {
-    case PermissionType::GEOLOCATION:
+    case CONTENT_SETTINGS_TYPE_GEOLOCATION:
       PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.Geolocation",
                             "Permissions.Action.SecureOrigin.Geolocation",
                             "Permissions.Action.InsecureOrigin.Geolocation",
                             action);
       break;
-    case PermissionType::NOTIFICATIONS:
+    case CONTENT_SETTINGS_TYPE_NOTIFICATIONS:
       PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.Notifications",
                             "Permissions.Action.SecureOrigin.Notifications",
                             "Permissions.Action.InsecureOrigin.Notifications",
                             action);
       break;
-    case PermissionType::MIDI_SYSEX:
+    case CONTENT_SETTINGS_TYPE_MIDI_SYSEX:
       PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.MidiSysEx",
                             "Permissions.Action.SecureOrigin.MidiSysEx",
                             "Permissions.Action.InsecureOrigin.MidiSysEx",
                             action);
       break;
-    case PermissionType::PUSH_MESSAGING:
+    case CONTENT_SETTINGS_TYPE_PUSH_MESSAGING:
       PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.PushMessaging",
                             "Permissions.Action.SecureOrigin.PushMessaging",
                             "Permissions.Action.InsecureOrigin.PushMessaging",
                             action);
       break;
-    case PermissionType::PROTECTED_MEDIA_IDENTIFIER:
+    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 PermissionType::DURABLE_STORAGE:
+    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 PermissionType::AUDIO_CAPTURE:
+    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);
       break;
-    case PermissionType::VIDEO_CAPTURE:
+    case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA:
       UMA_HISTOGRAM_ENUMERATION("Permissions.Action.VideoCapture", action,
                                 PERMISSION_ACTION_NUM);
       break;
-    case PermissionType::FLASH:
+    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.
-    case PermissionType::MIDI:
-    case PermissionType::BACKGROUND_SYNC:
-    case PermissionType::NUM:
+    default:
       NOTREACHED() << "PERMISSION "
                    << PermissionUtil::GetPermissionString(permission)
                    << " not accounted for";
   }
 
   // Retrieve the name of the RAPPOR metric. Currently, the new metric name is
   // the deprecated name with "2" on the end, e.g.
   // ContentSettings.PermissionActions_Geolocation.Granted.Url2. For simplicity,
   // we retrieve the deprecated name and append the "2" for the new name.
   // TODO(dominickn): remove the deprecated metric and replace it solely with
   // the new one in GetRapporMetric - crbug.com/605836.
   const std::string deprecated_metric = GetRapporMetric(permission, action);
   rappor::RapporServiceImpl* rappor_service =
       g_browser_process->rappor_service();
   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));
   }
 }