Add different error codes for getUserMedia.

content/browser/renderer_host/media/media_stream_manager.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 "content/browser/renderer_host/media/media_stream_manager.h"
 
 #include <list>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 70 matching lines @@
                                                &mandatory)) {
        DCHECK(mandatory);
        // This is tab or screen capture.
        if (audio_stream_source == kMediaStreamSourceTab) {
          *audio_type = content::MEDIA_TAB_AUDIO_CAPTURE;
        } else if (audio_stream_source == kMediaStreamSourceSystem) {
          *audio_type = content::MEDIA_LOOPBACK_AUDIO_CAPTURE;
        }
      } else {
        // This is normal audio device capture.
-       *audio_type = content::MEDIA_DEVICE_AUDIO_CAPTURE;
+       *audio_type = MEDIA_DEVICE_AUDIO_CAPTURE;
      }
   }
   if (options.video_requested) {
      std::string video_stream_source;
      bool mandatory = false;
      if (options.GetFirstVideoConstraintByName(kMediaStreamSource,
                                                &video_stream_source,
                                                &mandatory)) {
        DCHECK(mandatory);
        // This is tab or screen capture.
        if (video_stream_source == kMediaStreamSourceTab) {
          *video_type = content::MEDIA_TAB_VIDEO_CAPTURE;
        } else if (video_stream_source == kMediaStreamSourceScreen) {
          *video_type = content::MEDIA_DESKTOP_VIDEO_CAPTURE;
        } else if (video_stream_source == kMediaStreamSourceDesktop) {
          *video_type = content::MEDIA_DESKTOP_VIDEO_CAPTURE;
        }
      } else {
        // This is normal video device capture.
-       *video_type = content::MEDIA_DEVICE_VIDEO_CAPTURE;
+       *video_type = MEDIA_DEVICE_VIDEO_CAPTURE;
      }
   }
 }
 
 // Private helper method for SendMessageToNativeLog() that obtains the global
 // MediaStreamManager instance on the UI thread before sending |message| to the
 // webrtcLoggingPrivate API.
 void DoAddLogMessage(const std::string& message) {
   // Must be on the UI thread to access BrowserMainLoop.
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
@@ skipping 923 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DeviceRequest* request = FindRequest(label);
   if (!request) {
     DVLOG(1) << "SetupRequest label " << label << " doesn't exist!!";
     return;  // This can happen if the request has been canceled.
   }
 
   if (!request->security_origin.is_valid()) {
     LOG(ERROR) << "Invalid security origin. "
                << request->security_origin;
-    FinalizeRequestFailed(label, request);
+    FinalizeRequestFailed(label,
+                          request,
+                          MEDIA_DEVICE_INVALID_SECURITY_ORIGIN);
     return;
   }
 
   MediaStreamType audio_type = MEDIA_NO_SERVICE;
   MediaStreamType video_type = MEDIA_NO_SERVICE;
   ParseStreamType(request->options, &audio_type, &video_type);
   request->SetAudioType(audio_type);
   request->SetVideoType(video_type);
 
   bool is_web_contents_capture =
       audio_type == MEDIA_TAB_AUDIO_CAPTURE ||
       video_type == MEDIA_TAB_VIDEO_CAPTURE;
   if (is_web_contents_capture && !SetupTabCaptureRequest(request)) {
-    FinalizeRequestFailed(label, request);
+    FinalizeRequestFailed(label,
+                          request,
+                          MEDIA_DEVICE_TAB_CAPTURE_FAILURE);
     return;
   }
 
   bool is_screen_capture =
       video_type == MEDIA_DESKTOP_VIDEO_CAPTURE;
   if (is_screen_capture && !SetupScreenCaptureRequest(request)) {
-    FinalizeRequestFailed(label, request);
+    FinalizeRequestFailed(label,
+                          request,
+                          MEDIA_DEVICE_SCREEN_CAPTURE_FAILURE);
     return;
   }
 
   if (!is_web_contents_capture && !is_screen_capture) {
     if (EnumerationRequired(&audio_enumeration_cache_, audio_type) ||
         EnumerationRequired(&video_enumeration_cache_, video_type)) {
       // Enumerate the devices if there is no valid device lists to be used.
       StartEnumeration(request);
       return;
     } else {
         // Cache is valid, so log the cached devices for MediaStream requests.
       if (request->request_type == MEDIA_GENERATE_STREAM) {
         std::string log_message("Using cached devices for request.\n");
         if (audio_type != MEDIA_NO_SERVICE) {
           log_message +=
               GetLogMessageString(audio_type, audio_enumeration_cache_.devices);
         }
         if (video_type != MEDIA_NO_SERVICE) {
           log_message +=
               GetLogMessageString(video_type, video_enumeration_cache_.devices);
         }
         SendMessageToNativeLog(log_message);
       }
     }
 
     if (!SetupDeviceCaptureRequest(request)) {
-      FinalizeRequestFailed(label, request);
+      FinalizeRequestFailed(label, request, MEDIA_DEVICE_CAPTURE_FAILURE);
       return;
     }
   }
   PostRequestToUI(label, request);
 }
 
 bool MediaStreamManager::SetupDeviceCaptureRequest(DeviceRequest* request) {
   DCHECK((request->audio_type() == MEDIA_DEVICE_AUDIO_CAPTURE ||
           request->audio_type() == MEDIA_NO_SERVICE) &&
          (request->video_type() == MEDIA_DEVICE_VIDEO_CAPTURE ||
@@ skipping 174 matching lines @@
   }
 
   request->requester->StreamGenerated(
       request->requesting_view_id,
       request->page_request_id,
       label, audio_devices, video_devices);
 }
 
 void MediaStreamManager::FinalizeRequestFailed(
     const std::string& label,
-    DeviceRequest* request) {
+    DeviceRequest* request,
+    content::MediaStreamRequestResult result) {
   if (request->requester)
     request->requester->StreamGenerationFailed(
         request->requesting_view_id,
-        request->page_request_id);
+        request->page_request_id,
+        result);
 
   if (request->request_type == MEDIA_DEVICE_ACCESS &&
       !request->callback.is_null()) {
     request->callback.Run(MediaStreamDevices(), request->ui_proxy.Pass());
   }
 
   DeleteRequest(label);
 }
 
 void MediaStreamManager::FinalizeOpenDevice(const std::string& label,
@@ skipping 225 matching lines @@
       default:
         if (request->state(request->audio_type()) ==
                 MEDIA_REQUEST_STATE_REQUESTED ||
             request->state(request->video_type()) ==
                 MEDIA_REQUEST_STATE_REQUESTED) {
           // We are doing enumeration for other type of media, wait until it is
           // all done before posting the request to UI because UI needs
           // the device lists to handle the request.
           break;
         }
-        if (!SetupDeviceCaptureRequest(request))
-          FinalizeRequestFailed(*it, request);
-        else
+        if (!SetupDeviceCaptureRequest(request)) {
+          FinalizeRequestFailed(*it,
+                                request,
+                                MEDIA_DEVICE_CAPTURE_FAILURE);
+        } else {
           PostRequestToUI(*it, request);
+        }
         break;
     }
   }
   label_list.clear();
   --active_enumeration_ref_count_[stream_type];
   DCHECK_GE(active_enumeration_ref_count_[stream_type], 0);
 }
 
 // static
 void MediaStreamManager::SendMessageToNativeLog(const std::string& message) {
@@ skipping 43 matching lines @@
         static_cast<content::RenderProcessHostImpl*>(
             content::RenderProcessHost::FromID(*it));
     if (render_process_host_impl)
       render_process_host_impl->WebRtcLogMessage(message);
   }
 #endif
 }
 
 void MediaStreamManager::HandleAccessRequestResponse(
     const std::string& label,
-    const MediaStreamDevices& devices) {
+    const MediaStreamDevices& devices,
+    content::MediaStreamRequestResult result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "HandleAccessRequestResponse("
            << ", {label = " << label <<  "})";
 
   DeviceRequest* request = FindRequest(label);
   if (!request) {
     // The request has been canceled before the UI returned.
     return;
   }
 
   if (request->request_type == MEDIA_DEVICE_ACCESS) {
     FinalizeMediaAccessRequest(label, request, devices);
     return;
   }
 
   // Handle the case when the request was denied.
-  if (devices.empty()) {
-    FinalizeRequestFailed(label, request);
+  if (result != MEDIA_DEVICE_OK) {
+    FinalizeRequestFailed(label, request, result);
     return;
   }
 
   // Process all newly-accepted devices for this request.
   bool found_audio = false;
   bool found_video = false;
   for (MediaStreamDevices::const_iterator device_it = devices.begin();
        device_it != devices.end(); ++device_it) {
     StreamDeviceInfo device_info;
     device_info.device = *device_it;
@@ skipping 194 matching lines @@
   }
 
   // Always do enumeration even though some enumeration is in progress,
   // because those enumeration commands could be sent before these devices
   // change.
   ++active_enumeration_ref_count_[stream_type];
   GetDeviceManager(stream_type)->EnumerateDevices(stream_type);
 }
 
 }  // namespace content