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

The crash in the bug seems to be triggered by empty labels. This should avoid the crash if that's the case.

R=dmichael@chromium.org, kenrb@chromium.org
TBR=xians@chromium.com

BUG=383074

Review URL: https://codereview.chromium.org/323313003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@278184 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/renderer_host/media/media_stream_dispatcher_host.cc

@@ -170,7 +170,8 @@ void MediaStreamDispatcherHost::OnEnumerateDevices(
     int render_view_id,
     int page_request_id,
     MediaStreamType type,
-    const GURL& security_origin) {
+    const GURL& security_origin,
+    bool hide_labels_if_no_access) {
   DVLOG(1) << "MediaStreamDispatcherHost::OnEnumerateDevices("
            << render_view_id << ", "
            << page_request_id << ", "
@@ -183,10 +184,14 @@ void MediaStreamDispatcherHost::OnEnumerateDevices(
   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          type == MEDIA_DEVICE_VIDEO_CAPTURE ||
          type == MEDIA_DEVICE_AUDIO_OUTPUT);
-  bool have_permission =
-      type == MEDIA_DEVICE_AUDIO_CAPTURE || type == MEDIA_DEVICE_AUDIO_OUTPUT ?
-          resource_context_->AllowMicAccess(security_origin) :
-          resource_context_->AllowCameraAccess(security_origin);
+  bool have_permission = true;
+  if (hide_labels_if_no_access) {
+    bool audio_type = type == MEDIA_DEVICE_AUDIO_CAPTURE ||
+                      type == MEDIA_DEVICE_AUDIO_OUTPUT;
+    have_permission = audio_type ?
+        resource_context_->AllowMicAccess(security_origin) :
+        resource_context_->AllowCameraAccess(security_origin);
+  }
 
   media_stream_manager_->EnumerateDevices(
       this, render_process_id_, render_view_id, salt_callback_,

content/browser/renderer_host/media/media_stream_dispatcher_host.h

@@ -79,7 +79,8 @@ class CONTENT_EXPORT MediaStreamDispatcherHost : public BrowserMessageFilter,
   void OnEnumerateDevices(int render_view_id,
                           int page_request_id,
                           MediaStreamType type,
-                          const GURL& security_origin);
+                          const GURL& security_origin,
+                          bool hide_labels_if_no_access);
 
   void OnCancelEnumerateDevices(int render_view_id,
                                 int page_request_id);
@@ -95,7 +96,7 @@ class CONTENT_EXPORT MediaStreamDispatcherHost : public BrowserMessageFilter,
 
   void StoreRequest(int render_view_id,
                     int page_request_id,
-                    const std::string& label);;
+                    const std::string& label);
 
   bool IsURLAllowed(const GURL& url);
 

content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.cc

@@ -99,10 +99,12 @@ class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
                           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_;
@@ -327,10 +329,11 @@ class MediaStreamDispatcherHostTest : public testing::Test {
 
   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_));
