Change MediaStreamDevicesController tests to use RequestPermissions function

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 157 matching lines @@
   void RenderFrameDeleted(
       content::RenderFrameHost* render_frame_host) override {
     PageChanged(render_frame_host);
   }
 
   RequestMap::key_type key_;
 };
 
 }  // namespace
 
+// Implementation of PermissionPromptDelegate which actually shows a permission
+// prompt.
+class MediaStreamDevicesController::PermissionPromptDelegateImpl
+    : public MediaStreamDevicesController::PermissionPromptDelegate {
+ public:
+  void ShowPrompt(
+      bool user_gesture,
+      content::WebContents* web_contents,
+      std::unique_ptr<MediaStreamDevicesController> controller) override {
+#if defined(OS_ANDROID)
+    PermissionUmaUtil::RecordPermissionPromptShown(
+        controller->GetPermissionRequestType(),
+        PermissionUtil::GetGestureType(user_gesture));
+    if (PermissionDialogDelegate::ShouldShowDialog(user_gesture)) {
+      PermissionDialogDelegate::CreateMediaStreamDialog(
+          web_contents, user_gesture, std::move(controller));
+    } else {
+      MediaStreamInfoBarDelegateAndroid::Create(web_contents, user_gesture,
+                                                std::move(controller));
+    }
+#else
+    PermissionRequestManager* permission_request_manager =
+        PermissionRequestManager::FromWebContents(web_contents);
+    if (permission_request_manager)
+      permission_request_manager->AddRequest(controller.release());
+#endif
+  }
+};
+
 // static
 void MediaStreamDevicesController::RequestPermissions(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback) {
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      new MediaStreamDevicesController(web_contents, request, callback));
-  if (!controller->IsAskingForAudio() && !controller->IsAskingForVideo()) {
-#if defined(OS_ANDROID)
-    // If either audio or video was previously allowed and Chrome no longer has
-    // the necessary permissions, show a infobar to attempt to address this
-    // mismatch.
-    std::vector<ContentSettingsType> content_settings_types;
-    if (controller->IsAllowedForAudio())
-      content_settings_types.push_back(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
-
-    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)));
-    }
-#endif
-    return;
-  }
-
-#if defined(OS_ANDROID)
-  PermissionUmaUtil::RecordPermissionPromptShown(
-      controller->GetPermissionRequestType(),
-      PermissionUtil::GetGestureType(request.user_gesture));
-  if (PermissionDialogDelegate::ShouldShowDialog(request.user_gesture)) {
-    PermissionDialogDelegate::CreateMediaStreamDialog(
-        web_contents, request.user_gesture, std::move(controller));
-  } else {
-    MediaStreamInfoBarDelegateAndroid::Create(
-        web_contents, request.user_gesture, std::move(controller));
-  }
-#else
-  PermissionRequestManager* permission_request_manager =
-      PermissionRequestManager::FromWebContents(web_contents);
-  if (permission_request_manager)
-    permission_request_manager->AddRequest(controller.release());
-#endif
+  PermissionPromptDelegateImpl delegate;
+  RequestPermissionsWithDelegate(web_contents, 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);
 }
@@ skipping 93 matching lines @@
 
 void MediaStreamDevicesController::RequestFinished() {
   delete this;
 }
 
 PermissionRequestType MediaStreamDevicesController::GetPermissionRequestType()
     const {
   return PermissionRequestType::MEDIA_STREAM;
 }
 
+// static
+void MediaStreamDevicesController::RequestPermissionsWithDelegate(
+    content::WebContents* web_contents,
+    const content::MediaStreamRequest& request,
+    const content::MediaResponseCallback& callback,
+    PermissionPromptDelegate* delegate) {
+  std::unique_ptr<MediaStreamDevicesController> controller(
+      new MediaStreamDevicesController(web_contents, request, callback));
+  if (!controller->IsAskingForAudio() && !controller->IsAskingForVideo()) {
+#if defined(OS_ANDROID)
+    // If either audio or video was previously allowed and Chrome no longer has
+    // the necessary permissions, show a infobar to attempt to address this
+    // mismatch.
+    std::vector<ContentSettingsType> content_settings_types;
+    if (controller->IsAllowedForAudio())
+      content_settings_types.push_back(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
+
+    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)));
+    }
+#endif
+    return;
+  }
+
+  delegate->ShowPrompt(request.user_gesture, web_contents,
+                       std::move(controller));
+}
+
 MediaStreamDevicesController::MediaStreamDevicesController(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback)
     : web_contents_(web_contents), request_(request), callback_(callback) {
   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 310 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;
 }