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

chrome/browser/media/media_stream_devices_controller.cc

 // Copyright (c) 2012 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/media/media_stream_devices_controller.h"
 
 #include "base/auto_reset.h"
 #include "base/callback_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #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"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/public/common/origin_util.h"
 #include "extensions/common/constants.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_ANDROID)
 #include <vector>
 
 #include "chrome/browser/android/preferences/pref_service_bridge.h"
 #include "chrome/browser/permissions/permission_update_infobar_delegate_android.h"
 #include "content/public/browser/android/content_view_core.h"
 #include "ui/android/window_android.h"
 #endif  // OS_ANDROID
 
 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,
                             const content::MediaStreamRequest& request) {
   if (request.request_type == content::MEDIA_OPEN_DEVICE)
     return true;
 
   if (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC)
     return request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE;
 
   if (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA)
     return request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE;
 
   return false;
 }
 
+typedef void (*PermissionActionFunction)(ContentSettingsType, const GURL&);
+
+// Calls |action_function| for each permission requested by |request|.
+void RecordPermissionAction(const content::MediaStreamRequest& request,
+                            PermissionActionFunction action_function) {

[raymes, 2015/10/20 23:06:07]

optional: most code I see in Chrome would use a base::Callback instead of a
function pointer: 
base::Callback<void(ContentSettingsType, const GURL&)>

Then at the callsites, base::Bind(...)

[mlamouri (slow - plz ping), 2015/10/20 23:07:34]

+1. Completely missed that.

[tsergeant, 2015/10/21 02:44:49]

Done.

+  if (ContentTypeIsRequested(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
+                             request)) {
+    action_function(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
+                    request.security_origin);
+  }
+  if (ContentTypeIsRequested(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, request)) {
+    action_function(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
+                    request.security_origin);
+  }
+}
+
 }  // namespace
 
 MediaStreamDevicesController::MediaStreamDevicesController(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback)
     : web_contents_(web_contents),
       request_(request),
       callback_(callback),
       persist_permission_changes_(true) {
@@ skipping 35 matching lines @@
     return;
   }
 #endif
 
   // Otherwise we can run the callback immediately.
   RunCallback(old_audio_setting_, old_video_setting_, denial_reason);
 }
 
 MediaStreamDevicesController::~MediaStreamDevicesController() {
   if (!callback_.is_null()) {
+    RecordPermissionAction(request_,
+                           &PermissionContextUmaUtil::PermissionIgnored);
     callback_.Run(content::MediaStreamDevices(),
                   content::MEDIA_DEVICE_FAILED_DUE_TO_SHUTDOWN,
                   scoped_ptr<content::MediaStreamUI>());
   }
 }
 
 // static
 void MediaStreamDevicesController::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* prefs) {
   prefs->RegisterBooleanPref(prefs::kVideoCaptureAllowed, true);
@@ skipping 18 matching lines @@
   return old_video_setting_ == CONTENT_SETTING_ASK;
 }
 
 const std::string& MediaStreamDevicesController::GetSecurityOriginSpec() const {
   return request_.security_origin.spec();
 }
 
 void MediaStreamDevicesController::ForcePermissionDeniedTemporarily() {
   base::AutoReset<bool> persist_permissions(
       &persist_permission_changes_, false);
-  UMA_HISTOGRAM_ENUMERATION("Media.DevicePermissionActions",
-                            kDeny, kPermissionActionsMax);
+  RecordPermissionAction(request_, &PermissionContextUmaUtil::PermissionDenied);
   RunCallback(CONTENT_SETTING_BLOCK,
               CONTENT_SETTING_BLOCK,
               content::MEDIA_DEVICE_PERMISSION_DENIED);
 }
 
 int MediaStreamDevicesController::GetIconId() const {
   if (IsAskingForVideo())
     return IDR_INFOBAR_MEDIA_STREAM_CAMERA;
 
   return IDR_INFOBAR_MEDIA_STREAM_MIC;
@@ skipping 20 matching lines @@
 
 bool MediaStreamDevicesController::HasUserGesture() const {
   return request_.user_gesture;
 }
 
 GURL MediaStreamDevicesController::GetRequestingHostname() const {
   return request_.security_origin;
 }
 
 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_,
+                         &PermissionContextUmaUtil::PermissionGranted);
   RunCallback(GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
                             old_audio_setting_, CONTENT_SETTING_ALLOW),
               GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
                             old_video_setting_, CONTENT_SETTING_ALLOW),
               content::MEDIA_DEVICE_PERMISSION_DENIED);
 }
 
 void MediaStreamDevicesController::PermissionDenied() {
-  UMA_HISTOGRAM_ENUMERATION("Media.DevicePermissionActions",
-                            kDeny, kPermissionActionsMax);
+  RecordPermissionAction(request_, &PermissionContextUmaUtil::PermissionDenied);
   RunCallback(GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
                             old_audio_setting_, CONTENT_SETTING_BLOCK),
               GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
                             old_video_setting_, CONTENT_SETTING_BLOCK),
               content::MEDIA_DEVICE_PERMISSION_DENIED);
 }
 
 void MediaStreamDevicesController::Cancelled() {
-  UMA_HISTOGRAM_ENUMERATION("Media.DevicePermissionActions",
-                            kCancel, kPermissionActionsMax);
+  RecordPermissionAction(request_,
+                         &PermissionContextUmaUtil::PermissionDismissed);
   RunCallback(old_audio_setting_, old_video_setting_,
               content::MEDIA_DEVICE_PERMISSION_DISMISSED);
 }
 
 void MediaStreamDevicesController::RequestFinished() {
   delete this;
 }
 
 content::MediaStreamDevices MediaStreamDevicesController::GetDevices(
     ContentSetting audio_setting,
@@ skipping 285 matching lines @@
   if (android_permission_blocked)
     return false;
 
   // Don't approve device requests if the tab was hidden.
   // TODO(qinmin): Add a test for this. http://crbug.com/396869.
   // TODO(raymes): Shouldn't this apply to all permissions not just audio/video?
   return web_contents_->GetRenderWidgetHostView()->IsShowing();
 #endif
   return true;
 }