Introduce MediaDevicesPermissionChecker.

content/browser/renderer_host/media/media_devices_dispatcher_host_unittest.cc

 // Copyright 2016 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 "content/browser/renderer_host/media/media_devices_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <queue>
@@ skipping 46 matching lines @@
     audio_manager_.reset(
         new media::MockAudioManager(base::ThreadTaskRunnerHandle::Get()));
     media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
 
     MockResourceContext* mock_resource_context =
         static_cast<MockResourceContext*>(
             browser_context_.GetResourceContext());
 
     host_ = base::MakeUnique<MediaDevicesDispatcherHost>(
         kProcessId, kRenderId, mock_resource_context->GetMediaDeviceIDSalt(),
-        media_stream_manager_.get(), true /* use_fake_ui */);
+        media_stream_manager_.get());
   }
 
   void SetUp() override {
     base::RunLoop run_loop;
     MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
     devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = true;
     devices_to_enumerate[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = true;
     devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
     media_stream_manager_->media_devices_manager()->EnumerateDevices(
         devices_to_enumerate,
         base::Bind(&PhysicalDevicesEnumerated, run_loop.QuitClosure(),
                    &physical_devices_));
     run_loop.Run();
 
     ASSERT_GT(physical_devices_[MEDIA_DEVICE_TYPE_AUDIO_INPUT].size(), 0u);
     ASSERT_GT(physical_devices_[MEDIA_DEVICE_TYPE_VIDEO_INPUT].size(), 0u);
     ASSERT_GT(physical_devices_[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT].size(), 0u);
   }
 
  protected:
   void DevicesEnumerated(
       const base::Closure& closure,
       const std::vector<std::vector<MediaDeviceInfo>>& devices) {
     enumerated_devices_ = devices;
     closure.Run();
   }
 
-  void EnumerateDevicesAndWaitForResult(
-      bool enumerate_audio_input,
-      bool enumerate_video_input,
-      bool enumerate_audio_output,
-      std::unique_ptr<MediaStreamUIProxy> ui_proxy) {
-    if (ui_proxy)
-      host_->SetFakeUIProxyForTesting(std::move(ui_proxy));
+  void EnumerateDevicesAndWaitForResult(bool enumerate_audio_input,
+                                        bool enumerate_video_input,
+                                        bool enumerate_audio_output,
+                                        bool permission_override_value = true) {
+    MediaDevicesPermissionChecker permission_checker;
+    permission_checker.OverridePermissions(permission_override_value);
+    host_->SetPermissionChecker(permission_checker);
     base::RunLoop run_loop;
     host_->EnumerateDevices(
         enumerate_audio_input, enumerate_video_input, enumerate_audio_output,
         origin_, base::Bind(&MediaDevicesDispatcherHostTest::DevicesEnumerated,
                             base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
 
     ASSERT_FALSE(enumerated_devices_.empty());
     if (enumerate_audio_input)
       EXPECT_FALSE(enumerated_devices_[MEDIA_DEVICE_TYPE_AUDIO_INPUT].empty());
@@ skipping 78 matching lines @@
   std::unique_ptr<media::AudioManager, media::AudioManagerDeleter>
       audio_manager_;
   content::TestBrowserContext browser_context_;
   MediaDeviceEnumeration physical_devices_;
   url::Origin origin_;
 
   std::vector<std::vector<MediaDeviceInfo>> enumerated_devices_;
 };
 
 TEST_F(MediaDevicesDispatcherHostTest, EnumerateAudioInputDevices) {
-  EnumerateDevicesAndWaitForResult(true, false, false, nullptr);
+  EnumerateDevicesAndWaitForResult(true, false, false);
   EXPECT_TRUE(DoesContainLabels(enumerated_devices_));
 }
 
 TEST_F(MediaDevicesDispatcherHostTest, EnumerateVideoInputDevices) {
-  EnumerateDevicesAndWaitForResult(false, true, false, nullptr);
+  EnumerateDevicesAndWaitForResult(false, true, false);
   EXPECT_TRUE(DoesContainLabels(enumerated_devices_));
 }
 
 TEST_F(MediaDevicesDispatcherHostTest, EnumerateAudioOutputDevices) {
-  EnumerateDevicesAndWaitForResult(false, false, true, nullptr);
+  EnumerateDevicesAndWaitForResult(false, false, true);
   EXPECT_TRUE(DoesContainLabels(enumerated_devices_));
 }
 
 TEST_F(MediaDevicesDispatcherHostTest, EnumerateAllDevices) {
-  EnumerateDevicesAndWaitForResult(true, true, true, nullptr);
+  EnumerateDevicesAndWaitForResult(true, true, true);
   EXPECT_TRUE(DoesContainLabels(enumerated_devices_));
 }
 
 TEST_F(MediaDevicesDispatcherHostTest, EnumerateAudioInputDevicesNoAccess) {
-  std::unique_ptr<FakeMediaStreamUIProxy> fake_ui_proxy =
-      base::MakeUnique<FakeMediaStreamUIProxy>();
-  fake_ui_proxy->SetMicAccess(false);
-  EnumerateDevicesAndWaitForResult(true, false, false,
-                                   std::move(fake_ui_proxy));
+  EnumerateDevicesAndWaitForResult(true, false, false, false);
   EXPECT_TRUE(DoesNotContainLabels(enumerated_devices_));
 }
 
 TEST_F(MediaDevicesDispatcherHostTest, EnumerateVideoInputDevicesNoAccess) {
-  std::unique_ptr<FakeMediaStreamUIProxy> fake_ui_proxy =
-      base::MakeUnique<FakeMediaStreamUIProxy>();
-  fake_ui_proxy->SetCameraAccess(false);
-  EnumerateDevicesAndWaitForResult(false, true, false,
-                                   std::move(fake_ui_proxy));
+  EnumerateDevicesAndWaitForResult(false, true, false, false);
   EXPECT_TRUE(DoesNotContainLabels(enumerated_devices_));
 }
 
 TEST_F(MediaDevicesDispatcherHostTest, EnumerateAudioOutputDevicesNoAccess) {
-  std::unique_ptr<FakeMediaStreamUIProxy> fake_ui_proxy =
-      base::MakeUnique<FakeMediaStreamUIProxy>();
-  fake_ui_proxy->SetMicAccess(false);
-  EnumerateDevicesAndWaitForResult(false, false, true,
-                                   std::move(fake_ui_proxy));
+  EnumerateDevicesAndWaitForResult(false, false, true, false);
   EXPECT_TRUE(DoesNotContainLabels(enumerated_devices_));
 }
 
 TEST_F(MediaDevicesDispatcherHostTest, EnumerateAllDevicesNoAccess) {
-  std::unique_ptr<FakeMediaStreamUIProxy> fake_ui_proxy =
-      base::MakeUnique<FakeMediaStreamUIProxy>();
-  fake_ui_proxy->SetMicAccess(false);
-  fake_ui_proxy->SetCameraAccess(false);
-  EnumerateDevicesAndWaitForResult(true, true, true, std::move(fake_ui_proxy));
+  EnumerateDevicesAndWaitForResult(true, true, true, false);
   EXPECT_TRUE(DoesNotContainLabels(enumerated_devices_));
 }
 
 };  // namespace content