Change MediaStreamDevicesController tests to use RequestPermissions function

chrome/browser/media/webrtc/media_stream_devices_controller_browsertest.cc

 // Copyright 2014 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 <string>
 
 #include "base/bind.h"
 #include "base/metrics/field_trial.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/webrtc/media_stream_capture_indicator.h"
 #include "chrome/browser/media/webrtc/media_stream_device_permissions.h"
 #include "chrome/browser/media/webrtc/media_stream_devices_controller.h"
 #include "chrome/browser/media/webrtc/webrtc_browsertest_base.h"
 #include "chrome/browser/permissions/permission_context_base.h"
+#include "chrome/browser/permissions/permission_request_manager.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace {
-
-// Causes the controller to update the TabSpecificContentSettings associated
-// with the same WebContents with the current permissions. This should be the
-// last change made to the controller in the test.
-void NotifyTabSpecificContentSettings(
-    MediaStreamDevicesController* controller) {
-  // Note that calling Deny() would have the same effect of passing the current
-  // permissions state to the TabSpecificContentSettings. Deny() and Accept()
-  // differ in their effect on the controller itself, but that is not important
-  // in the tests calling this.
-  if (controller->IsAskingForAudio() || controller->IsAskingForVideo())
-    controller->PermissionGranted();
-}
-
-}  // namespace
-
 class MediaStreamDevicesControllerTest : public WebRtcTestBase {
  public:
+  // TODO(raymes): When crbug.com/606138 is finished and the
+  // PermissionRequestManager is used to show all prompts on Android/Desktop
+  // we should remove PermissionPromptDelegate and just use
+  // MockPermissionPromptFactory instead. The APIs are the same.
+  class TestPermissionPromptDelegate
+      : public MediaStreamDevicesController::PermissionPromptDelegate {
+   public:
+    void ShowPrompt(
+        bool user_gesture,
+        content::WebContents* web_contents,
+        std::unique_ptr<MediaStreamDevicesController> controller) override {
+      if (controller->IsAskingForAudio())
+        ++total_request_count_;
+      if (controller->IsAskingForVideo())
+        ++total_request_count_;
+
+      if (response_type_ == PermissionRequestManager::ACCEPT_ALL)
+        controller->PermissionGranted();
+      else if (response_type_ == PermissionRequestManager::DENY_ALL)
+        controller->PermissionDenied();
+    }
+
+    void set_response_type(
+        PermissionRequestManager::AutoResponseType response_type) {
+      response_type_ = response_type;
+    }
+
+    int total_request_count() { return total_request_count_; }
+
+    void ResetCounts() { total_request_count_ = 0; }
+
+   private:
+    PermissionRequestManager::AutoResponseType response_type_ =
+        PermissionRequestManager::NONE;
+    int total_request_count_ = 0;
+  };
+
   MediaStreamDevicesControllerTest()
       : example_audio_id_("fake_audio_dev"),
         example_video_id_("fake_video_dev"),
         media_stream_result_(content::NUM_MEDIA_REQUEST_RESULTS) {}
 
   // Dummy callback for when we deny the current request directly.
   void OnMediaStreamResponse(const content::MediaStreamDevices& devices,
                              content::MediaStreamRequestResult result,
                              std::unique_ptr<content::MediaStreamUI> ui) {
     media_stream_devices_ = devices;
@@ skipping 10 matching lines @@
     return TabSpecificContentSettings::FromWebContents(GetWebContents());
   }
 
   const std::string& example_audio_id() const { return example_audio_id_; }
   const std::string& example_video_id() const { return example_video_id_; }
 
   content::MediaStreamRequestResult media_stream_result() const {
     return media_stream_result_;
   }
 
-  std::unique_ptr<MediaStreamDevicesController>
-  CreateMediaStreamDevicesController(
-      content::WebContents* web_contents,
-      const content::MediaStreamRequest& request,
-      const content::MediaResponseCallback& callback) {
-    return base::WrapUnique(
-        new MediaStreamDevicesController(web_contents, request, callback));
+  void RequestPermissions(content::WebContents* web_contents,
+                          const content::MediaStreamRequest& request,
+                          const content::MediaResponseCallback& callback) {
+    MediaStreamDevicesController::RequestPermissionsWithDelegate(
+        web_contents, request, callback, &prompt_delegate_);
   }
 
-  bool IsAskingForAudio(const MediaStreamDevicesController* controller) {
-    return controller->IsAskingForAudio();
-  }
-
-  bool IsAskingForVideo(const MediaStreamDevicesController* controller) {
-    return controller->IsAskingForVideo();
-  }
-
-  void PermissionGranted(MediaStreamDevicesController* controller) {
-    return controller->PermissionGranted();
-  }
-
-  void PermissionDenied(MediaStreamDevicesController* controller) {
-    return controller->PermissionDenied();
-  }
+  TestPermissionPromptDelegate* prompt_delegate() { return &prompt_delegate_; }
 
   // Sets the device policy-controlled |access| for |example_url_| to be for the
   // selected |device_type|.
   void SetDevicePolicy(DeviceType device_type, Access access) {
     PrefService* prefs = Profile::FromBrowserContext(
         GetWebContents()->GetBrowserContext())->GetPrefs();
     const char* policy_name = NULL;
     switch (device_type) {
       case DEVICE_TYPE_AUDIO:
         policy_name = prefs::kAudioCaptureAllowed;
@@ skipping 89 matching lines @@
     MediaCaptureDevicesDispatcher::GetInstance()->SetTestVideoCaptureDevices(
         video_devices);
   }
 
   GURL example_url_;
   const std::string example_audio_id_;
   const std::string example_video_id_;
 
   content::MediaStreamDevices media_stream_devices_;
   content::MediaStreamRequestResult media_stream_result_;
+
+  TestPermissionPromptDelegate prompt_delegate_;
 };
 
 // Request and allow microphone access.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest, RequestAndAllowMic) {
   InitWithUrl(GURL("https://www.example.com"));
   SetDevicePolicy(DEVICE_TYPE_AUDIO, ACCESS_ALLOWED);
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(), CreateRequest(example_audio_id(), std::string()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  NotifyTabSpecificContentSettings(controller.get());
+  // Ensure the prompt is accepted if necessary such that tab specific content
+  // settings are updated.
+  prompt_delegate()->set_response_type(PermissionRequestManager::ACCEPT_ALL);
+  RequestPermissions(
+      GetWebContents(), CreateRequest(example_audio_id(), std::string()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
 
   EXPECT_TRUE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_FALSE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_EQ(TabSpecificContentSettings::MICROPHONE_ACCESSED,
             GetContentSettings()->GetMicrophoneCameraState());
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_requested_audio_device());
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_selected_audio_device());
   EXPECT_EQ(std::string(),
             GetContentSettings()->media_stream_requested_video_device());
   EXPECT_EQ(std::string(),
             GetContentSettings()->media_stream_selected_video_device());
 }
 
 // Request and allow camera access.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest, RequestAndAllowCam) {
   InitWithUrl(GURL("https://www.example.com"));
   SetDevicePolicy(DEVICE_TYPE_VIDEO, ACCESS_ALLOWED);
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(), CreateRequest(std::string(), example_video_id()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  NotifyTabSpecificContentSettings(controller.get());
+  // Ensure the prompt is accepted if necessary such that tab specific content
+  // settings are updated.
+  prompt_delegate()->set_response_type(PermissionRequestManager::ACCEPT_ALL);
+  RequestPermissions(
+      GetWebContents(), CreateRequest(std::string(), example_video_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
 
   EXPECT_TRUE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_FALSE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_EQ(TabSpecificContentSettings::CAMERA_ACCESSED,
             GetContentSettings()->GetMicrophoneCameraState());
   EXPECT_EQ(std::string(),
             GetContentSettings()->media_stream_requested_audio_device());
   EXPECT_EQ(std::string(),
             GetContentSettings()->media_stream_selected_audio_device());
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_requested_video_device());
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_selected_video_device());
 }
 
 // Request and block microphone access.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest, RequestAndBlockMic) {
   InitWithUrl(GURL("https://www.example.com"));
   SetDevicePolicy(DEVICE_TYPE_AUDIO, ACCESS_DENIED);
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(), CreateRequest(example_audio_id(), std::string()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  NotifyTabSpecificContentSettings(controller.get());
+  // Ensure the prompt is accepted if necessary such that tab specific content
+  // settings are updated.
+  prompt_delegate()->set_response_type(PermissionRequestManager::ACCEPT_ALL);
+  RequestPermissions(
+      GetWebContents(), CreateRequest(example_audio_id(), std::string()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
 
   EXPECT_FALSE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_TRUE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_EQ(TabSpecificContentSettings::MICROPHONE_ACCESSED |
                 TabSpecificContentSettings::MICROPHONE_BLOCKED,
             GetContentSettings()->GetMicrophoneCameraState());
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_requested_audio_device());
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_selected_audio_device());
   EXPECT_EQ(std::string(),
             GetContentSettings()->media_stream_requested_video_device());
   EXPECT_EQ(std::string(),
             GetContentSettings()->media_stream_selected_video_device());
 }
 
 // Request and block camera access.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest, RequestAndBlockCam) {
   InitWithUrl(GURL("https://www.example.com"));
   SetDevicePolicy(DEVICE_TYPE_VIDEO, ACCESS_DENIED);
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(), CreateRequest(std::string(), example_video_id()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  NotifyTabSpecificContentSettings(controller.get());
+  // Ensure the prompt is accepted if necessary such that tab specific content
+  // settings are updated.
+  prompt_delegate()->set_response_type(PermissionRequestManager::ACCEPT_ALL);
+  RequestPermissions(
+      GetWebContents(), CreateRequest(std::string(), example_video_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
 
   EXPECT_FALSE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_TRUE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_EQ(TabSpecificContentSettings::CAMERA_ACCESSED |
                 TabSpecificContentSettings::CAMERA_BLOCKED,
             GetContentSettings()->GetMicrophoneCameraState());
   EXPECT_EQ(std::string(),
             GetContentSettings()->media_stream_requested_audio_device());
   EXPECT_EQ(std::string(),
             GetContentSettings()->media_stream_selected_audio_device());
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_requested_video_device());
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_selected_video_device());
 }
 
 // Request and allow microphone and camera access.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        RequestAndAllowMicCam) {
   InitWithUrl(GURL("https://www.example.com"));
   SetDevicePolicy(DEVICE_TYPE_AUDIO, ACCESS_ALLOWED);
   SetDevicePolicy(DEVICE_TYPE_VIDEO, ACCESS_ALLOWED);
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(),
-          CreateRequest(example_audio_id(), example_video_id()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  NotifyTabSpecificContentSettings(controller.get());
+  // Ensure the prompt is accepted if necessary such that tab specific content
+  // settings are updated.
+  prompt_delegate()->set_response_type(PermissionRequestManager::ACCEPT_ALL);
+  RequestPermissions(
+      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
 
   EXPECT_TRUE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_FALSE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_TRUE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_FALSE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_EQ(TabSpecificContentSettings::MICROPHONE_ACCESSED |
                 TabSpecificContentSettings::CAMERA_ACCESSED,
             GetContentSettings()->GetMicrophoneCameraState());
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_requested_audio_device());
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_selected_audio_device());
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_requested_video_device());
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_selected_video_device());
 }
 
 // Request and block microphone and camera access.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        RequestAndBlockMicCam) {
   InitWithUrl(GURL("https://www.example.com"));
   SetDevicePolicy(DEVICE_TYPE_AUDIO, ACCESS_DENIED);
   SetDevicePolicy(DEVICE_TYPE_VIDEO, ACCESS_DENIED);
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(),
-          CreateRequest(example_audio_id(), example_video_id()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  NotifyTabSpecificContentSettings(controller.get());
+  // Ensure the prompt is accepted if necessary such that tab specific content
+  // settings are updated.
+  prompt_delegate()->set_response_type(PermissionRequestManager::ACCEPT_ALL);
+  RequestPermissions(
+      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
 
   EXPECT_FALSE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_TRUE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_FALSE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_TRUE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_EQ(TabSpecificContentSettings::MICROPHONE_ACCESSED |
@@ skipping 10 matching lines @@
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_selected_video_device());
 }
 
 // Request microphone and camera access. Allow microphone, block camera.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        RequestMicCamBlockCam) {
   InitWithUrl(GURL("https://www.example.com"));
   SetDevicePolicy(DEVICE_TYPE_AUDIO, ACCESS_ALLOWED);
   SetDevicePolicy(DEVICE_TYPE_VIDEO, ACCESS_DENIED);
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(),
-          CreateRequest(example_audio_id(), example_video_id()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  NotifyTabSpecificContentSettings(controller.get());
+  // Ensure the prompt is accepted if necessary such that tab specific content
+  // settings are updated.
+  prompt_delegate()->set_response_type(PermissionRequestManager::ACCEPT_ALL);
+  RequestPermissions(
+      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
 
   EXPECT_TRUE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_FALSE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_FALSE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_TRUE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_EQ(TabSpecificContentSettings::MICROPHONE_ACCESSED |
                 TabSpecificContentSettings::CAMERA_ACCESSED |
                 TabSpecificContentSettings::CAMERA_BLOCKED,
             GetContentSettings()->GetMicrophoneCameraState());
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_requested_audio_device());
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_selected_audio_device());
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_requested_video_device());
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_selected_video_device());
 }
 
 // Request microphone and camera access. Block microphone, allow camera.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        RequestMicCamBlockMic) {
   InitWithUrl(GURL("https://www.example.com"));
   SetDevicePolicy(DEVICE_TYPE_AUDIO, ACCESS_DENIED);
   SetDevicePolicy(DEVICE_TYPE_VIDEO, ACCESS_ALLOWED);
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(),
-          CreateRequest(example_audio_id(), example_video_id()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  NotifyTabSpecificContentSettings(controller.get());
+  // Ensure the prompt is accepted if necessary such that tab specific content
+  // settings are updated.
+  prompt_delegate()->set_response_type(PermissionRequestManager::ACCEPT_ALL);
+  RequestPermissions(
+      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
 
   EXPECT_FALSE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_TRUE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_TRUE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_FALSE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_EQ(TabSpecificContentSettings::MICROPHONE_ACCESSED |
@@ skipping 10 matching lines @@
             GetContentSettings()->media_stream_selected_video_device());
 }
 
 // Request microphone access. Requesting camera should not change microphone
 // state.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        RequestCamDoesNotChangeMic) {
   InitWithUrl(GURL("https://www.example.com"));
   // Request mic and deny.
   SetDevicePolicy(DEVICE_TYPE_AUDIO, ACCESS_DENIED);
-  std::unique_ptr<MediaStreamDevicesController> mic_controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(), CreateRequest(example_audio_id(), std::string()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  NotifyTabSpecificContentSettings(mic_controller.get());
+  // Ensure the prompt is accepted if necessary such that tab specific content
+  // settings are updated.
+  prompt_delegate()->set_response_type(PermissionRequestManager::ACCEPT_ALL);
+  RequestPermissions(
+      GetWebContents(), CreateRequest(example_audio_id(), std::string()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
   EXPECT_FALSE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_TRUE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_requested_audio_device());
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_selected_audio_device());
 
   // Request cam and allow
   SetDevicePolicy(DEVICE_TYPE_VIDEO, ACCESS_ALLOWED);
-  std::unique_ptr<MediaStreamDevicesController> cam_controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(), CreateRequest(std::string(), example_video_id()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  NotifyTabSpecificContentSettings(cam_controller.get());
+  RequestPermissions(
+      GetWebContents(), CreateRequest(std::string(), example_video_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
   EXPECT_TRUE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_FALSE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_requested_video_device());
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_selected_video_device());
 
   // Mic state should not have changed.
   EXPECT_FALSE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_TRUE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_requested_audio_device());
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_selected_audio_device());
 }
 
 // Denying mic access after camera access should still show the camera as state.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        DenyMicDoesNotChangeCam) {
   InitWithUrl(GURL("https://www.example.com"));
   // Request cam and allow
   SetDevicePolicy(DEVICE_TYPE_VIDEO, ACCESS_ALLOWED);
