Pull code associated with a Media PermissionRequest out of MediaStreamDevicesController

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 172 matching lines @@
   // device id is non-empty, then the corresponding device list must not be
   // NULL.
   if (!device_id.empty() && !devices->FindById(device_id))
     return false;
 
   return true;
 }
 
 }  // namespace
 
+MediaStreamDevicesController::Request::Request(
+    Profile* profile,
+    bool is_asking_for_audio,
+    bool is_asking_for_video,
+    const GURL& security_origin,
+    PromptAnsweredCallback prompt_answered_callback)
+    : profile_(profile),
+      is_asking_for_audio_(is_asking_for_audio),
+      is_asking_for_video_(is_asking_for_video),
+      security_origin_(security_origin),
+      prompt_answered_callback_(prompt_answered_callback) {}
+
+MediaStreamDevicesController::Request::~Request() {
+  RecordPermissionAction(is_asking_for_audio_, is_asking_for_video_,

[Timothy Loh, 2017/04/20 03:13:20]

I think this needs to be guarded somehow otherwise we're going to record ignores
for every request.

[raymes, 2017/04/20 04:23:37]

Thanks, good catch! Done.

+                         security_origin_, profile_,
+                         base::Bind(PermissionUmaUtil::PermissionIgnored));
+}
+
+bool MediaStreamDevicesController::Request::IsAskingForAudio() const {
+  return is_asking_for_audio_;
+}
+
+bool MediaStreamDevicesController::Request::IsAskingForVideo() const {
+  return is_asking_for_video_;
+}
+
+base::string16 MediaStreamDevicesController::Request::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));
+}
+
+PermissionRequest::IconId MediaStreamDevicesController::Request::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::Request::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::Request::GetOrigin() const {
+  return security_origin_;
+}
+
+void MediaStreamDevicesController::Request::PermissionGranted() {
+  RecordPermissionAction(is_asking_for_audio_, is_asking_for_video_,
+                         security_origin_, profile_,
+                         base::Bind(PermissionUmaUtil::PermissionGranted));
+  prompt_answered_callback_.Run(CONTENT_SETTING_ALLOW, persist());
+}
+
+void MediaStreamDevicesController::Request::PermissionDenied() {
+  RecordPermissionAction(is_asking_for_audio_, is_asking_for_video_,
+                         security_origin_, profile_,
+                         base::Bind(PermissionUmaUtil::PermissionDenied));
+  prompt_answered_callback_.Run(CONTENT_SETTING_BLOCK, persist());
+}
+
+void MediaStreamDevicesController::Request::Cancelled() {
+  RecordPermissionAction(is_asking_for_audio_, is_asking_for_video_,
+                         security_origin_, profile_,
+                         base::Bind(PermissionUmaUtil::PermissionDismissed));
+  prompt_answered_callback_.Run(CONTENT_SETTING_ASK, false /* persist */);
+}
+
+void MediaStreamDevicesController::Request::RequestFinished() {
+  delete this;
+}
+
+PermissionRequestType
+MediaStreamDevicesController::Request::GetPermissionRequestType() const {
+  return PermissionRequestType::MEDIA_STREAM;
+}
+
+bool MediaStreamDevicesController::Request::ShouldShowPersistenceToggle()
+    const {
+  return PermissionUtil::ShouldShowPersistenceToggle();
+}
+
 // Implementation of PermissionPromptDelegate which actually shows a permission
 // prompt.
 class MediaStreamDevicesController::PermissionPromptDelegateImpl
-    : public internal::PermissionPromptDelegate {
+    : public MediaStreamDevicesController::PermissionPromptDelegate {
  public:
   void ShowPrompt(
       bool user_gesture,
       content::WebContents* web_contents,
-      std::unique_ptr<MediaStreamDevicesController> controller) override {
+      std::unique_ptr<MediaStreamDevicesController::Request> request) override {
 #if defined(OS_ANDROID)
     PermissionUmaUtil::RecordPermissionPromptShown(
-        controller->GetPermissionRequestType(),
+        request->GetPermissionRequestType(),
         PermissionUtil::GetGestureType(user_gesture));
     if (PermissionDialogDelegate::ShouldShowDialog(user_gesture)) {
       PermissionDialogDelegate::CreateMediaStreamDialog(
-          web_contents, user_gesture, std::move(controller));
+          web_contents, user_gesture, std::move(request));
     } else {
       MediaStreamInfoBarDelegateAndroid::Create(web_contents, user_gesture,
-                                                std::move(controller));
+                                                std::move(request));
     }
 #else
     PermissionRequestManager* permission_request_manager =
         PermissionRequestManager::FromWebContents(web_contents);
     if (permission_request_manager)
-      permission_request_manager->AddRequest(controller.release());
+      permission_request_manager->AddRequest(request.release());
 #endif
   }
 };
 
 // static
 void MediaStreamDevicesController::RequestPermissions(
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback) {
   PermissionPromptDelegateImpl delegate;
   RequestPermissionsWithDelegate(request, callback, &delegate);
 }
 
 // static
 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(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::PromptAnswered(ContentSetting setting,
+                                                  bool persist) {
+  ContentSetting audio_setting = GetNewSetting(
+      CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, old_audio_setting_, setting);
+  ContentSetting video_setting = GetNewSetting(
+      CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, old_video_setting_, setting);
+
+  if (persist)
+    StorePermission(audio_setting, video_setting);
+
+  content::MediaStreamRequestResult denial_reason = content::MEDIA_DEVICE_OK;
+  if (setting == CONTENT_SETTING_ASK)
+    denial_reason = content::MEDIA_DEVICE_PERMISSION_DISMISSED;
+  else if (setting == CONTENT_SETTING_BLOCK)
+    denial_reason = content::MEDIA_DEVICE_PERMISSION_DENIED;
+
+  RunCallback(audio_setting, video_setting, denial_reason);
 }
 
 #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);
 }
 #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(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(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(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()
