Add hooks to permission layer for permission action reporting

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 <map>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 54 matching lines @@
   if (type == content::PermissionType::AUDIO_CAPTURE)
     return request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE;
 
   if (type == content::PermissionType::VIDEO_CAPTURE)
     return request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE;
 
   return false;
 }
 
 using PermissionActionCallback =
-    base::Callback<void(content::PermissionType, const GURL&)>;
+    base::Callback<void(content::PermissionType, const GURL&, Profile*)>;
 
 void RecordSinglePermissionAction(const content::MediaStreamRequest& request,
                                   content::PermissionType permission_type,
+                                  Profile* profile,
                                   PermissionActionCallback callback) {
   if (ContentTypeIsRequested(permission_type, request)) {
-    callback.Run(permission_type, request.security_origin);
+    callback.Run(permission_type, request.security_origin, profile);
   }
 }
 
 // Calls |action_function| for each permission requested by |request|.
 void RecordPermissionAction(const content::MediaStreamRequest& request,
+                            Profile* profile,
                             PermissionActionCallback callback) {
   RecordSinglePermissionAction(request, content::PermissionType::AUDIO_CAPTURE,
-                               callback);
+                               profile, callback);
   RecordSinglePermissionAction(request, content::PermissionType::VIDEO_CAPTURE,
-                               callback);
+                               profile, callback);
 }
 
 // This helper class helps to measure the number of media stream requests that
 // occur. It ensures that only one request will be recorded per navigation, per
 // frame. TODO(raymes): Remove this when https://crbug.com/526324 is fixed.
 class MediaPermissionRequestLogger : content::WebContentsObserver {
   // Map of <render process id, render frame id> ->
   // MediaPermissionRequestLogger.
   using RequestMap = std::map<std::pair<int, int>,
                               std::unique_ptr<MediaPermissionRequestLogger>>;
@@ skipping 95 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_, base::Bind(PermissionUmaUtil::PermissionIgnored));
+    RecordPermissionAction(request_, profile_,
+                           base::Bind(PermissionUmaUtil::PermissionIgnored));
     callback_.Run(content::MediaStreamDevices(),
                   content::MEDIA_DEVICE_FAILED_DUE_TO_SHUTDOWN,
                   std::unique_ptr<content::MediaStreamUI>());
   }
 }
 
 // static
 void MediaStreamDevicesController::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* prefs) {
   prefs->RegisterBooleanPref(prefs::kVideoCaptureAllowed, true);
@@ skipping 54 matching lines @@
   else if (!IsAskingForVideo())
     message_id = IDS_MEDIA_CAPTURE_AUDIO_ONLY_PERMISSION_FRAGMENT;
   return l10n_util::GetStringUTF16(message_id);
 }
 
 GURL MediaStreamDevicesController::GetOrigin() const {
   return request_.security_origin;
 }
 
 void MediaStreamDevicesController::PermissionGranted() {
-  RecordPermissionAction(
-      request_, base::Bind(PermissionUmaUtil::PermissionGranted));
+  RecordPermissionAction(request_, profile_,
+                         base::Bind(PermissionUmaUtil::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() {
-  RecordPermissionAction(
-      request_, base::Bind(PermissionUmaUtil::PermissionDenied));
+  RecordPermissionAction(request_, profile_,
+                         base::Bind(PermissionUmaUtil::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::GroupedRequestFinished(bool audio_accepted,
                                                           bool video_accepted) {
   RecordSinglePermissionAction(
-      request_, content::PermissionType::AUDIO_CAPTURE,
+      request_, content::PermissionType::AUDIO_CAPTURE, profile_,
       base::Bind(audio_accepted ? PermissionUmaUtil::PermissionGranted
                                 : PermissionUmaUtil::PermissionDenied));
   RecordSinglePermissionAction(
-      request_, content::PermissionType::VIDEO_CAPTURE,
+      request_, content::PermissionType::VIDEO_CAPTURE, profile_,
       base::Bind(video_accepted ? PermissionUmaUtil::PermissionGranted
                                 : PermissionUmaUtil::PermissionDenied));
 
   ContentSetting audio_setting =
       audio_accepted ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK;
   ContentSetting video_setting =
       video_accepted ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK;
   RunCallback(GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
                             old_audio_setting_, audio_setting),
               GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
                             old_video_setting_, video_setting),
               content::MEDIA_DEVICE_PERMISSION_DENIED);
 }
 
 void MediaStreamDevicesController::Cancelled() {
-  RecordPermissionAction(
-      request_, base::Bind(PermissionUmaUtil::PermissionDismissed));
+  RecordPermissionAction(request_, profile_,
+                         base::Bind(PermissionUmaUtil::PermissionDismissed));
   RunCallback(old_audio_setting_, old_video_setting_,
               content::MEDIA_DEVICE_PERMISSION_DISMISSED);
 }
 
 void MediaStreamDevicesController::RequestFinished() {
   delete this;
 }
 
 PermissionBubbleType MediaStreamDevicesController::GetPermissionBubbleType()
     const {
@@ skipping 295 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;
 }