Add support for device-change notifications to MediaStreamDispatcher and MediaStreamDispatcherHost

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 <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/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"
@@ skipping 30 matching lines @@
 
 namespace content {
 
 class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
                                       public TestContentBrowserClient {
  public:
   MockMediaStreamDispatcherHost(
       const ResourceContext::SaltCallback salt_callback,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       MediaStreamManager* manager)
-      : MediaStreamDispatcherHost(kProcessId, salt_callback, manager),
+      : MediaStreamDispatcherHost(kProcessId, salt_callback, manager, true),
         task_runner_(task_runner),
         current_ipc_(NULL) {}
 
   // A list of mock methods.
   MOCK_METHOD4(OnStreamGenerated,
                void(int routing_id, int request_id, int audio_array_size,
                     int video_array_size));
   MOCK_METHOD3(OnStreamGenerationFailed, void(int routing_id,
                                               int request_id,
                                               MediaStreamRequestResult result));
@@ skipping 30 matching lines @@
   void OnEnumerateDevices(int render_frame_id,
                           int page_request_id,
                           MediaStreamType type,
                           const url::Origin& security_origin,
                           const base::Closure& quit_closure) {
     quit_closures_.push(quit_closure);
     MediaStreamDispatcherHost::OnEnumerateDevices(
         render_frame_id, page_request_id, type, security_origin);
   }
 
+  void OnCancelEnumerateDevices(int render_frame_id, int page_request_id) {
+    MediaStreamDispatcherHost::OnCancelEnumerateDevices(render_frame_id,
+                                                        page_request_id);
+  }
+
+  void OnSubscribeToDeviceChangeNotifications(
+      int render_frame_id,
+      const url::Origin& security_origin,
+      const base::Closure& quit_closure) {
+    quit_closures_.push(quit_closure);
+    MediaStreamDispatcherHost::OnSubscribeToDeviceChangeNotifications(
+        render_frame_id, security_origin);
+  }
+
   std::string label_;
   StreamDeviceInfoArray audio_devices_;
   StreamDeviceInfoArray video_devices_;
   StreamDeviceInfo opened_device_;
   StreamDeviceInfoArray enumerated_devices_;
 
  private:
   ~MockMediaStreamDispatcherHost() override {}
 
   // This method is used to dispatch IPC messages to the renderer. We intercept
   // these messages here and dispatch to our mock methods to verify the
   // conversation between this object and the renderer.
   bool Send(IPC::Message* message) override {
     CHECK(message);
     current_ipc_ = message;
 
-    // In this method we dispatch the messages to the according handlers as if
-    // we are the renderer.
+    // In this method we dispatch the messages to the corresponding handlers as
+    // if we are the renderer.
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(MockMediaStreamDispatcherHost, *message)
       IPC_MESSAGE_HANDLER(MediaStreamMsg_StreamGenerated,
                           OnStreamGeneratedInternal)
       IPC_MESSAGE_HANDLER(MediaStreamMsg_StreamGenerationFailed,
                           OnStreamGenerationFailedInternal)
       IPC_MESSAGE_HANDLER(MediaStreamMsg_DeviceStopped, OnDeviceStoppedInternal)
       IPC_MESSAGE_HANDLER(MediaStreamMsg_DeviceOpened, OnDeviceOpenedInternal)
       IPC_MESSAGE_HANDLER(MediaStreamMsg_DevicesEnumerated, OnDevicesEnumerated)
+      IPC_MESSAGE_HANDLER(MediaStreamMsg_DevicesChanged, OnDevicesChanged)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     EXPECT_TRUE(handled);
 
     delete message;
     current_ipc_ = NULL;
     return true;
   }
 
   // These handler methods do minimal things and delegate to the mock methods.
@@ skipping 48 matching lines @@
   }
 
   void OnDevicesEnumerated(int request_id,
                            const StreamDeviceInfoArray& devices) {
     base::Closure quit_closure = quit_closures_.front();
     quit_closures_.pop();
     task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&quit_closure));
     enumerated_devices_ = devices;
   }
 
+  void OnDevicesChanged() {
+    base::Closure quit_closure = quit_closures_.front();
+    quit_closures_.pop();
+    task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&quit_closure));
+  }
+
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   IPC::Message* current_ipc_;
   std::queue<base::Closure> quit_closures_;
 };
 
 class MockMediaStreamUIProxy : public FakeMediaStreamUIProxy {
  public:
   MOCK_METHOD2(
       OnStarted,
       void(const base::Closure& stop,
@@ skipping 120 matching lines @@
   void EnumerateDevicesAndWaitForResult(int render_frame_id,
                                         int page_request_id,
                                         MediaStreamType type) {
     base::RunLoop run_loop;
     host_->OnEnumerateDevices(render_frame_id, page_request_id, type, origin_,
                               run_loop.QuitClosure());
     run_loop.Run();
     ASSERT_FALSE(host_->enumerated_devices_.empty());
     EXPECT_FALSE(DoesContainRawIds(host_->enumerated_devices_));
     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->enumerated_devices_, origin_));
+    // Enumeration requests must be cancelled manually.
+    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(
+        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) {
         if (audio_it->unique_id == devices[i].device.id)
           return true;
       }
@@ skipping 545 matching lines @@
 }
 
 TEST_F(MediaStreamDispatcherHostTest, EnumerateVideoDevicesNoAccess) {
   SetupFakeUI(false);
   stream_ui_->SetCameraAccess(false);
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_VIDEO_CAPTURE);
   EXPECT_TRUE(DoesNotContainLabels(host_->enumerated_devices_));
 }
 
+TEST_F(MediaStreamDispatcherHostTest, DeviceChangeNotification) {
+  SetupFakeUI(false);
+  // warm up the cache
+  EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
+                                   MEDIA_DEVICE_VIDEO_CAPTURE);
+  SubscribeToDeviceChangeNotificationsAndWaitForNotification(kRenderId);
+}
+
 };  // namespace content