Remove device enumeration, caching and monitoring from MediaStreamManager.

content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.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 "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
 
 #include <stddef.h>
+#include <memory>
 #include <queue>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/system_monitor/system_monitor.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/audio_input_device_manager.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/media_device_id.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_content_client.h"
 #include "ipc/ipc_message_macros.h"
+#include "media/audio/audio_device_description.h"
 #include "media/audio/mock_audio_manager.h"
 #include "media/base/media_switches.h"
 #include "media/capture/video/fake_video_capture_device_factory.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/audio/cras_audio_handler.h"
 #endif
 
 using ::testing::_;
 using ::testing::DeleteArg;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::SaveArg;
 
 const int kProcessId = 5;
 const int kRenderId = 6;
 const int kPageRequestId = 7;
 
 namespace content {
 
+namespace {
+
+void AudioInputDevicesEnumerated(base::Closure quit_closure,
+                                 media::AudioDeviceNames* out,
+                                 const MediaDeviceEnumeration& enumeration) {
+  for (const auto& info : enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT]) {
+    out->emplace_back(info.label, info.device_id);
+  }
+  quit_closure.Run();
+}
+
+}  // namespace
+
 class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
                                       public TestContentBrowserClient {
  public:
   MockMediaStreamDispatcherHost(
       const std::string& salt,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       MediaStreamManager* manager)
       : MediaStreamDispatcherHost(kProcessId, salt, manager, true),
         task_runner_(task_runner),
         current_ipc_(NULL) {}
@@ skipping 220 matching lines @@
 #if defined(OS_CHROMEOS)
     chromeos::CrasAudioHandler::Shutdown();
 #endif
   }
 
   void SetUp() override {
     video_capture_device_factory_->GetDeviceDescriptors(
         &physical_video_devices_);
     ASSERT_GT(physical_video_devices_.size(), 0u);
 
-    media_stream_manager_->audio_input_device_manager()->GetFakeDeviceNames(
-        &physical_audio_devices_);
+    base::RunLoop run_loop;
+    media_stream_manager_->media_devices_manager()->EnumerateDevices(
+        {{true, false, false}},
+        base::Bind(&AudioInputDevicesEnumerated, run_loop.QuitClosure(),
+                   &physical_audio_devices_));
+    run_loop.Run();
+
     ASSERT_GT(physical_audio_devices_.size(), 0u);
   }
 
   void TearDown() override { host_->OnChannelClosing(); }
 
  protected:
   virtual void SetupFakeUI(bool expect_started) {
     stream_ui_ = new MockMediaStreamUIProxy();
     if (expect_started) {
       EXPECT_CALL(*stream_ui_, OnStarted(_, _));
@@ skipping 64 matching lines @@
     host_->OnCancelEnumerateDevices(render_frame_id, page_request_id);
   }
 
   void SubscribeToDeviceChangeNotificationsAndWaitForNotification(
       int render_frame_id) {
     base::RunLoop run_loop;
     host_->OnSubscribeToDeviceChangeNotifications(render_frame_id, origin_,
                                                   run_loop.QuitClosure());
     // Simulate a change in the set of devices.
     video_capture_device_factory_->set_number_of_devices(5);
-    media_stream_manager_->OnDevicesChanged(
+    media_stream_manager_->media_devices_manager()->OnDevicesChanged(
         base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
     run_loop.Run();
   }
 
   bool DoesContainRawIds(const StreamDeviceInfoArray& devices) {
     for (size_t i = 0; i < devices.size(); ++i) {
       media::AudioDeviceNames::const_iterator audio_it =
           physical_audio_devices_.begin();
       for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
+        // Skip default and communications audio devices, whose IDs are not
+        // translated.
+        if (devices[i].device.id ==
+                media::AudioDeviceDescription::kDefaultDeviceId ||
+            devices[i].device.id ==
+                media::AudioDeviceDescription::kCommunicationsDeviceId)

[tommi (sloooow) - chröme, 2016/09/20 08:47:15]

nit: {}

[Guido Urdaneta, 2016/09/20 13:59:26]

Done.

+          continue;
         if (audio_it->unique_id == devices[i].device.id)
           return true;
       }
       media::VideoCaptureDeviceDescriptors::const_iterator video_it =
           physical_video_devices_.begin();
       for (; video_it != physical_video_devices_.end(); ++video_it) {
         if (video_it->device_id == devices[i].device.id)
           return true;
       }
     }
@@ skipping 498 matching lines @@
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
   EXPECT_EQ(host_->audio_devices_.size(), 1u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
 
   video_capture_device_factory_->set_number_of_devices(0);
 
   base::RunLoop run_loop;
   EXPECT_CALL(*host_.get(), OnDeviceStopped(kRenderId))
       .WillOnce(testing::InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
-  media_stream_manager_->OnDevicesChanged(
+  media_stream_manager_->media_devices_manager()->OnDevicesChanged(
       base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
 
   run_loop.Run();
 }
 
 TEST_F(MediaStreamDispatcherHostTest, EnumerateAudioDevices) {
   SetupFakeUI(false);
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_AUDIO_CAPTURE);
   EXPECT_TRUE(DoesContainLabels(host_->enumerated_devices_));
@@ skipping 24 matching lines @@
 
 TEST_F(MediaStreamDispatcherHostTest, DeviceChangeNotification) {
   SetupFakeUI(false);
   // warm up the cache
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_VIDEO_CAPTURE);
   SubscribeToDeviceChangeNotificationsAndWaitForNotification(kRenderId);
 }
 
 };  // namespace content