Add Rappor reporting for grant/deny/cancel/ignore of Mediastream permissions

chrome/browser/media/media_stream_devices_controller.cc

Index: chrome/browser/media/media_stream_devices_controller.cc
diff --git a/chrome/browser/media/media_stream_devices_controller.cc b/chrome/browser/media/media_stream_devices_controller.cc
index 34ff83368a5722d46f510a75d4ae6547113eed0a..cbed7264aaef5f384f35939d8d74e1ab57be0abb 100644
--- a/chrome/browser/media/media_stream_devices_controller.cc
+++ b/chrome/browser/media/media_stream_devices_controller.cc
@@ -16,6 +16,7 @@
 #include "chrome/browser/media/media_permission.h"
 #include "chrome/browser/media/media_stream_capture_indicator.h"
 #include "chrome/browser/media/media_stream_device_permissions.h"
+#include "chrome/browser/permissions/permission_context_uma_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_switches.h"
@@ -45,14 +46,6 @@ using content::BrowserThread;
 
 namespace {
 
-enum DevicePermissionActions {
-  kAllowHttps = 0,
-  kAllowHttp,
-  kDeny,
-  kCancel,
-  kPermissionActionsMax  // Must always be last!
-};
-
 // Returns true if the given ContentSettingsType is being requested in
 // |request|.
 bool ContentTypeIsRequested(ContentSettingsType type,
@@ -69,6 +62,23 @@ bool ContentTypeIsRequested(ContentSettingsType type,
   return false;
 }
 
+using PermissionActionCallback =
+    base::Callback<void(ContentSettingsType, const GURL&)>;
+
+// Calls |action_function| for each permission requested by |request|.
+void RecordPermissionAction(const content::MediaStreamRequest& request,
+                            PermissionActionCallback callback) {
+  if (ContentTypeIsRequested(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
+                             request)) {
+    callback.Run(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
+                 request.security_origin);
+  }
+  if (ContentTypeIsRequested(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, request)) {
+    callback.Run(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
+                 request.security_origin);
+  }
+}
+
 }  // namespace
 
 MediaStreamDevicesController::MediaStreamDevicesController(
@@ -124,6 +134,8 @@ MediaStreamDevicesController::MediaStreamDevicesController(
 
 MediaStreamDevicesController::~MediaStreamDevicesController() {
   if (!callback_.is_null()) {
+    RecordPermissionAction(
+        request_, base::Bind(PermissionContextUmaUtil::PermissionIgnored));
     callback_.Run(content::MediaStreamDevices(),
                   content::MEDIA_DEVICE_FAILED_DUE_TO_SHUTDOWN,
                   scoped_ptr<content::MediaStreamUI>());
@@ -162,8 +174,8 @@ const std::string& MediaStreamDevicesController::GetSecurityOriginSpec() const {
 void MediaStreamDevicesController::ForcePermissionDeniedTemporarily() {
   base::AutoReset<bool> persist_permissions(
       &persist_permission_changes_, false);
-  UMA_HISTOGRAM_ENUMERATION("Media.DevicePermissionActions",
-                            kDeny, kPermissionActionsMax);
+  RecordPermissionAction(

[kcarattini, 2015/11/03 04:19:30]

Is this actually a user decision or is it forced by another mechanism?

[tsergeant, 2015/11/05 02:34:42]

It appears to be to do with Android Permissions not allowing a permission to be
granted.

It's possible that this is indirectly tied to a user action (ie, user Denies an
Android-level request for Camera and this bubbles down to the Chrome-level
permission request here), but I'm not actually sure.

[tsergeant, 2015/11/10 00:32:42]

As discussed, I've replaced this with a TODO while we decide how best to handle
this case.

+      request_, base::Bind(PermissionContextUmaUtil::PermissionDenied));
   RunCallback(CONTENT_SETTING_BLOCK,
               CONTENT_SETTING_BLOCK,
               content::MEDIA_DEVICE_PERMISSION_DENIED);
@@ -204,14 +216,8 @@ GURL MediaStreamDevicesController::GetRequestingHostname() const {
 }
 
 void MediaStreamDevicesController::PermissionGranted() {
-  GURL origin(GetSecurityOriginSpec());
-  if (content::IsOriginSecure(origin)) {
-    UMA_HISTOGRAM_ENUMERATION("Media.DevicePermissionActions",
-                              kAllowHttps, kPermissionActionsMax);
-  } else {
-    UMA_HISTOGRAM_ENUMERATION("Media.DevicePermissionActions",
-                              kAllowHttp, kPermissionActionsMax);
-  }
+  RecordPermissionAction(
+      request_, base::Bind(PermissionContextUmaUtil::PermissionGranted));
   RunCallback(GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
                             old_audio_setting_, CONTENT_SETTING_ALLOW),
               GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
@@ -220,8 +226,8 @@ void MediaStreamDevicesController::PermissionGranted() {
 }
 
 void MediaStreamDevicesController::PermissionDenied() {
-  UMA_HISTOGRAM_ENUMERATION("Media.DevicePermissionActions",
-                            kDeny, kPermissionActionsMax);
+  RecordPermissionAction(
+      request_, base::Bind(PermissionContextUmaUtil::PermissionDenied));
   RunCallback(GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
                             old_audio_setting_, CONTENT_SETTING_BLOCK),
               GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
@@ -230,8 +236,8 @@ void MediaStreamDevicesController::PermissionDenied() {
 }
 
 void MediaStreamDevicesController::Cancelled() {
-  UMA_HISTOGRAM_ENUMERATION("Media.DevicePermissionActions",
-                            kCancel, kPermissionActionsMax);
+  RecordPermissionAction(
+      request_, base::Bind(PermissionContextUmaUtil::PermissionDismissed));
   RunCallback(old_audio_setting_, old_video_setting_,
               content::MEDIA_DEVICE_PERMISSION_DISMISSED);
 }