Add support for device-change notifications to MediaStreamDispatcher and MediaStreamDispatcherHost

content/renderer/media/media_stream_dispatcher_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/renderer/media/media_stream_dispatcher.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 21 matching lines @@
 const int kRequestId4 = 40;
 
 const MediaStreamType kAudioType = MEDIA_DEVICE_AUDIO_CAPTURE;
 const MediaStreamType kVideoType = MEDIA_DEVICE_VIDEO_CAPTURE;
 
 class MockMediaStreamDispatcherEventHandler
     : public MediaStreamDispatcherEventHandler,
       public base::SupportsWeakPtr<MockMediaStreamDispatcherEventHandler> {
  public:
   MockMediaStreamDispatcherEventHandler()
-      : request_id_(-1) {}
+      : request_id_(-1), did_receive_devices_changed_(false) {}
 
   void OnStreamGenerated(
       int request_id,
       const std::string& label,
       const StreamDeviceInfoArray& audio_device_array,
       const StreamDeviceInfoArray& video_device_array) override {
     request_id_ = request_id;
     label_ = label;
     if (audio_device_array.size()) {
       DCHECK(audio_device_array.size() == 1);
@@ skipping 29 matching lines @@
 
   void OnDeviceOpened(int request_id,
                       const std::string& label,
                       const StreamDeviceInfo& video_device) override {
     request_id_ = request_id;
     label_ = label;
   }
 
   void OnDeviceOpenFailed(int request_id) override { request_id_ = request_id; }
 
+  void OnDevicesChanged() override { did_receive_devices_changed_ = true; }
+
   void ResetStoredParameters() {
     request_id_ = -1;
     label_ = "";
     device_stopped_label_ = "";
     audio_device_ = StreamDeviceInfo();
     video_device_ = StreamDeviceInfo();
   }
 
   int request_id_;
   std::string label_;
   std::string device_stopped_label_;
   StreamDeviceInfo audio_device_;
   StreamDeviceInfo video_device_;
+  bool did_receive_devices_changed_;
 };
 
 class MediaStreamDispatcherUnderTest : public MediaStreamDispatcher {
  public:
   MediaStreamDispatcherUnderTest() : MediaStreamDispatcher(NULL) {}
 
   using MediaStreamDispatcher::GetNextIpcIdForTest;
   using RenderFrameObserver::OnMessageReceived;
 };
 
 class MediaStreamDispatcherTest : public ::testing::Test {
  public:
   MediaStreamDispatcherTest()
       : dispatcher_(new MediaStreamDispatcherUnderTest()),
         handler_(new MockMediaStreamDispatcherEventHandler),
-        security_origin_(url::Origin(GURL("http://test.com"))) {}
+        security_origin_(GURL("http://test.com")) {}
 
   // Generates a request for a MediaStream and returns the request id that is
   // used in IPC. Use this returned id in CompleteGenerateStream to identify
   // the request.
   int GenerateStream(const StreamControls& controls, int request_id) {
     int next_ipc_id = dispatcher_->GetNextIpcIdForTest();
     dispatcher_->GenerateStream(request_id, handler_.get()->AsWeakPtr(),
                                 controls, security_origin_);
     return next_ipc_id;
   }
@@ skipping 272 matching lines @@
 
   dispatcher_->OnMessageReceived(
       MediaStreamMsg_DeviceStopped(kRouteId, label, handler_->video_device_));
   // Verify that MediaStreamDispatcherEventHandler::OnDeviceStopped has been
   // called.
   EXPECT_EQ(label, handler_->device_stopped_label_);
   EXPECT_EQ(dispatcher_->video_session_id(label, 0),
             StreamDeviceInfo::kNoId);
 }
 
+// Test that the MediaStreamDispatcherEventHandler is notified when the message
+// MediaStreamMsg_DevicesChanged is received.
+TEST_F(MediaStreamDispatcherTest, DevicesChanged) {
+  std::unique_ptr<MockMediaStreamDispatcherEventHandler> handler1(
+      new MockMediaStreamDispatcherEventHandler);
+  std::unique_ptr<MockMediaStreamDispatcherEventHandler> handler2(
+      new MockMediaStreamDispatcherEventHandler);
+  dispatcher_->SubscribeToDeviceChangeNotifications(handler1->AsWeakPtr(),
+                                                    security_origin_);
+  dispatcher_->SubscribeToDeviceChangeNotifications(handler2->AsWeakPtr(),
+                                                    security_origin_);
+  EXPECT_DEATH(dispatcher_->SubscribeToDeviceChangeNotifications(
+                   handler2->AsWeakPtr(), security_origin_),
+               "");
+  dispatcher_->OnMessageReceived(MediaStreamMsg_DevicesChanged(kRouteId));
+  dispatcher_->CancelDeviceChangeNotifications(handler1->AsWeakPtr());
+  dispatcher_->CancelDeviceChangeNotifications(handler2->AsWeakPtr());
+
+  EXPECT_TRUE(handler1->did_receive_devices_changed_);
+  EXPECT_TRUE(handler2->did_receive_devices_changed_);
+  EXPECT_DEATH(
+      dispatcher_->CancelDeviceChangeNotifications(handler2->AsWeakPtr()), "");
+}
+
 }  // namespace content