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 479 matching lines @@
                            constraints,
                            request->frame,
                            &webkit_source);
     (*webkit_tracks)[i].initialize(webkit_source);
     request->StartAudioTrack((*webkit_tracks)[i], constraints);
   }
 }
 
 void MediaStreamImpl::OnCreateNativeTracksCompleted(
     UserMediaRequestInfo* request,
-    content::MediaStreamRequestResult result) {
+    content::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);
+    GetUserMediaRequestFailed(&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 96 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) {
+    content::MediaStreamRequestResult result,
+    const blink::WebString& result_name) {
   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;
+    case MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED:
+      request_info->requestFailedConstraint(result_name);
+      break;
     case MEDIA_DEVICE_TRACK_START_FAILURE:
       request_info->requestFailedUASpecific("TrackStartError");
       break;
+    case MEDIA_DEVICE_SOURCE_START_FAILURE:
+      request_info->requestFailedUASpecific("SourceStartError");
+      break;
     default:
       request_info->requestFailed();
       break;
   }
 }
 
 void MediaStreamImpl::EnumerateDevicesSucceded(
     blink::WebMediaDevicesRequest* request,
     blink::WebVector<blink::WebMediaDeviceInfo>& devices) {
   request->requestSucceeded(devices);
@@ skipping 213 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,
+    content::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)
+  if (result != MEDIA_DEVICE_OK)
     request_failed_ = true;
-  CheckAllTracksStarted();
+  if (!ready_callback_.is_null() && sources_waiting_for_callback_.empty()) {
+    ready_callback_.Run(this, result, result_name);
+  }
 }
 
 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);
+        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