@@ -878,32 +881,52 @@ TEST_F(MediaStreamDispatcherHostTest, VideoDeviceUnplugged) {
 
 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

content/common/media/media_stream_messages.h

@@ -126,15 +126,14 @@ IPC_MESSAGE_CONTROL2(MediaStreamHostMsg_GetSources,
                      int /* request id */,
                      GURL /* origin */)
 
-
 // Request to enumerate devices.
-// Used by Pepper.
-// TODO(vrk,wjia): Move this to pepper code.
-IPC_MESSAGE_CONTROL4(MediaStreamHostMsg_EnumerateDevices,
+// Used by Pepper and WebRTC.
+IPC_MESSAGE_CONTROL5(MediaStreamHostMsg_EnumerateDevices,
                      int /* render view id */,
                      int /* request id */,
                      content::MediaStreamType /* type */,
-                     GURL /* security origin */)
+                     GURL /* security origin */,
+                     bool /* hide_labels_if_no_access */)
 
 // Request to stop enumerating devices.
 IPC_MESSAGE_CONTROL2(MediaStreamHostMsg_CancelEnumerateDevices,

content/renderer/media/media_stream_dispatcher.cc

@@ -134,7 +134,8 @@ void MediaStreamDispatcher::EnumerateDevices(
     int request_id,
     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
     MediaStreamType type,
-    const GURL& security_origin) {
+    const GURL& security_origin,
+    bool hide_labels_if_no_access) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          type == MEDIA_DEVICE_VIDEO_CAPTURE ||
@@ -151,7 +152,8 @@ void MediaStreamDispatcher::EnumerateDevices(
   Send(new MediaStreamHostMsg_EnumerateDevices(routing_id(),
                                                next_ipc_id_++,
                                                type,
-                                               security_origin));
+                                               security_origin,
+                                               hide_labels_if_no_access));
 }
 
 void MediaStreamDispatcher::StopEnumerateDevices(

content/renderer/media/media_stream_dispatcher.h

@@ -56,11 +56,15 @@ class CONTENT_EXPORT MediaStreamDispatcher
   virtual void StopStreamDevice(const StreamDeviceInfo& device_info);
 
   // Request to enumerate devices.
+  // If |hide_labels_if_no_access| is true, labels will be empty in the
+  // response if permission has not been granted for the device type. This
+  // should normally be true.
   virtual void EnumerateDevices(
       int request_id,
       const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
       MediaStreamType type,
-      const GURL& security_origin);
+      const GURL& security_origin,
+      bool hide_labels_if_no_access);
 
   // Request to stop enumerating devices.
   void StopEnumerateDevices(

content/renderer/media/media_stream_dispatcher_unittest.cc

@@ -226,13 +226,15 @@ TEST_F(MediaStreamDispatcherTest, BasicVideoDevice) {
   dispatcher->EnumerateDevices(
       kRequestId1, handler1.get()->AsWeakPtr(),
       kVideoType,
-      security_origin);
+      security_origin,
+      false);
   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);
+      security_origin,
+      false);
   EXPECT_EQ(dispatcher->requests_.size(), size_t(2));
 
   StreamDeviceInfoArray video_device_array(1);

content/renderer/media/media_stream_impl.cc

@@ -228,19 +228,22 @@ void MediaStreamImpl::requestMediaDevices(
       audio_input_request_id,
       AsWeakPtr(),
       MEDIA_DEVICE_AUDIO_CAPTURE,
-      security_origin);
+      security_origin,
+      true);
 
   media_stream_dispatcher_->EnumerateDevices(
       video_input_request_id,
       AsWeakPtr(),
       MEDIA_DEVICE_VIDEO_CAPTURE,
-      security_origin);
+      security_origin,
+      true);
 
   media_stream_dispatcher_->EnumerateDevices(
       audio_output_request_id,
       AsWeakPtr(),
       MEDIA_DEVICE_AUDIO_OUTPUT,
-      security_origin);
+      security_origin,
+      true);
 }
 
 void MediaStreamImpl::cancelMediaDevicesRequest(

content/renderer/media/mock_media_stream_dispatcher.cc

@@ -59,7 +59,8 @@ void MockMediaStreamDispatcher::EnumerateDevices(
     int request_id,
     const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
     MediaStreamType type,
-    const GURL& security_origin) {
+    const GURL& security_origin,
+    bool hide_labels_if_no_access) {
   if (type == MEDIA_DEVICE_AUDIO_CAPTURE) {
     audio_input_request_id_ = request_id;
     audio_input_array_.clear();

content/renderer/media/mock_media_stream_dispatcher.h

@@ -31,7 +31,8 @@ class MockMediaStreamDispatcher : public MediaStreamDispatcher {
       int request_id,
       const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
       MediaStreamType type,
-      const GURL& security_origin) OVERRIDE;
+      const GURL& security_origin,
+      bool hide_labels_if_no_access) OVERRIDE;
   virtual void StopStreamDevice(const StreamDeviceInfo& device_info) OVERRIDE;
   virtual bool IsStream(const std::string& label) OVERRIDE;
   virtual int video_session_id(const std::string& label, int index) OVERRIDE;

content/renderer/pepper/pepper_media_device_manager.cc

@@ -54,7 +54,8 @@ int PepperMediaDeviceManager::EnumerateDevices(
       request_id,
       AsWeakPtr(),
       PepperMediaDeviceManager::FromPepperDeviceType(type),
-      document_url.GetOrigin());
+      document_url.GetOrigin(),
+      false);
 #else
   base::MessageLoop::current()->PostTask(
       FROM_HERE,