Add different error codes for getUserMedia.

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/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
@@ skipping 333 matching lines @@
 
 void MediaCaptureDevicesDispatcher::ProcessDesktopCaptureAccessRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
     const extensions::Extension* extension) {
   content::MediaStreamDevices devices;
   scoped_ptr<content::MediaStreamUI> ui;
 
   if (request.video_type != content::MEDIA_DESKTOP_VIDEO_CAPTURE) {
-    callback.Run(devices, ui.Pass());
+    callback.Run(devices, content::MEDIA_DEVICE_INVALID_STATE, ui.Pass());
     return;
   }
 
   // If the device id wasn't specified then this is a screen capture request
   // (i.e. chooseDesktopMedia() API wasn't used to generate device id).
   if (request.requested_video_device_id.empty()) {
     ProcessScreenCaptureAccessRequest(
         web_contents, request, callback, extension);
     return;
   }
 
   // The extension name that the stream is registered with.
   std::string original_extension_name;
   // Resolve DesktopMediaID for the specified device id.
   content::DesktopMediaID media_id =
       GetDesktopStreamsRegistry()->RequestMediaForStreamId(
           request.requested_video_device_id, request.render_process_id,
           request.render_view_id, request.security_origin,
           &original_extension_name);
 
   // Received invalid device id.
   if (media_id.type == content::DesktopMediaID::TYPE_NONE) {
-    callback.Run(devices, ui.Pass());
+    callback.Run(devices, content::MEDIA_DEVICE_INVALID_STATE, ui.Pass());
     return;
   }
 
   bool loopback_audio_supported = false;
 #if defined(USE_CRAS) || defined(OS_WIN)
   // Currently loopback audio capture is supported only on Windows and ChromeOS.
   loopback_audio_supported = true;
 #endif
 
   // Audio is only supported for screen capture streams.
   bool capture_audio =
       (media_id.type == content::DesktopMediaID::TYPE_SCREEN &&
        request.audio_type == content::MEDIA_LOOPBACK_AUDIO_CAPTURE &&
        loopback_audio_supported);
 
   ui = GetDevicesForDesktopCapture(
       devices, media_id, capture_audio, true,
       GetApplicationTitle(web_contents, extension),
       base::UTF8ToUTF16(original_extension_name));
 
-  callback.Run(devices, ui.Pass());
+  callback.Run(devices, content::MEDIA_DEVICE_OK, ui.Pass());
 }
 
 void MediaCaptureDevicesDispatcher::ProcessScreenCaptureAccessRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
     const extensions::Extension* extension) {
   content::MediaStreamDevices devices;
   scoped_ptr<content::MediaStreamUI> ui;
 
@@ skipping 69 matching lines @@
       // 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);
     }
   }
 
