Delay completion of getUserMedia in UserMediaClient

content/renderer/media/user_media_client_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/user_media_client_impl.h"
 
 #include <utility>
 
 #include "base/hash.h"
 #include "base/logging.h"
@@ skipping 481 matching lines @@
   DVLOG(1) << "UserMediaClientImpl::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;
   }
 
-  GetUserMediaRequestFailed(&request_info->request, result, "");
+  GetUserMediaRequestFailed(request_info->request, result, "");
   DeleteUserMediaRequestInfo(request_info);
 }
 
 // Callback from MediaStreamDispatcher.
 // The browser process has stopped a device used by a MediaStream.
 void UserMediaClientImpl::OnDeviceStopped(
     const std::string& label,
     const StreamDeviceInfo& device_info) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "UserMediaClientImpl::OnDeviceStopped("
@@ skipping 134 matching lines @@
 }
 
 void UserMediaClientImpl::OnCreateNativeTracksCompleted(
     UserMediaRequestInfo* request,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   DVLOG(1) << "UserMediaClientImpl::OnCreateNativeTracksComplete("
            << "{request_id = " << request->request_id << "} "
            << "{result = " << result << "})";
 
-  // Completing the request can lead to that blink call
-  // cancelUserMediaRequest with the blink request and the UserMediaClientImpl
-  // is destroyed. Therefore, we copy (blink objects are smart pointers) the
-  // following objects and delete |request| before completing the blink request.
-  blink::WebMediaStream stream = request->web_stream;
-  blink::WebUserMediaRequest blink_request = request->request;
-  blink::WebString result_name_copy = result_name;
+  if (result == content::MEDIA_DEVICE_OK)
+    GetUserMediaRequestSucceeded(request->web_stream, request->request);
+  else
+    GetUserMediaRequestFailed(request->request, result, result_name);
+
   DeleteUserMediaRequestInfo(request);
-
-  if (result == content::MEDIA_DEVICE_OK)
-    GetUserMediaRequestSucceeded(stream, &blink_request);
-  else
-    GetUserMediaRequestFailed(&blink_request, result, result_name_copy);
 }
 
 void UserMediaClientImpl::OnDevicesEnumerated(
     int request_id,
     const StreamDeviceInfoArray& device_array) {
   DVLOG(1) << "UserMediaClientImpl::OnDevicesEnumerated(" << request_id << ")";
 
   MediaDevicesRequestInfo* request = FindMediaDevicesRequestInfo(request_id);
   DCHECK(request);
 
@@ skipping 37 matching lines @@
 }
 
 void UserMediaClientImpl::OnDeviceOpenFailed(int request_id) {
   DVLOG(1) << "UserMediaClientImpl::VideoDeviceOpenFailed("
            << request_id << ")";
   NOTIMPLEMENTED();
 }
 
 void UserMediaClientImpl::GetUserMediaRequestSucceeded(
     const blink::WebMediaStream& stream,
-    blink::WebUserMediaRequest* request_info) {
-  DVLOG(1) << "UserMediaClientImpl::GetUserMediaRequestSucceeded";
+    blink::WebUserMediaRequest request_info) {
+  // Completing the getUserMedia request can lead to that the RenderFrame and
+  // the UserMediaClientImpl is destroyed if the JavaScript code request the
+  // frame to be destroyed within the scope of the callback. Therefore,
+  // post a task to complete the request with a clean stack.
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&UserMediaClientImpl::DelayedGetUserMediaRequestSucceeded,
+                 weak_factory_.GetWeakPtr(), stream, request_info));
+}
+
+void UserMediaClientImpl::DelayedGetUserMediaRequestSucceeded(
+    const blink::WebMediaStream& stream,
+    blink::WebUserMediaRequest request_info) {
+  DVLOG(1) << "UserMediaClientImpl::DelayedGetUserMediaRequestSucceeded";
   LogUserMediaRequestResult(MEDIA_DEVICE_OK);
-  request_info->requestSucceeded(stream);
+  request_info.requestSucceeded(stream);
 }
 
 void UserMediaClientImpl::GetUserMediaRequestFailed(
-    blink::WebUserMediaRequest* request_info,
+    blink::WebUserMediaRequest request_info,
+    MediaStreamRequestResult result,
+    const blink::WebString& result_name) {
+  // Completing the getUserMedia request can lead to that the RenderFrame and
+  // the UserMediaClientImpl is destroyed if the JavaScript code request the
+  // frame to be destroyed within the scope of the callback. Therefore,
+  // post a task to complete the request with a clean stack.
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&UserMediaClientImpl::DelayedGetUserMediaRequestFailed,
+                 weak_factory_.GetWeakPtr(), request_info, result,
+                 result_name));
+}
+
+void UserMediaClientImpl::DelayedGetUserMediaRequestFailed(
+    blink::WebUserMediaRequest request_info,
     MediaStreamRequestResult result,
     const blink::WebString& result_name) {
   LogUserMediaRequestResult(result);
   switch (result) {
     case MEDIA_DEVICE_OK:
     case NUM_MEDIA_REQUEST_RESULTS:
       NOTREACHED();
       return;
     case MEDIA_DEVICE_PERMISSION_DENIED:
-      request_info->requestDenied();
+      request_info.requestDenied();
       return;
     case MEDIA_DEVICE_PERMISSION_DISMISSED:
-      request_info->requestFailedUASpecific("PermissionDismissedError");
+      request_info.requestFailedUASpecific("PermissionDismissedError");
       return;
     case MEDIA_DEVICE_INVALID_STATE:
-      request_info->requestFailedUASpecific("InvalidStateError");
+      request_info.requestFailedUASpecific("InvalidStateError");
       return;
     case MEDIA_DEVICE_NO_HARDWARE:
-      request_info->requestFailedUASpecific("DevicesNotFoundError");
+      request_info.requestFailedUASpecific("DevicesNotFoundError");
       return;
     case MEDIA_DEVICE_INVALID_SECURITY_ORIGIN:
-      request_info->requestFailedUASpecific("InvalidSecurityOriginError");
+      request_info.requestFailedUASpecific("InvalidSecurityOriginError");
       return;
     case MEDIA_DEVICE_TAB_CAPTURE_FAILURE:
-      request_info->requestFailedUASpecific("TabCaptureError");
+      request_info.requestFailedUASpecific("TabCaptureError");
       return;
     case MEDIA_DEVICE_SCREEN_CAPTURE_FAILURE:
-      request_info->requestFailedUASpecific("ScreenCaptureError");
+      request_info.requestFailedUASpecific("ScreenCaptureError");
       return;
     case MEDIA_DEVICE_CAPTURE_FAILURE:
-      request_info->requestFailedUASpecific("DeviceCaptureError");
+      request_info.requestFailedUASpecific("DeviceCaptureError");
       return;
     case MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED:
-      request_info->requestFailedConstraint(result_name);
+      request_info.requestFailedConstraint(result_name);
       return;
     case MEDIA_DEVICE_TRACK_START_FAILURE:
-      request_info->requestFailedUASpecific("TrackStartError");
+      request_info.requestFailedUASpecific("TrackStartError");
       return;
     case MEDIA_DEVICE_NOT_SUPPORTED:
-      request_info->requestFailedUASpecific("MediaDeviceNotSupported");
+      request_info.requestFailedUASpecific("MediaDeviceNotSupported");
       return;
     case MEDIA_DEVICE_FAILED_DUE_TO_SHUTDOWN:
-      request_info->requestFailedUASpecific("MediaDeviceFailedDueToShutdown");
+      request_info.requestFailedUASpecific("MediaDeviceFailedDueToShutdown");
       return;
   }
   NOTREACHED();
-  request_info->requestFailed();
+  request_info.requestFailed();
 }
 
 void UserMediaClientImpl::EnumerateDevicesSucceded(
     blink::WebMediaDevicesRequest* request,
     blink::WebVector<blink::WebMediaDeviceInfo>& devices) {
   request->requestSucceeded(devices);
 }
 
 void UserMediaClientImpl::EnumerateSourcesSucceded(
     blink::WebMediaStreamTrackSourcesRequest* request,
@@ skipping 272 matching lines @@
       return;
     }
   }
 }
 
 bool UserMediaClientImpl::UserMediaRequestInfo::HasPendingSources() const {
   return !sources_waiting_for_callback_.empty();
 }
 
 }  // namespace content