Move logic to show permission prompts into MediaStreamDevicesController

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"
@@ skipping 58 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));
+  }
+
+  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();
+  }
+
   // 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;
         break;
@@ skipping 94 matching lines @@
   const std::string example_video_id_;
 
   content::MediaStreamDevices media_stream_devices_;
   content::MediaStreamRequestResult media_stream_result_;
 };
 
 // Request and allow microphone access.
 IN_PROC_BROWSER_TEST_F(MediaStreamDevicesControllerTest, RequestAndAllowMic) {
   InitWithUrl(GURL("https://www.example.com"));
   SetDevicePolicy(DEVICE_TYPE_AUDIO, ACCESS_ALLOWED);
-  MediaStreamDevicesController controller(
-      GetWebContents(), CreateRequest(example_audio_id(), std::string()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  NotifyTabSpecificContentSettings(&controller);
+  std::unique_ptr<MediaStreamDevicesController> controller(
+      CreateMediaStreamDevicesController(
+          GetWebContents(), CreateRequest(example_audio_id(), std::string()),
+          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                     base::Unretained(this))));
+  NotifyTabSpecificContentSettings(controller.get());
 
   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);
-  MediaStreamDevicesController controller(
-      GetWebContents(), CreateRequest(std::string(), example_video_id()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  NotifyTabSpecificContentSettings(&controller);
+  std::unique_ptr<MediaStreamDevicesController> controller(
+      CreateMediaStreamDevicesController(
+          GetWebContents(), CreateRequest(std::string(), example_video_id()),
+          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                     base::Unretained(this))));
+  NotifyTabSpecificContentSettings(controller.get());
 
   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);
-  MediaStreamDevicesController controller(
-      GetWebContents(), CreateRequest(example_audio_id(), std::string()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  NotifyTabSpecificContentSettings(&controller);
+  std::unique_ptr<MediaStreamDevicesController> controller(
+      CreateMediaStreamDevicesController(
+          GetWebContents(), CreateRequest(example_audio_id(), std::string()),
+          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                     base::Unretained(this))));
+  NotifyTabSpecificContentSettings(controller.get());
 
   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);
-  MediaStreamDevicesController controller(
-      GetWebContents(), CreateRequest(std::string(), example_video_id()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  NotifyTabSpecificContentSettings(&controller);
+  std::unique_ptr<MediaStreamDevicesController> controller(
+      CreateMediaStreamDevicesController(
+          GetWebContents(), CreateRequest(std::string(), example_video_id()),
+          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                     base::Unretained(this))));
+  NotifyTabSpecificContentSettings(controller.get());
 
   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);
-  MediaStreamDevicesController controller(
-      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  NotifyTabSpecificContentSettings(&controller);
+  std::unique_ptr<MediaStreamDevicesController> controller(
+      CreateMediaStreamDevicesController(
+          GetWebContents(),
+          CreateRequest(example_audio_id(), example_video_id()),
+          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                     base::Unretained(this))));
+  NotifyTabSpecificContentSettings(controller.get());
 
   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);
-  MediaStreamDevicesController controller(
-      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  NotifyTabSpecificContentSettings(&controller);
+  std::unique_ptr<MediaStreamDevicesController> controller(
+      CreateMediaStreamDevicesController(
+          GetWebContents(),
+          CreateRequest(example_audio_id(), example_video_id()),
+          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                     base::Unretained(this))));
+  NotifyTabSpecificContentSettings(controller.get());
 
   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);
-  MediaStreamDevicesController controller(
-      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  NotifyTabSpecificContentSettings(&controller);
+  std::unique_ptr<MediaStreamDevicesController> controller(
+      CreateMediaStreamDevicesController(
+          GetWebContents(),
+          CreateRequest(example_audio_id(), example_video_id()),
+          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                     base::Unretained(this))));
+  NotifyTabSpecificContentSettings(controller.get());
 
   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);
-  MediaStreamDevicesController controller(
-      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  NotifyTabSpecificContentSettings(&controller);
+  std::unique_ptr<MediaStreamDevicesController> controller(
+      CreateMediaStreamDevicesController(
+          GetWebContents(),
+          CreateRequest(example_audio_id(), example_video_id()),
+          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                     base::Unretained(this))));
+  NotifyTabSpecificContentSettings(controller.get());
 
   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);
