Implement getMediaDevices.

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 <string>
 #include <queue>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 33 matching lines @@
 const int kPageRequestId = 7;
 
 namespace content {
 
 class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
                                       public TestContentBrowserClient {
  public:
   MockMediaStreamDispatcherHost(
       const ResourceContext::SaltCallback salt_callback,
       const scoped_refptr<base::MessageLoopProxy>& message_loop,
-      MediaStreamManager* manager)
-      : MediaStreamDispatcherHost(kProcessId, salt_callback, manager),
+      MediaStreamManager* manager,
+      ResourceContext* resource_context)
+      : MediaStreamDispatcherHost(kProcessId, salt_callback, manager,
+                                  resource_context),
         message_loop_(message_loop),
         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 157 matching lines @@
     CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kUseFakeDeviceForMediaStream);
     // Create our own MediaStreamManager.
     media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
     video_capture_device_factory_ =
         static_cast<media::FakeVideoCaptureDeviceFactory*>(
             media_stream_manager_->video_capture_manager()
             ->video_capture_device_factory());
     DCHECK(video_capture_device_factory_);
 
+    MockResourceContext* mock_resource_context =
+        static_cast<MockResourceContext*>(
+            browser_context_.GetResourceContext());
+    mock_resource_context->set_mic_access(true);
+    mock_resource_context->set_camera_access(true);
+
     host_ = new MockMediaStreamDispatcherHost(
-        browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
+        mock_resource_context->GetMediaDeviceIDSalt(),
         base::MessageLoopProxy::current(),
-        media_stream_manager_.get());
+        media_stream_manager_.get(),
+        mock_resource_context);
 
     // Use the fake content client and browser.
     content_client_.reset(new TestContentClient());
     SetContentClient(content_client_.get());
     old_browser_client_ = SetBrowserClientForTesting(host_.get());
   }
 
   virtual ~MediaStreamDispatcherHostTest() {
   }
 
@@ skipping 126 matching lines @@
           EXPECT_FALSE(found_match);
           found_match = true;
         }
       }
       if (!found_match)
         return false;
     }
     return true;
   }
 
+  // Returns true if all devices have labels, false otherwise.
+  bool DoesContainLabels(const StreamDeviceInfoArray& devices) {
+    for (size_t i = 0; i < devices.size(); ++i) {
+      if (devices[i].device.name.empty())
+        return false;
+    }
+    return true;
+  }
+
+  // Returns true if no devices have labels, false otherwise.
+  bool DoesNotContainLabels(const StreamDeviceInfoArray& devices) {
+    for (size_t i = 0; i < devices.size(); ++i) {
+      if (!devices[i].device.name.empty())
+        return false;
+    }
+    return true;
+  }
+
   void AddSourceIdConstraint(const std::string& source_id,
                              StreamOptions::Constraints* constraints) {
     constraints->push_back(StreamOptions::Constraint(kMediaStreamSourceInfoId,
                                                      source_id));
   }
 
   scoped_refptr<MockMediaStreamDispatcherHost> host_;
   scoped_ptr<media::AudioManager> audio_manager_;
   scoped_ptr<MediaStreamManager> media_stream_manager_;
   ContentBrowserClient* old_browser_client_;
@@ skipping 452 matching lines @@
       .WillOnce(testing::InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   media_stream_manager_->OnDevicesChanged(
       base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
 
   run_loop.Run();
 }
 
 TEST_F(MediaStreamDispatcherHostTest, EnumerateAudioDevices) {
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_AUDIO_CAPTURE);
+  EXPECT_TRUE(DoesContainLabels(host_->enumerated_devices_));
 }
 
 TEST_F(MediaStreamDispatcherHostTest, EnumerateVideoDevices) {
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_VIDEO_CAPTURE);
+  EXPECT_TRUE(DoesContainLabels(host_->enumerated_devices_));
+}
+
+TEST_F(MediaStreamDispatcherHostTest, EnumerateAudioDevicesNoAccess) {
+  MockResourceContext* mock_resource_context =
+      static_cast<MockResourceContext*>(browser_context_.GetResourceContext());
+  mock_resource_context->set_mic_access(false);
+  EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
+                                   MEDIA_DEVICE_AUDIO_CAPTURE);
+  EXPECT_TRUE(DoesNotContainLabels(host_->enumerated_devices_));
+}
+
+TEST_F(MediaStreamDispatcherHostTest, EnumerateVideoDevicesNoAccess) {
+  MockResourceContext* mock_resource_context =
+      static_cast<MockResourceContext*>(browser_context_.GetResourceContext());
+  mock_resource_context->set_camera_access(false);
+  EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
+                                   MEDIA_DEVICE_VIDEO_CAPTURE);
+  EXPECT_TRUE(DoesNotContainLabels(host_->enumerated_devices_));
 }
 
 };  // namespace content