Simplify RecordPermissionAction and Android permission callback

chrome/browser/media/webrtc/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/webrtc/media_stream_devices_controller.h"
 
 #include <map>
 #include <utility>
 
 #include "base/callback_helpers.h"
@@ skipping 64 matching lines @@
 
   return false;
 }
 
 using PermissionActionCallback =
     base::Callback<void(ContentSettingsType,
                         PermissionRequestGestureType,
                         const GURL&,
                         Profile*)>;
 
-void RecordSinglePermissionAction(const content::MediaStreamRequest& request,
-                                  ContentSettingsType content_type,
-                                  Profile* profile,
-                                  PermissionActionCallback callback) {
-  if (ContentTypeIsRequested(content_type, request)) {
-    // TODO(stefanocs): Pass the actual |gesture_type| once this file has been
-    // refactored into PermissionContext.
-    callback.Run(content_type, PermissionRequestGestureType::UNKNOWN,
-                 request.security_origin, profile);
+// Calls |action_callback| for each permission requested.
+void RecordPermissionAction(bool is_asking_for_audio,
+                            bool is_asking_for_video,
+                            const GURL& security_origin,
+                            Profile* profile,
+                            PermissionActionCallback action_callback) {
+  // TODO(stefanocs): Pass the actual |gesture_type| once this file has been
+  // refactored into PermissionContext.
+  if (is_asking_for_audio) {
+    action_callback.Run(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
+                        PermissionRequestGestureType::UNKNOWN, security_origin,
+                        profile);
+  }
+  if (is_asking_for_video) {
+    action_callback.Run(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
+                        PermissionRequestGestureType::UNKNOWN, 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_SETTINGS_TYPE_MEDIASTREAM_MIC,
-                               profile, callback);
-  RecordSinglePermissionAction(
-      request, CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, profile, callback);
-}
-
-#if defined(OS_ANDROID)
-// Callback for the permission update infobar when the site and Chrome
-// permissions are mismatched on Android.
-void OnPermissionConflictResolved(
-    std::unique_ptr<MediaStreamDevicesController> controller,
-    bool allowed) {
-  if (allowed)
-    controller->PermissionGranted();
-  else
-    controller->ForcePermissionDeniedTemporarily();
-}
-
-#endif  // defined(OS_ANDROID)
-
 // 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>>;
 
  public:
@@ skipping 116 matching lines @@
 void MediaStreamDevicesController::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* prefs) {
   prefs->RegisterBooleanPref(prefs::kVideoCaptureAllowed, true);
   prefs->RegisterBooleanPref(prefs::kAudioCaptureAllowed, true);
   prefs->RegisterListPref(prefs::kVideoCaptureAllowedUrls);
   prefs->RegisterListPref(prefs::kAudioCaptureAllowedUrls);
 }
 
 MediaStreamDevicesController::~MediaStreamDevicesController() {
   if (!callback_.is_null()) {
-    RecordPermissionAction(request_, profile_,
+    RecordPermissionAction(IsAskingForAudio(), IsAskingForVideo(), GetOrigin(),
+                           profile_,
                            base::Bind(PermissionUmaUtil::PermissionIgnored));
     callback_.Run(content::MediaStreamDevices(),
                   content::MEDIA_DEVICE_FAILED_DUE_TO_SHUTDOWN,
                   std::unique_ptr<content::MediaStreamUI>());
   }
 }
 
 bool MediaStreamDevicesController::IsAskingForAudio() const {
   return old_audio_setting_ == CONTENT_SETTING_ASK;
 }
 
 bool MediaStreamDevicesController::IsAskingForVideo() const {
   return old_video_setting_ == CONTENT_SETTING_ASK;
 }
 
 base::string16 MediaStreamDevicesController::GetMessageText() const {
   int message_id = IDS_MEDIA_CAPTURE_AUDIO_AND_VIDEO;
   if (!IsAskingForAudio())
     message_id = IDS_MEDIA_CAPTURE_VIDEO_ONLY;
   else if (!IsAskingForVideo())
     message_id = IDS_MEDIA_CAPTURE_AUDIO_ONLY;
   return l10n_util::GetStringFUTF16(
       message_id,
       url_formatter::FormatUrlForSecurityDisplay(
           GetOrigin(), url_formatter::SchemeDisplay::OMIT_CRYPTOGRAPHIC));
 }
 
-void MediaStreamDevicesController::ForcePermissionDeniedTemporarily() {
-  set_persist(false);
-  // TODO(tsergeant): Determine whether it is appropriate to record permission
-  // action metrics here, as this is a different sort of user action.
-  RunCallback(CONTENT_SETTING_BLOCK,
-              CONTENT_SETTING_BLOCK,
+#if defined(OS_ANDROID)
+void MediaStreamDevicesController::AndroidOSPromptAnswered(bool allowed) {
+  DCHECK(old_audio_setting_ != CONTENT_SETTING_ASK &&
+         old_video_setting_ != CONTENT_SETTING_ASK);
+
+  ContentSetting audio_setting = old_audio_setting_;
+  ContentSetting video_setting = old_video_setting_;
+
+  if (!allowed) {
+    // Only permissions that were previously ALLOW for a site will have had
+    // their android permissions requested. It's only in that case that we need
+    // to change the setting to BLOCK to reflect that it wasn't allowed.
+    if (audio_setting == CONTENT_SETTING_ALLOW)
+      audio_setting = CONTENT_SETTING_BLOCK;
+    if (video_setting == CONTENT_SETTING_ALLOW)
+      video_setting = CONTENT_SETTING_BLOCK;
+  }
+
+  RunCallback(audio_setting, video_setting,
               content::MEDIA_DEVICE_PERMISSION_DENIED);
-  set_persist(true);
 }
+#endif  // defined(OS_ANDROID)
 
 PermissionRequest::IconId MediaStreamDevicesController::GetIconId() const {
 #if defined(OS_ANDROID)
   return IsAskingForVideo() ? IDR_INFOBAR_MEDIA_STREAM_CAMERA
                             : IDR_INFOBAR_MEDIA_STREAM_MIC;
 #else
   return IsAskingForVideo() ? ui::kVideocamIcon : ui::kMicrophoneIcon;
 #endif
 }
 
 base::string16 MediaStreamDevicesController::GetMessageTextFragment() const {
   int message_id = IDS_MEDIA_CAPTURE_AUDIO_AND_VIDEO_PERMISSION_FRAGMENT;
   if (!IsAskingForAudio())
     message_id = IDS_MEDIA_CAPTURE_VIDEO_ONLY_PERMISSION_FRAGMENT;
   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_, profile_,
+  RecordPermissionAction(IsAskingForAudio(), IsAskingForVideo(), GetOrigin(),
+                         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_, profile_,
+  RecordPermissionAction(IsAskingForAudio(), IsAskingForVideo(), GetOrigin(),
+                         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);
 }
 
 bool MediaStreamDevicesController::ShouldShowPersistenceToggle() const {
   return PermissionUtil::ShouldShowPersistenceToggle();
 }
 
 void MediaStreamDevicesController::Cancelled() {
-  RecordPermissionAction(request_, profile_,
+  RecordPermissionAction(IsAskingForAudio(), IsAskingForVideo(), GetOrigin(),
+                         profile_,
                          base::Bind(PermissionUmaUtil::PermissionDismissed));
   RunCallback(old_audio_setting_, old_video_setting_,
               content::MEDIA_DEVICE_PERMISSION_DISMISSED);
 }
 
 void MediaStreamDevicesController::RequestFinished() {
   delete this;
 }
 
 PermissionRequestType MediaStreamDevicesController::GetPermissionRequestType()
@@ skipping 29 matching lines @@
 
     if (controller->IsAllowedForVideo()) {
       content_settings_types.push_back(
           CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
     }
     if (!content_settings_types.empty() &&
         PermissionUpdateInfoBarDelegate::ShouldShowPermissionInfobar(
             web_contents, content_settings_types)) {
       PermissionUpdateInfoBarDelegate::Create(
           web_contents, content_settings_types,
-          base::Bind(&OnPermissionConflictResolved, base::Passed(&controller)));
+          base::Bind(&MediaStreamDevicesController::AndroidOSPromptAnswered,
+                     base::Passed(&controller)));
     }
 #endif
     return;
   }
 
   delegate->ShowPrompt(request.user_gesture, web_contents,
                        std::move(controller));
 }
 
 MediaStreamDevicesController::MediaStreamDevicesController(
@@ skipping 319 matching lines @@
     }
   }
 
   // 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;
 }