Change two media request "invalid state" results.

chrome/browser/media/media_capture_devices_dispatcher.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 "chrome/browser/media/media_capture_devices_dispatcher.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
@@ skipping 608 matching lines @@
           (request.audio_type == content::MEDIA_LOOPBACK_AUDIO_CAPTURE &&
            loopback_audio_supported);
 
       // Unless we're being invoked from a component extension, register to
       // display the notification for stream capture.
       bool display_notification = !component_extension;
 
       ui = GetDevicesForDesktopCapture(devices, screen_id, capture_audio,
                                        display_notification, application_title,
                                        application_title);
+      DCHECK(!devices.empty());
     }
   }
 
+  // The only case when devices can be empty is if the user has denied
+  // permission.

[tommi (sloooow) - chröme, 2014/09/20 14:45:23]

or !screen_capture_enabled or !origin_is_secure?

in either case, I think that 'permission denied' would be the appropriate error
code (unless we add a specific one for screen capture).

[Henrik Grunell, 2014/09/22 09:16:14]

Ah, right.
I'd prefer to have the permission denied for user action, though I do think we
use it for non-user action cases in other places already. I changed it so that
invalid state is kept for the cases you pointed out. Wdyt?

I could add another denied result in a follow-up that's used for non-user action
denial such as this case.

   callback.Run(
     devices,
-    devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE :
+    devices.empty() ? content::MEDIA_DEVICE_PERMISSION_DENIED :
                       content::MEDIA_DEVICE_OK,
     ui.Pass());
 }
 
 void MediaCaptureDevicesDispatcher::ProcessTabCaptureAccessRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
     const extensions::Extension* extension) {
   content::MediaStreamDevices devices;
@@ skipping 59 matching lines @@
   bool video_allowed =
       request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE &&
       extension->permissions_data()->HasAPIPermission(
           extensions::APIPermission::kVideoCapture);
 
   bool get_default_audio_device = audio_allowed;
   bool get_default_video_device = video_allowed;
 
   content::MediaStreamDevices devices;
 
+  // Set an initial error result. If neither audio or video is allowed, we'll
+  // never try to get any device below but will just create |ui| and return an
+  // empty list with "invalid state" result. If at least one is allowed, we'll
+  // try to get device(s), and if failure, we want to return "no hardware"
+  // result.
+  // TODO(grunell): The invalid state result should be changed to a new denied
+  // result + a dcheck to ensure at least one of audio or video types is
+  // capture.
+  content::MediaStreamRequestResult result =
+      audio_allowed || video_allowed ? content::MEDIA_DEVICE_NO_HARDWARE
+                                     : content::MEDIA_DEVICE_INVALID_STATE;

[tommi (sloooow) - chröme, 2014/09/20 14:45:23]

instead of invalid state, should it be permission denied if neither video nor
audio is allowed?

[Henrik Grunell, 2014/09/22 09:16:14]

Same reply as above, as the todo also says.

+
   // Get the exact audio or video device if an id is specified.
+  // We only set any error result here and before running the callback change
+  // it to OK if we have any device.
   if (audio_allowed && !request.requested_audio_device_id.empty()) {
     const content::MediaStreamDevice* audio_device =
         GetRequestedAudioDevice(request.requested_audio_device_id);
     if (audio_device) {
       devices.push_back(*audio_device);
       get_default_audio_device = false;
     }
   }
   if (video_allowed && !request.requested_video_device_id.empty()) {
     const content::MediaStreamDevice* video_device =
@@ skipping 10 matching lines @@
     Profile* profile =
         Profile::FromBrowserContext(web_contents->GetBrowserContext());
     GetDefaultDevicesForProfile(profile,
                                 get_default_audio_device,
                                 get_default_video_device,
                                 &devices);
   }
 
   scoped_ptr<content::MediaStreamUI> ui;
   if (!devices.empty()) {
+    result = content::MEDIA_DEVICE_OK;
     ui = media_stream_capture_indicator_->RegisterMediaStream(
         web_contents, devices);
   }
   callback.Run(
     devices,
     devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE :

[tommi (sloooow) - chröme, 2014/09/20 14:45:23]

did you mean to use |result| here?

[tommi (sloooow) - chröme, 2014/09/22 20:15:02]

I guess you missed this comment?

[Henrik Grunell, 2014/09/23 07:39:28]

Yep. It's fixed now.

                       content::MEDIA_DEVICE_OK,
     ui.Pass());
 }
 
 void MediaCaptureDevicesDispatcher::ProcessRegularMediaAccessRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 303 matching lines @@
 
 void MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices(
     const MediaStreamDevices& devices) {
   test_audio_devices_ = devices;
 }
 
 void MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices(
     const MediaStreamDevices& devices) {
   test_video_devices_ = devices;
 }