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);
+    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 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:

[miu, 2014/07/30 19:37:23]

It's generally not good practice to use "default" clauses when handling enum
values.  Please add handling for all values so that the compiler will force
someone to account for a new result value (if added in the future).

In addition, if there are cases that should not be reached, use NOTREACHED()
before the request_info->requestFailed() call, to ensure debug builds will crash
on a logic error.

[jiajia.qin, 2014/07/31 13:43:00]

Done.

[miu, 2014/07/31 19:30:09]

You should still call request_info->requestFailed() and break after the
NOTREACHED(), since non-debug binaries will pass by the NOTREACHED().

[jiajia.qin, 2014/08/01 05:25:33]

Done.

+      request_info->requestFailed();
+      break;
+  }
+}
+
+void MediaStreamImpl::GetUserMediaRequestFailed(

[miu, 2014/07/30 19:37:23]

IMHO, this shouldn't be a separate method.  Can you just add the new 3rd arg to
the existing one, and add these additional cases?

If you strongly disagree then, at the least, the name of this method should be
changed to indicate its specific meaning/difference from the other one. 
Something to make it more obvious when this method is supposed to handle a
failure versus the other.  Suggestion: StartUserMediaRequestFailed() or
CompleteUserMediaRequestFailed().

[jiajia.qin, 2014/07/31 13:43:00]

The new 3rd arg is only for 'TrackStartError'. For other errors, we don't need
to pass the 3rd arg. So I separate this method. I use
'GetUserMediaRequestTrackStartedFailed' to rename this new function. It seems
more meaningful.

+    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:
       request_info->requestFailed();
       break;
   }
 }
 
 void MediaStreamImpl::EnumerateDevicesSucceded(
@@ skipping 207 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)
+  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