Add flag in device enumeration request to control label clearing and don't clear for pepper.

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 81 matching lines @@
                     const base::Closure& quit_closure) {
     quit_closures_.push(quit_closure);
     MediaStreamDispatcherHost::OnOpenDevice(
         render_view_id, page_request_id, device_id, type, security_origin);
   }
 
   void OnEnumerateDevices(int render_view_id,
                           int page_request_id,
                           MediaStreamType type,
                           const GURL& security_origin,
+                          bool hide_labels_if_no_access,
                           const base::Closure& quit_closure) {
     quit_closures_.push(quit_closure);
     MediaStreamDispatcherHost::OnEnumerateDevices(
-        render_view_id, page_request_id, type, security_origin);
+        render_view_id, page_request_id, type, security_origin,
+        hide_labels_if_no_access);
   }
 
   std::string label_;
   StreamDeviceInfoArray audio_devices_;
   StreamDeviceInfoArray video_devices_;
   StreamDeviceInfo opened_device_;
   StreamDeviceInfoArray enumerated_devices_;
 
  private:
   virtual ~MockMediaStreamDispatcherHost() {}
@@ skipping 204 matching lines @@
     host_->OnOpenDevice(render_view_id, page_request_id, device_id,
                         MEDIA_DEVICE_VIDEO_CAPTURE, origin_,
                         run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_FALSE(DoesContainRawIds(host_->video_devices_));
     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->video_devices_, origin_));
   }
 
   void EnumerateDevicesAndWaitForResult(int render_view_id,
                                         int page_request_id,
-                                        MediaStreamType type) {
+                                        MediaStreamType type,
+                                        bool hide_labels_if_no_access) {
     base::RunLoop run_loop;
     host_->OnEnumerateDevices(render_view_id, page_request_id, type, origin_,
-                              run_loop.QuitClosure());
+                              hide_labels_if_no_access, 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_));
   }
 
   bool DoesContainRawIds(const StreamDeviceInfoArray& devices) {
     for (size_t i = 0; i < devices.size(); ++i) {
       media::AudioDeviceNames::const_iterator audio_it =
           physical_audio_devices_.begin();
@@ skipping 527 matching lines @@
   EXPECT_CALL(*host_.get(), OnDeviceStopped(kRenderId))
       .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);
+                                   MEDIA_DEVICE_AUDIO_CAPTURE, true);
   EXPECT_TRUE(DoesContainLabels(host_->enumerated_devices_));
 }
 
 TEST_F(MediaStreamDispatcherHostTest, EnumerateVideoDevices) {
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
-                                   MEDIA_DEVICE_VIDEO_CAPTURE);
+                                   MEDIA_DEVICE_VIDEO_CAPTURE, true);
   EXPECT_TRUE(DoesContainLabels(host_->enumerated_devices_));
 }
 
-TEST_F(MediaStreamDispatcherHostTest, EnumerateAudioDevicesNoAccess) {
+TEST_F(MediaStreamDispatcherHostTest, EnumerateAudioDevicesNoAccessHideLabels) {
   MockResourceContext* mock_resource_context =
       static_cast<MockResourceContext*>(browser_context_.GetResourceContext());
   mock_resource_context->set_mic_access(false);
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
-                                   MEDIA_DEVICE_AUDIO_CAPTURE);
+                                   MEDIA_DEVICE_AUDIO_CAPTURE, true);
   EXPECT_TRUE(DoesNotContainLabels(host_->enumerated_devices_));
 }
 
-TEST_F(MediaStreamDispatcherHostTest, EnumerateVideoDevicesNoAccess) {
+TEST_F(MediaStreamDispatcherHostTest, EnumerateVideoDevicesNoAccessHideLabels) {
   MockResourceContext* mock_resource_context =
       static_cast<MockResourceContext*>(browser_context_.GetResourceContext());
   mock_resource_context->set_camera_access(false);
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
-                                   MEDIA_DEVICE_VIDEO_CAPTURE);
+                                   MEDIA_DEVICE_VIDEO_CAPTURE, true);
   EXPECT_TRUE(DoesNotContainLabels(host_->enumerated_devices_));
 }
 
+TEST_F(MediaStreamDispatcherHostTest,
+       EnumerateAudioDevicesNoAccessNoHideLabels) {
+  MockResourceContext* mock_resource_context =
+      static_cast<MockResourceContext*>(browser_context_.GetResourceContext());
+  mock_resource_context->set_mic_access(false);
+  EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
+                                   MEDIA_DEVICE_AUDIO_CAPTURE, false);
+  EXPECT_TRUE(DoesContainLabels(host_->enumerated_devices_));
+}
+
+TEST_F(MediaStreamDispatcherHostTest,
+       EnumerateVideoDevicesNoAccessNoHideLabels) {
+  MockResourceContext* mock_resource_context =
+      static_cast<MockResourceContext*>(browser_context_.GetResourceContext());
+  mock_resource_context->set_camera_access(false);
+  EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
+                                   MEDIA_DEVICE_VIDEO_CAPTURE, false);
+  EXPECT_TRUE(DoesContainLabels(host_->enumerated_devices_));
+}
+
 };  // namespace content