Remove dead code related to media device enumerations and monitoring.

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 10 matching lines @@
 #include "url/origin.h"
 
 namespace content {
 namespace {
 
 const int kRouteId = 0;
 const int kAudioSessionId = 3;
 const int kVideoSessionId = 5;
 const int kRequestId1 = 10;
 const int kRequestId2 = 20;
-const int kRequestId3 = 30;
-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), did_receive_devices_changed_(false) {}
+  MockMediaStreamDispatcherEventHandler() : request_id_(-1) {}
 
   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 15 matching lines @@
                        const StreamDeviceInfo& device_info) override {
     device_stopped_label_ = label;
     if (IsVideoMediaType(device_info.device.type)) {
       EXPECT_TRUE(StreamDeviceInfo::IsEqual(video_device_, device_info));
     }
     if (IsAudioInputMediaType(device_info.device.type)) {
       EXPECT_TRUE(StreamDeviceInfo::IsEqual(audio_device_, device_info));
     }
   }
 
-  void OnDevicesEnumerated(int request_id,
-                           const StreamDeviceInfoArray& device_array) override {
-    request_id_ = request_id;
-  }
-
   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;
 };
 
@@ skipping 100 matching lines @@
 
 TEST_F(MediaStreamDispatcherTest, BasicVideoDevice) {
   std::unique_ptr<MediaStreamDispatcher> dispatcher(
       new MediaStreamDispatcher(NULL));
   std::unique_ptr<MockMediaStreamDispatcherEventHandler> handler1(
       new MockMediaStreamDispatcherEventHandler);
   std::unique_ptr<MockMediaStreamDispatcherEventHandler> handler2(
       new MockMediaStreamDispatcherEventHandler);
   url::Origin security_origin;
 
-  int ipc_request_id1 = dispatcher->next_ipc_id_;
-  dispatcher->EnumerateDevices(
-      kRequestId1, handler1.get()->AsWeakPtr(),
-      kVideoType,
-      security_origin);
-  int ipc_request_id2 = dispatcher->next_ipc_id_;
-  EXPECT_NE(ipc_request_id1, ipc_request_id2);
-  dispatcher->EnumerateDevices(
-      kRequestId2, handler2.get()->AsWeakPtr(),
-      kVideoType,
-      security_origin);
-  EXPECT_EQ(dispatcher->requests_.size(), size_t(2));
-
   StreamDeviceInfoArray video_device_array(1);
   StreamDeviceInfo video_device_info;
   video_device_info.device.name = "Camera";
   video_device_info.device.id = "device_path";
   video_device_info.device.type = kVideoType;
   video_device_info.session_id = kVideoSessionId;
   video_device_array[0] = video_device_info;
 
-  // Complete the first enumeration request.
-  dispatcher->OnMessageReceived(MediaStreamMsg_DevicesEnumerated(
-      kRouteId, ipc_request_id1, video_device_array));
-  EXPECT_EQ(handler1->request_id_, kRequestId1);
-
-  dispatcher->OnMessageReceived(MediaStreamMsg_DevicesEnumerated(
-        kRouteId, ipc_request_id2, video_device_array));
-  EXPECT_EQ(handler2->request_id_, kRequestId2);
-
-  EXPECT_EQ(dispatcher->requests_.size(), size_t(2));
+  EXPECT_EQ(dispatcher->requests_.size(), size_t(0));
   EXPECT_EQ(dispatcher->label_stream_map_.size(), size_t(0));
 
-  int ipc_request_id3 = dispatcher->next_ipc_id_;
-  dispatcher->OpenDevice(kRequestId3, handler1.get()->AsWeakPtr(),
-                         video_device_info.device.id,
-                         kVideoType,
+  int ipc_request_id1 = dispatcher->next_ipc_id_;
+  dispatcher->OpenDevice(kRequestId1, handler1.get()->AsWeakPtr(),
+                         video_device_info.device.id, kVideoType,
                          security_origin);
-  int ipc_request_id4 = dispatcher->next_ipc_id_;
-  EXPECT_NE(ipc_request_id3, ipc_request_id4);
-  dispatcher->OpenDevice(kRequestId4, handler1.get()->AsWeakPtr(),
-                         video_device_info.device.id,
-                         kVideoType,
+  int ipc_request_id2 = dispatcher->next_ipc_id_;
+  EXPECT_NE(ipc_request_id1, ipc_request_id2);
+  dispatcher->OpenDevice(kRequestId2, handler1.get()->AsWeakPtr(),
+                         video_device_info.device.id, kVideoType,
                          security_origin);
-  EXPECT_EQ(dispatcher->requests_.size(), size_t(4));
+  EXPECT_EQ(dispatcher->requests_.size(), size_t(2));
 
   // Complete the OpenDevice of request 1.
   std::string stream_label1 = std::string("stream1");
   dispatcher->OnMessageReceived(MediaStreamMsg_DeviceOpened(
-      kRouteId, ipc_request_id3, stream_label1, video_device_info));
-  EXPECT_EQ(handler1->request_id_, kRequestId3);
+      kRouteId, ipc_request_id1, stream_label1, video_device_info));
+  EXPECT_EQ(handler1->request_id_, kRequestId1);
 
   // Complete the OpenDevice of request 2.
   std::string stream_label2 = std::string("stream2");
   dispatcher->OnMessageReceived(MediaStreamMsg_DeviceOpened(
-      kRouteId, ipc_request_id4, stream_label2, video_device_info));
-  EXPECT_EQ(handler1->request_id_, kRequestId4);
+      kRouteId, ipc_request_id2, stream_label2, video_device_info));
+  EXPECT_EQ(handler1->request_id_, kRequestId2);
 
-  EXPECT_EQ(dispatcher->requests_.size(), size_t(2));
+  EXPECT_EQ(dispatcher->requests_.size(), size_t(0));
   EXPECT_EQ(dispatcher->label_stream_map_.size(), size_t(2));
 
   // Check the video_session_id.
   EXPECT_EQ(dispatcher->video_session_id(stream_label1, 0), kVideoSessionId);
   EXPECT_EQ(dispatcher->video_session_id(stream_label2, 0), kVideoSessionId);
 
   // Close the device from request 2.
   dispatcher->CloseDevice(stream_label2);
   EXPECT_EQ(dispatcher->video_session_id(stream_label2, 0),
             StreamDeviceInfo::kNoId);
 
   // Close the device from request 1.
   dispatcher->CloseDevice(stream_label1);
   EXPECT_EQ(dispatcher->video_session_id(stream_label1, 0),
             StreamDeviceInfo::kNoId);
   EXPECT_EQ(dispatcher->label_stream_map_.size(), size_t(0));
 
   // Verify that the request have been completed.
   EXPECT_EQ(dispatcher->label_stream_map_.size(), size_t(0));
-  EXPECT_EQ(dispatcher->requests_.size(), size_t(2));
+  EXPECT_EQ(dispatcher->requests_.size(), size_t(0));
 }
 
 TEST_F(MediaStreamDispatcherTest, TestFailure) {
   std::unique_ptr<MediaStreamDispatcher> dispatcher(
       new MediaStreamDispatcher(NULL));
   std::unique_ptr<MockMediaStreamDispatcherEventHandler> handler(
       new MockMediaStreamDispatcherEventHandler);
   StreamControls components(true, true);
   url::Origin security_origin;
 
@@ skipping 89 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_);
-  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_);
-}
-
 }  // namespace content