Implement ConstraintNotSatisfiedError 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/hash.h"
 #include "base/logging.h"
@@ skipping 318 matching lines @@
   // Wait for the tracks to be started successfully or to fail.
   request_info->CallbackOnTracksStarted(
       base::Bind(&MediaStreamImpl::OnCreateNativeTracksCompleted,
                  weak_factory_.GetWeakPtr()));
 }
 
 // Callback from MediaStreamDispatcher.
 // The requested stream failed to be generated.
 void MediaStreamImpl::OnStreamGenerationFailed(
     int request_id,
-    content::MediaStreamRequestResult result) {
+    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;
   }
@@ skipping 137 matching lines @@
                            blink::WebMediaStreamSource::TypeAudio,
                            constraints,
                            &webkit_source);
     (*webkit_tracks)[i].initialize(webkit_source);
     request->StartAudioTrack((*webkit_tracks)[i], constraints);
   }
 }
 
 void MediaStreamImpl::OnCreateNativeTracksCompleted(
     UserMediaRequestInfo* request,
-    content::MediaStreamRequestResult result) {
+    MediaStreamRequestResult result,
+    const blink::WebString& result_name) {
   DVLOG(1) << "MediaStreamImpl::OnCreateNativeTracksComplete("
            << "{request_id = " << request->request_id << "} "
            << "{result = " << result << "})";
   if (result == content::MEDIA_DEVICE_OK)
     GetUserMediaRequestSucceeded(request->web_stream, &request->request);
   else
-    GetUserMediaRequestFailed(&request->request, result);
+    GetUserMediaRequestTrackStartedFailed(&request->request,
+                                          result,
+                                          result_name);
 
   DeleteUserMediaRequestInfo(request);
 }
 
 void MediaStreamImpl::OnDevicesEnumerated(
     int request_id,
     const StreamDeviceInfoArray& device_array) {
   DVLOG(1) << "MediaStreamImpl::OnDevicesEnumerated(" << request_id << ")";
 
   MediaDevicesRequestInfo* request = FindMediaDevicesRequestInfo(request_id);
@@ skipping 84 matching lines @@
 
 void MediaStreamImpl::GetUserMediaRequestSucceeded(
     const blink::WebMediaStream& stream,
     blink::WebUserMediaRequest* request_info) {
   DVLOG(1) << "MediaStreamImpl::GetUserMediaRequestSucceeded";
   request_info->requestSucceeded(stream);
 }
 
 void MediaStreamImpl::GetUserMediaRequestFailed(
     blink::WebUserMediaRequest* request_info,
-    content::MediaStreamRequestResult result) {
+    MediaStreamRequestResult result) {
   switch (result) {
     case MEDIA_DEVICE_OK:
       NOTREACHED();
       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;
+    default:
+      NOTREACHED();
+      request_info->requestFailed();
+      break;
+  }
+}
+
+void MediaStreamImpl::GetUserMediaRequestTrackStartedFailed(
+    blink::WebUserMediaRequest* request_info,
+    MediaStreamRequestResult result,
+    const blink::WebString& result_name) {
+  switch (result) {
+    case MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED:
+      request_info->requestFailedConstraint(result_name);
+      break;
     case MEDIA_DEVICE_TRACK_START_FAILURE:
       request_info->requestFailedUASpecific("TrackStartError");
       break;
     default:
+      NOTREACHED();
       request_info->requestFailed();
       break;
   }
 }
 
 void MediaStreamImpl::EnumerateDevicesSucceded(
     blink::WebMediaDevicesRequest* request,
     blink::WebVector<blink::WebMediaDeviceInfo>& devices) {
   request->requestSucceeded(devices);
 }
@@ skipping 155 matching lines @@
 
 MediaStreamImpl::UserMediaRequestInfo::UserMediaRequestInfo(
     int request_id,
     const blink::WebUserMediaRequest& request,
     bool enable_automatic_output_device_selection)
     : request_id(request_id),
       generated(false),
       enable_automatic_output_device_selection(
           enable_automatic_output_device_selection),
       request(request),
-      request_failed_(false) {
+      request_result_(MEDIA_DEVICE_OK),
+      request_result_name_("") {
 }
 
 MediaStreamImpl::UserMediaRequestInfo::~UserMediaRequestInfo() {
   DVLOG(1) << "~UserMediaRequestInfo";
 }
 
 void MediaStreamImpl::UserMediaRequestInfo::StartAudioTrack(
     const blink::WebMediaStreamTrack& track,
     const blink::WebMediaConstraints& constraints) {
   DCHECK(track.source().type() == blink::WebMediaStreamSource::TypeAudio);
@@ skipping 27 matching lines @@
 }
 
 void MediaStreamImpl::UserMediaRequestInfo::CallbackOnTracksStarted(
     const ResourcesReady& callback) {
   DCHECK(ready_callback_.is_null());
   ready_callback_ = callback;
   CheckAllTracksStarted();
 }
 
 void MediaStreamImpl::UserMediaRequestInfo::OnTrackStarted(
-    MediaStreamSource* source, bool success) {
-  DVLOG(1) << "OnTrackStarted result " << success;
+    MediaStreamSource* source,
+    MediaStreamRequestResult result,
+    const blink::WebString& result_name) {
+  DVLOG(1) << "OnTrackStarted result " << result;
   std::vector<MediaStreamSource*>::iterator it =
       std::find(sources_waiting_for_callback_.begin(),
                 sources_waiting_for_callback_.end(),
                 source);
   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;
+  if (result != MEDIA_DEVICE_OK) {
+    request_result_ = result;
+    request_result_name_ = result_name;
+  }
+
   CheckAllTracksStarted();
 }
 
 void MediaStreamImpl::UserMediaRequestInfo::CheckAllTracksStarted() {
   if (!ready_callback_.is_null() && sources_waiting_for_callback_.empty()) {
-    ready_callback_.Run(
-        this,
-        request_failed_ ? MEDIA_DEVICE_TRACK_START_FAILURE : MEDIA_DEVICE_OK);
+    ready_callback_.Run(this, request_result_, request_result_name_);
   }
 }
 
 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