-  callback.Run(devices, ui.Pass());
+  callback.Run(
+    devices,
+    devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE :
+                      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;
   scoped_ptr<content::MediaStreamUI> ui;
 
 #if defined(OS_ANDROID)
   // Tab capture is not supported on Android.
-  callback.Run(devices, ui.Pass());
+  callback.Run(devices, content::MEDIA_DEVICE_TAB_CAPTURE_FAILURE, ui.Pass());
 #else  // defined(OS_ANDROID)
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   extensions::TabCaptureRegistry* tab_capture_registry =
       extensions::TabCaptureRegistry::Get(profile);
   if (!tab_capture_registry) {
     NOTREACHED();
-    callback.Run(devices, ui.Pass());
+    callback.Run(devices, content::MEDIA_DEVICE_INVALID_STATE, ui.Pass());
     return;
   }
   bool tab_capture_allowed =
       tab_capture_registry->VerifyRequest(request.render_process_id,
                                           request.render_view_id);
 
   if (request.audio_type == content::MEDIA_TAB_AUDIO_CAPTURE &&
       tab_capture_allowed &&
       extension->HasAPIPermission(extensions::APIPermission::kTabCapture)) {
     devices.push_back(content::MediaStreamDevice(
         content::MEDIA_TAB_AUDIO_CAPTURE, std::string(), std::string()));
   }
 
   if (request.video_type == content::MEDIA_TAB_VIDEO_CAPTURE &&
       tab_capture_allowed &&
       extension->HasAPIPermission(extensions::APIPermission::kTabCapture)) {
     devices.push_back(content::MediaStreamDevice(
         content::MEDIA_TAB_VIDEO_CAPTURE, std::string(), std::string()));
   }
 
   if (!devices.empty()) {
     ui = media_stream_capture_indicator_->RegisterMediaStream(
         web_contents, devices);
   }
-  callback.Run(devices, ui.Pass());
+  callback.Run(
+    devices,
+    devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE :
+                      content::MEDIA_DEVICE_OK,
+    ui.Pass());
 #endif  // !defined(OS_ANDROID)
 }
 
 void MediaCaptureDevicesDispatcher::
     ProcessMediaAccessRequestFromPlatformAppOrExtension(
         content::WebContents* web_contents,
         const content::MediaStreamRequest& request,
         const content::MediaResponseCallback& callback,
         const extensions::Extension* extension) {
   content::MediaStreamDevices devices;
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 
   if (request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE &&
       extension->HasAPIPermission(extensions::APIPermission::kAudioCapture)) {
     GetDefaultDevicesForProfile(profile, true, false, &devices);
   }
 
   if (request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE &&
       extension->HasAPIPermission(extensions::APIPermission::kVideoCapture)) {
     GetDefaultDevicesForProfile(profile, false, true, &devices);
   }
 
   scoped_ptr<content::MediaStreamUI> ui;
   if (!devices.empty()) {
     ui = media_stream_capture_indicator_->RegisterMediaStream(
         web_contents, devices);
   }
-  callback.Run(devices, ui.Pass());
+  callback.Run(
+    devices,
+    devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE :
+                      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));
 
   RequestsQueue& queue = pending_requests_[web_contents];
   queue.push_back(PendingAccessRequest(request, callback));
@@ skipping 34 matching lines @@
   // when we've transitioned to bubbles. (crbug/337458)
   MediaStreamInfoBarDelegate::Create(
       web_contents, it->second.front().request,
       base::Bind(&MediaCaptureDevicesDispatcher::OnAccessRequestResponse,
                  base::Unretained(this), web_contents));
 }
 
 void MediaCaptureDevicesDispatcher::OnAccessRequestResponse(
     content::WebContents* web_contents,
     const content::MediaStreamDevices& devices,
+    content::MediaStreamRequestResult result,
     scoped_ptr<content::MediaStreamUI> ui) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::map<content::WebContents*, RequestsQueue>::iterator it =
       pending_requests_.find(web_contents);
   if (it == pending_requests_.end()) {
     // WebContents has been destroyed. Don't need to do anything.
     return;
   }
 
   RequestsQueue& queue(it->second);
   if (queue.empty())
     return;
 
   content::MediaResponseCallback callback = queue.front().callback;
   queue.pop_front();
 
   if (!queue.empty()) {
     // Post a task to process next queued request. It has to be done
     // asynchronously to make sure that calling infobar is not destroyed until
     // after this function returns.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&MediaCaptureDevicesDispatcher::ProcessQueuedAccessRequest,
                    base::Unretained(this), web_contents));
   }
 
-  callback.Run(devices, ui.Pass());
+  callback.Run(devices, result, ui.Pass());
 }
 
 void MediaCaptureDevicesDispatcher::GetDefaultDevicesForProfile(
     Profile* profile,
     bool audio,
     bool video,
     content::MediaStreamDevices* devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(audio || video);
 
@@ skipping 255 matching lines @@
     // info for content::WebContentsUserData).
     AudioStreamMonitor::CreateForWebContents(web_contents);
   }
 #endif
 }
 
 bool MediaCaptureDevicesDispatcher::IsDesktopCaptureInProgress() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return desktop_capture_sessions_.size() > 0;
 }