-    const {
-  return PermissionRequestType::MEDIA_STREAM;
-}
-
 // static
 void MediaStreamDevicesController::RequestPermissionsWithDelegate(
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
-    internal::PermissionPromptDelegate* delegate) {
+    PermissionPromptDelegate* delegate) {
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(
           content::RenderFrameHost::FromID(request.render_process_id,
                                            request.render_frame_id));
   if (request.request_type == content::MEDIA_OPEN_DEVICE_PEPPER_ONLY) {
     MediaPermissionRequestLogger::LogRequest(
         web_contents, request.render_process_id, request.render_frame_id,
         content::IsOriginSecure(request.security_origin));
   }
 
@@ skipping 17 matching lines @@
             web_contents, content_settings_types)) {
       PermissionUpdateInfoBarDelegate::Create(
           web_contents, content_settings_types,
           base::Bind(&MediaStreamDevicesController::AndroidOSPromptAnswered,
                      base::Passed(&controller)));
     }
 #endif
     return;
   }
 
-  delegate->ShowPrompt(request.user_gesture, web_contents,
-                       std::move(controller));
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
+  delegate->ShowPrompt(
+      request.user_gesture, web_contents,
+      base::MakeUnique<MediaStreamDevicesController::Request>(
+          profile, controller->IsAskingForAudio(),
+          controller->IsAskingForVideo(), request.security_origin,
+          base::Bind(&MediaStreamDevicesController::PromptAnswered,
+                     base::Passed(&controller))));
 }
 
 MediaStreamDevicesController::MediaStreamDevicesController(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback)
     : web_contents_(web_contents), request_(request), callback_(callback) {
   profile_ = Profile::FromBrowserContext(web_contents->GetBrowserContext());
   content_settings_ = TabSpecificContentSettings::FromWebContents(web_contents);
 
@@ skipping 128 matching lines @@
 
   return devices;
 }
 
 void MediaStreamDevicesController::RunCallback(
     ContentSetting audio_setting,
     ContentSetting video_setting,
     content::MediaStreamRequestResult denial_reason) {
   CHECK(!callback_.is_null());
 
-  // If the kill switch is on we don't update the tab context or persist the
-  // setting.
-  if (denial_reason != content::MEDIA_DEVICE_KILL_SWITCH_ON) {
-    if (persist())
-      StorePermission(audio_setting, video_setting);
+  // If the kill switch is on we don't update the tab context.
+  if (denial_reason != content::MEDIA_DEVICE_KILL_SWITCH_ON)
     UpdateTabSpecificContentSettings(audio_setting, video_setting);
-  }
 
   content::MediaStreamDevices devices =
       GetDevices(audio_setting, video_setting);
 
   // If either audio or video are allowed then the callback should report
   // success, otherwise we report |denial_reason|.
   content::MediaStreamRequestResult request_result = content::MEDIA_DEVICE_OK;
   if (audio_setting != CONTENT_SETTING_ALLOW &&
       video_setting != CONTENT_SETTING_ALLOW) {
     DCHECK_NE(content::MEDIA_DEVICE_OK, denial_reason);
@@ skipping 120 matching lines @@
                          : content::MEDIA_DEVICE_PERMISSION_DENIED;
   }
 
   return result.content_setting;
 }
 
 ContentSetting MediaStreamDevicesController::GetNewSetting(
     ContentSettingsType content_type,
     ContentSetting old_setting,
     ContentSetting user_decision) const {
-  DCHECK(user_decision == CONTENT_SETTING_ALLOW ||
-         user_decision == CONTENT_SETTING_BLOCK);
   ContentSetting result = old_setting;
   if (old_setting == CONTENT_SETTING_ASK)
     result = user_decision;
   return result;
 }
 
 bool MediaStreamDevicesController::IsUserAcceptAllowed(
     ContentSettingsType content_type) const {
 #if defined(OS_ANDROID)
   content::ContentViewCore* cvc =
@@ skipping 15 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;
 }