-  std::unique_ptr<MediaStreamDevicesController> cam_controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(), CreateRequest(std::string(), example_video_id()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  NotifyTabSpecificContentSettings(cam_controller.get());
+  // Ensure the prompt is accepted if necessary such that tab specific content
+  // settings are updated.
+  prompt_delegate()->set_response_type(PermissionRequestManager::ACCEPT_ALL);
+  RequestPermissions(
+      GetWebContents(), CreateRequest(std::string(), example_video_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
   EXPECT_TRUE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_FALSE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_requested_video_device());
   EXPECT_EQ(example_video_id(),
             GetContentSettings()->media_stream_selected_video_device());
   EXPECT_EQ(TabSpecificContentSettings::CAMERA_ACCESSED,
             GetContentSettings()->GetMicrophoneCameraState());
 
   // Simulate that an a video stream is now being captured.
   content::MediaStreamDevice fake_video_device(
       content::MEDIA_DEVICE_VIDEO_CAPTURE, example_video_id(),
       example_video_id());
   content::MediaStreamDevices video_devices(1, fake_video_device);
   MediaCaptureDevicesDispatcher* dispatcher =
       MediaCaptureDevicesDispatcher::GetInstance();
   dispatcher->SetTestVideoCaptureDevices(video_devices);
   std::unique_ptr<content::MediaStreamUI> video_stream_ui =
       dispatcher->GetMediaStreamCaptureIndicator()->RegisterMediaStream(
           GetWebContents(), video_devices);
   video_stream_ui->OnStarted(base::Closure());
 
   // Request mic and deny.
   SetDevicePolicy(DEVICE_TYPE_AUDIO, ACCESS_DENIED);
-  std::unique_ptr<MediaStreamDevicesController> mic_controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(), CreateRequest(example_audio_id(), std::string()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  NotifyTabSpecificContentSettings(mic_controller.get());
+  // Ensure the prompt is accepted if necessary such that tab specific content
+  // settings are updated.
+  prompt_delegate()->set_response_type(PermissionRequestManager::ACCEPT_ALL);
+  RequestPermissions(
+      GetWebContents(), CreateRequest(example_audio_id(), std::string()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
   EXPECT_FALSE(GetContentSettings()->IsContentAllowed(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_TRUE(GetContentSettings()->IsContentBlocked(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_requested_audio_device());
   EXPECT_EQ(example_audio_id(),
             GetContentSettings()->media_stream_selected_audio_device());
 
   // Cam should still be included in the state.
@@ skipping 22 matching lines @@
 // which return the expected outputs for that test.
 struct ContentSettingsTestData {
   // The initial value of the mic/cam content settings.
   ContentSetting mic;
   ContentSetting cam;
   // Whether the infobar should be accepted if it's shown.
   bool accept_infobar;
 
   // Whether the infobar should be displayed to request mic/cam for the given
   // content settings inputs.
-  bool ExpectMicInfobar() const { return mic == CONTENT_SETTING_ASK; }
-  bool ExpectCamInfobar() const { return cam == CONTENT_SETTING_ASK; }
+  int NumExpectedPrompts() const {
+    int result = 0;
+    if (mic == CONTENT_SETTING_ASK)
+      ++result;
+    if (cam == CONTENT_SETTING_ASK)
+      ++result;
+    return result;
+  }
 
   // Whether or not the mic/cam should be allowed after clicking accept/deny for
   // the given inputs.
   bool ExpectMicAllowed() const {
     return mic == CONTENT_SETTING_ALLOW ||
            (mic == CONTENT_SETTING_ASK && accept_infobar);
   }
   bool ExpectCamAllowed() const {
     return cam == CONTENT_SETTING_ALLOW ||
            (cam == CONTENT_SETTING_ASK && accept_infobar);
@@ skipping 31 matching lines @@
 
       {CONTENT_SETTING_ASK, CONTENT_SETTING_ALLOW, false},
       {CONTENT_SETTING_ASK, CONTENT_SETTING_ALLOW, true},
 
       {CONTENT_SETTING_ASK, CONTENT_SETTING_BLOCK, false},
       {CONTENT_SETTING_ASK, CONTENT_SETTING_BLOCK, true},
   };
 
   for (auto& test : tests) {
     SetContentSettings(test.mic, test.cam);
-    std::unique_ptr<MediaStreamDevicesController> controller(
-        CreateMediaStreamDevicesController(
-            GetWebContents(),
-            CreateRequest(example_audio_id(), example_video_id()),
-            base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                       base::Unretained(this))));
+
+    prompt_delegate()->ResetCounts();
+
+    // Accept or deny the infobar if it's showing.
+    if (test.NumExpectedPrompts() > 0) {
+      if (test.accept_infobar) {
+        prompt_delegate()->set_response_type(
+            PermissionRequestManager::ACCEPT_ALL);
+      } else {
+        prompt_delegate()->set_response_type(
+            PermissionRequestManager::DENY_ALL);
+      }
+    } else {
+      prompt_delegate()->set_response_type(PermissionRequestManager::NONE);
+    }
+    RequestPermissions(
+        GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
+        base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                   base::Unretained(this)));
 
     // Check that the infobar is requesting the expected cam/mic values.
-    ASSERT_EQ(test.ExpectMicInfobar(), IsAskingForAudio(controller.get()));
-    ASSERT_EQ(test.ExpectCamInfobar(), IsAskingForVideo(controller.get()));
-
-    // Accept or deny the infobar if it's showing.
-    if (test.ExpectMicInfobar() || test.ExpectCamInfobar()) {
-      if (test.accept_infobar)
-        PermissionGranted(controller.get());
-      else
-        PermissionDenied(controller.get());
-    }
+    ASSERT_EQ(test.NumExpectedPrompts(),

[Timothy Loh, 2017/02/28 00:39:20]

This makes the test a bit less thorough, can we retain separate checks for which
permissions we get prompted for?

[raymes, 2017/03/01 02:08:01]

That's true. I kept the checks back in by storing a list of the request types.
That means this won't exactly match mock_permission_prompt_factory.h but when we
convert this over it should be easy to make that API slightly more general to
cover this use case.

+              prompt_delegate()->total_request_count());
 
     // Check the media stream result is expected and the devices returned are
     // expected;
     ASSERT_EQ(test.ExpectedMediaStreamResult(), media_stream_result());
     ASSERT_EQ(CheckDevicesListContains(content::MEDIA_DEVICE_AUDIO_CAPTURE),
               test.ExpectMicAllowed());
     ASSERT_EQ(CheckDevicesListContains(content::MEDIA_DEVICE_VIDEO_CAPTURE),
               test.ExpectCamAllowed());
   }
 }
 
 // Request and allow camera access on WebUI pages without prompting.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        WebUIRequestAndAllowCam) {
   InitWithUrl(GURL("chrome://test-page"));
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(), CreateRequest(std::string(), example_video_id()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
+  RequestPermissions(
+      GetWebContents(), CreateRequest(std::string(), example_video_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
 
-  ASSERT_FALSE(IsAskingForAudio(controller.get()));
-  ASSERT_FALSE(IsAskingForVideo(controller.get()));
+  ASSERT_EQ(0, prompt_delegate()->total_request_count());
 
   ASSERT_EQ(content::MEDIA_DEVICE_OK, media_stream_result());
   ASSERT_FALSE(CheckDevicesListContains(content::MEDIA_DEVICE_AUDIO_CAPTURE));
   ASSERT_TRUE(CheckDevicesListContains(content::MEDIA_DEVICE_VIDEO_CAPTURE));
 }
 
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        ExtensionRequestMicCam) {
   InitWithUrl(GURL("chrome-extension://test-page"));
   // Test that a prompt is required.
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(),
-          CreateRequest(example_audio_id(), example_video_id()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  ASSERT_TRUE(IsAskingForAudio(controller.get()));
-  ASSERT_TRUE(IsAskingForVideo(controller.get()));
+  prompt_delegate()->set_response_type(PermissionRequestManager::ACCEPT_ALL);
+  RequestPermissions(
+      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
+  ASSERT_EQ(2, prompt_delegate()->total_request_count());
 
   // Accept the prompt.
-  PermissionGranted(controller.get());
   ASSERT_EQ(content::MEDIA_DEVICE_OK, media_stream_result());
   ASSERT_TRUE(CheckDevicesListContains(content::MEDIA_DEVICE_AUDIO_CAPTURE));
   ASSERT_TRUE(CheckDevicesListContains(content::MEDIA_DEVICE_VIDEO_CAPTURE));
 
   // Check that re-requesting allows without prompting.
-  std::unique_ptr<MediaStreamDevicesController> controller2(
-      CreateMediaStreamDevicesController(
-          GetWebContents(),
-          CreateRequest(example_audio_id(), example_video_id()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  ASSERT_FALSE(IsAskingForAudio(controller2.get()));
-  ASSERT_FALSE(IsAskingForVideo(controller2.get()));
+  prompt_delegate()->ResetCounts();
+  RequestPermissions(
+      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
+  ASSERT_EQ(0, prompt_delegate()->total_request_count());
 
   ASSERT_EQ(content::MEDIA_DEVICE_OK, media_stream_result());
   ASSERT_TRUE(CheckDevicesListContains(content::MEDIA_DEVICE_AUDIO_CAPTURE));
   ASSERT_TRUE(CheckDevicesListContains(content::MEDIA_DEVICE_VIDEO_CAPTURE));
 }
 
 // For Pepper request from insecure origin, even if it's ALLOW, it won't be
 // changed to ASK.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        PepperRequestInsecure) {
   InitWithUrl(GURL("http://www.example.com"));
   SetContentSettings(CONTENT_SETTING_ALLOW, CONTENT_SETTING_ALLOW);
 
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(),
-          CreateRequestWithType(example_audio_id(), std::string(),
-                                content::MEDIA_OPEN_DEVICE_PEPPER_ONLY),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
-  ASSERT_FALSE(IsAskingForAudio(controller.get()));
-  ASSERT_FALSE(IsAskingForVideo(controller.get()));
+  RequestPermissions(
+      GetWebContents(),
+      CreateRequestWithType(example_audio_id(), std::string(),
+                            content::MEDIA_OPEN_DEVICE_PEPPER_ONLY),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
+  ASSERT_EQ(0, prompt_delegate()->total_request_count());
 }
 
 // Request and block microphone and camera access with kill switch.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest,
                        RequestAndKillSwitchMicCam) {
   std::map<std::string, std::string> params;
   params[PermissionUtil::GetPermissionString(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC)] =
       PermissionContextBase::kPermissionsKillSwitchBlockedValue;
   params[PermissionUtil::GetPermissionString(
       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA)] =
       PermissionContextBase::kPermissionsKillSwitchBlockedValue;
   variations::AssociateVariationParams(
       PermissionContextBase::kPermissionsKillSwitchFieldStudy,
       "TestGroup", params);
   base::FieldTrialList::CreateFieldTrial(
       PermissionContextBase::kPermissionsKillSwitchFieldStudy,
       "TestGroup");
   InitWithUrl(GURL("https://www.example.com"));
   SetDevicePolicy(DEVICE_TYPE_AUDIO, ACCESS_ALLOWED);
   SetDevicePolicy(DEVICE_TYPE_VIDEO, ACCESS_ALLOWED);
-  std::unique_ptr<MediaStreamDevicesController> controller(
-      CreateMediaStreamDevicesController(
-          GetWebContents(),
-          CreateRequest(example_audio_id(), example_video_id()),
-          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                     base::Unretained(this))));
+  RequestPermissions(
+      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
+      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                 base::Unretained(this)));
 
-  EXPECT_FALSE(IsAskingForAudio(controller.get()));
-  EXPECT_FALSE(IsAskingForVideo(controller.get()));
+  ASSERT_EQ(0, prompt_delegate()->total_request_count());
 
   ASSERT_EQ(content::MEDIA_DEVICE_KILL_SWITCH_ON, media_stream_result());
   ASSERT_FALSE(CheckDevicesListContains(content::MEDIA_DEVICE_AUDIO_CAPTURE));
   ASSERT_FALSE(CheckDevicesListContains(content::MEDIA_DEVICE_VIDEO_CAPTURE));
 }