-  MediaStreamDevicesController mic_controller(
-      GetWebContents(), CreateRequest(example_audio_id(), std::string()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  NotifyTabSpecificContentSettings(&mic_controller);
+  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());
   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);
-  MediaStreamDevicesController cam_controller(
-      GetWebContents(), CreateRequest(std::string(), example_video_id()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  NotifyTabSpecificContentSettings(&cam_controller);
+  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());
   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);
-  MediaStreamDevicesController cam_controller(
-      GetWebContents(), CreateRequest(std::string(), example_video_id()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  NotifyTabSpecificContentSettings(&cam_controller);
+  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());
   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);
-  MediaStreamDevicesController mic_controller(
-      GetWebContents(), CreateRequest(example_audio_id(), std::string()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  NotifyTabSpecificContentSettings(&mic_controller);
+  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());
   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 75 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);
-    MediaStreamDevicesController controller(
-        GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
-        base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                   base::Unretained(this)));
+    std::unique_ptr<MediaStreamDevicesController> controller(
+        CreateMediaStreamDevicesController(
+            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(), controller.IsAskingForAudio());
-    ASSERT_EQ(test.ExpectCamInfobar(), controller.IsAskingForVideo());
+    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)
-        controller.PermissionGranted();
+        PermissionGranted(controller.get());
       else
-        controller.PermissionDenied();
+        PermissionDenied(controller.get());
     }
 
     // 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"));
-  MediaStreamDevicesController controller(
-      GetWebContents(), CreateRequest(std::string(), example_video_id()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
+  std::unique_ptr<MediaStreamDevicesController> controller(
+      CreateMediaStreamDevicesController(
+          GetWebContents(), CreateRequest(std::string(), example_video_id()),
+          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                     base::Unretained(this))));
 
-  ASSERT_FALSE(controller.IsAskingForAudio());
-  ASSERT_FALSE(controller.IsAskingForVideo());
+  ASSERT_FALSE(IsAskingForAudio(controller.get()));
+  ASSERT_FALSE(IsAskingForVideo(controller.get()));
 
   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.
-  MediaStreamDevicesController controller(
-      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  ASSERT_TRUE(controller.IsAskingForAudio());
-  ASSERT_TRUE(controller.IsAskingForVideo());
+  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()));
 
   // Accept the prompt.
-  controller.PermissionGranted();
+  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.
-  MediaStreamDevicesController controller2(
-      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  ASSERT_FALSE(controller2.IsAskingForAudio());
-  ASSERT_FALSE(controller2.IsAskingForVideo());
+  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()));
 
   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);
 
-  MediaStreamDevicesController controller(
-      GetWebContents(),
-      CreateRequestWithType(example_audio_id(), std::string(),
-                            content::MEDIA_OPEN_DEVICE_PEPPER_ONLY),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
-  ASSERT_FALSE(controller.IsAskingForAudio());
-  ASSERT_FALSE(controller.IsAskingForVideo());
+  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()));
 }
 
 // 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);
-  MediaStreamDevicesController controller(
-      GetWebContents(), CreateRequest(example_audio_id(), example_video_id()),
-      base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
-                 base::Unretained(this)));
+  std::unique_ptr<MediaStreamDevicesController> controller(
+      CreateMediaStreamDevicesController(
+          GetWebContents(),
+          CreateRequest(example_audio_id(), example_video_id()),
+          base::Bind(&MediaStreamDevicesControllerTest::OnMediaStreamResponse,
+                     base::Unretained(this))));
 
-  EXPECT_FALSE(controller.IsAllowedForAudio());
-  EXPECT_FALSE(controller.IsAllowedForVideo());
-  EXPECT_FALSE(controller.IsAskingForAudio());
-  EXPECT_FALSE(controller.IsAskingForVideo());
+  EXPECT_FALSE(IsAskingForAudio(controller.get()));
+  EXPECT_FALSE(IsAskingForVideo(controller.get()));
+
+  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));
 }