Add different error codes for getUserMedia.

content/renderer/media/media_stream_impl.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/renderer/media/media_stream_impl.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
@@ skipping 334 matching lines @@
           base::Bind(&MediaStreamImpl::OnLocalMediaStreamStop, AsWeakPtr()),
           *web_stream));
 
   // Wait for the tracks to be started successfully or to fail.
   request_info->CallbackOnTracksStarted(
       base::Bind(&MediaStreamImpl::OnCreateNativeTracksCompleted, AsWeakPtr()));
 }
 
 // Callback from MediaStreamDispatcher.
 // The requested stream failed to be generated.
-void MediaStreamImpl::OnStreamGenerationFailed(int request_id) {
+void MediaStreamImpl::OnStreamGenerationFailed(
+    int request_id,
+    content::MediaStreamRequestResult result) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "MediaStreamImpl::OnStreamGenerationFailed("
            << request_id << ")";
   UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id);
   if (!request_info) {
     // This can happen if the request is canceled or the frame reloads while
     // MediaStreamDispatcher is processing the request.
     DVLOG(1) << "Request ID not found";
     return;
   }
   CompleteGetUserMediaRequest(request_info->web_stream,
                               &request_info->request,
-                              false);
+                              result);
   DeleteUserMediaRequestInfo(request_info);
 }
 
 // Callback from MediaStreamDispatcher.
 // The browser process has stopped a device used by a MediaStream.
 void MediaStreamImpl::OnDeviceStopped(
     const std::string& label,
     const StreamDeviceInfo& device_info) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "MediaStreamImpl::OnDeviceStopped("
@@ skipping 142 matching lines @@
                            constraints,
                            request->frame,
                            &webkit_source);
     (*webkit_tracks)[i].initialize(webkit_source);
     request->StartTrack((*webkit_tracks)[i], constraints);
   }
 }
 
 void MediaStreamImpl::OnCreateNativeTracksCompleted(
     UserMediaRequestInfo* request,
-    bool request_succeeded) {
+    content::MediaStreamRequestResult result) {
   DVLOG(1) << "MediaStreamImpl::OnCreateNativeTracksComplete("
            << "{request_id = " << request->request_id << "} "
-           << "{request_succeeded = " << request_succeeded << "})";
+           << "{result = " << result << "})";
   CompleteGetUserMediaRequest(request->web_stream, &request->request,
-                              request_succeeded);
-  if (!request_succeeded) {
+                              result);
+  if (result != MEDIA_DEVICE_OK) {
     // TODO(perkj): Once we don't support MediaStream::Stop the |request_info|
     // can be deleted even if the request succeeds.
     DeleteUserMediaRequestInfo(request);
     StopUnreferencedSources(true);
   }
 }
 
 void MediaStreamImpl::OnDevicesEnumerated(
     int request_id,
     const StreamDeviceInfoArray& device_array) {
@@ skipping 13 matching lines @@
 
 void MediaStreamImpl::OnDeviceOpenFailed(int request_id) {
   DVLOG(1) << "MediaStreamImpl::VideoDeviceOpenFailed("
            << request_id << ")";
   NOTIMPLEMENTED();
 }
 
 void MediaStreamImpl::CompleteGetUserMediaRequest(
     const blink::WebMediaStream& stream,
     blink::WebUserMediaRequest* request_info,
-    bool request_succeeded) {
-  if (request_succeeded) {
-    request_info->requestSucceeded(stream);
-  } else {
-    request_info->requestFailed();
+    content::MediaStreamRequestResult result) {
+
+  DVLOG(1) << "MediaStreamImpl::CompleteGetUserMediaRequest("
+           << "result=" << result;
+
+  switch (result) {
+    case MEDIA_DEVICE_OK:
+      request_info->requestSucceeded(stream);
+      break;
+    case MEDIA_DEVICE_PERMISSION_DENIED:
+      request_info->requestDenied();
+      break;
+    case MEDIA_DEVICE_PERMISSION_DISMISSED:
+      request_info->requestFailedUASpecific("PermissionDismissedError");
+      break;
+    case MEDIA_DEVICE_INVALID_STATE:
+      request_info->requestFailedUASpecific("InvalidStateError");
+      break;
+    case MEDIA_DEVICE_NO_HARDWARE:
+      request_info->requestFailedUASpecific("DevicesNotFoundError");
+      break;
+    case MEDIA_DEVICE_INVALID_SECURITY_ORIGIN:
+      request_info->requestFailedUASpecific("InvalidSecurityOriginError");
+      break;
+    case MEDIA_DEVICE_TAB_CAPTURE_FAILURE:
+      request_info->requestFailedUASpecific("TabCaptureError");
+      break;
+    case MEDIA_DEVICE_SCREEN_CAPTURE_FAILURE:
+      request_info->requestFailedUASpecific("ScreenCaptureError");
+      break;
+    case MEDIA_DEVICE_CAPTURE_FAILURE:
+      request_info->requestFailedUASpecific("DeviceCaptureError");
+      break;
+    case MEDIA_DEVICE_TRACK_START_FAILURE:
+      request_info->requestFailedUASpecific("TrackStartError");
+      break;
+    default:
+      request_info->requestFailed();
+      break;
   }
 }
 
 const blink::WebMediaStreamSource* MediaStreamImpl::FindLocalSource(
     const StreamDeviceInfo& device) const {
   for (LocalStreamSources::const_iterator it = local_sources_.begin();
        it != local_sources_.end(); ++it) {
     MediaStreamSource* source =
         static_cast<MediaStreamSource*>(it->source.extraData());
     const StreamDeviceInfo& active_device = source->device_info();
@@ skipping 280 matching lines @@
   DCHECK(it != sources_waiting_for_callback_.end());
   sources_waiting_for_callback_.erase(it);
   // All tracks must be started successfully. Otherwise the request is a
   // failure.
   if (!success)
     request_failed_ = true;
   CheckAllTracksStarted();
 }
 
 void MediaStreamImpl::UserMediaRequestInfo::CheckAllTracksStarted() {
-  if (!ready_callback_.is_null() && sources_waiting_for_callback_.empty())
-    ready_callback_.Run(this, !request_failed_);
+  if (!ready_callback_.is_null() && sources_waiting_for_callback_.empty()) {
+    ready_callback_.Run(
+        this,
+        request_failed_ ? MEDIA_DEVICE_TRACK_START_FAILURE : MEDIA_DEVICE_OK);
+  }
 }
 
 bool MediaStreamImpl::UserMediaRequestInfo::IsSourceUsed(
     const blink::WebMediaStreamSource& source) const {
   for (std::vector<blink::WebMediaStreamSource>::const_iterator source_it =
            sources_.begin();
        source_it != sources_.end(); ++source_it) {
     if (source_it->id() == source.id())
       return true;
   }
   return false;
 }
 
 void MediaStreamImpl::UserMediaRequestInfo::RemoveSource(
     const blink::WebMediaStreamSource& source) {
   for (std::vector<blink::WebMediaStreamSource>::iterator it =
            sources_.begin();
        it != sources_.end(); ++it) {
     if (source.id() == it->id()) {
       sources_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace content