Permissions: Allow control of individual requests in media permission infobars

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 56 matching lines @@
 
   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&)>;
 
+void RecordSinglePermissionAction(const content::MediaStreamRequest& request,
+                                  content::PermissionType permission_type,
+                                  PermissionActionCallback callback) {
+  if (ContentTypeIsRequested(permission_type, request)) {
+    callback.Run(permission_type, request.security_origin);
+  }
+}
+
 // Calls |action_function| for each permission requested by |request|.
 void RecordPermissionAction(const content::MediaStreamRequest& request,
                             PermissionActionCallback callback) {
-  if (ContentTypeIsRequested(content::PermissionType::VIDEO_CAPTURE, request)) {
-    callback.Run(content::PermissionType::VIDEO_CAPTURE,
-                 request.security_origin);
-  }
-  if (ContentTypeIsRequested(content::PermissionType::AUDIO_CAPTURE, request)) {
-    callback.Run(content::PermissionType::AUDIO_CAPTURE,
-                 request.security_origin);
-  }
+  RecordSinglePermissionAction(request, content::PermissionType::AUDIO_CAPTURE,
+                               callback);
+  RecordSinglePermissionAction(request, content::PermissionType::VIDEO_CAPTURE,
+                               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 190 matching lines @@
 void MediaStreamDevicesController::PermissionDenied() {
   RecordPermissionAction(
       request_, 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,

[Sergey Ulanov, 2016/06/07 21:06:54]

Do we still need PermissionGranted() and PermissionDenied()?
It seems wrong to have these tree functions that all do the same thing, i.e.
handle permission request result.

[tsergeant, 2016/06/07 23:31:59]

I think they are still necessary at the moment. On Android, we'd be able to
remove them in this patch. On desktop, though, MediaStreamDevicesController ties
into the permission bubbles framework (through PermissionBubbleRequest), which
calls PermissionBubbleRequest::PermissionGranted/PermissionDenied when a
decision is made.

The plan (following on from this patch) is to have Android also use Permission
Bubbles, which will allow us to remove this function and get back to just
PermissionGranted and PermissionDenied.

+                                                          bool video_accepted) {
+  RecordSinglePermissionAction(
+      request_, content::PermissionType::AUDIO_CAPTURE,
+      base::Bind(audio_accepted ? PermissionUmaUtil::PermissionGranted
+                                : PermissionUmaUtil::PermissionDenied));
+  RecordSinglePermissionAction(
+      request_, content::PermissionType::VIDEO_CAPTURE,
+      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));
   RunCallback(old_audio_setting_, old_video_setting_,
               content::MEDIA_DEVICE_PERMISSION_DISMISSED);
 }
 
 void MediaStreamDevicesController::RequestFinished() {
   delete this;
 }
@@ skipping 307 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;
 }