Run constraints processing for video-device capture on the main thread

The constraints processing algorithm operates on data coming directly
from Blink, and it may happen that a future change accesses a
string or some other data that is allowed to be accessed only from
the main thread. So far no such bug has been found for device capture,
but one was recently discovered for screen capture. See
http://crbug.com/791992.

The original motivation to run constraints processing on the worker
thread was to avoid blocking the main thread in case the algorithm
took too long to run, but in practice we have not observed
significant performance issues.

Bug: 792106
Change-Id: I5fa6f9e1b107e680cb4a5b544488fe7f2d8bfb0d
Reviewed-on: https://chromium-review.googlesource.com/809011Reviewed-by: Henrik Boström <hbos@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Commit-Queue: Guido Urdaneta <guidou@chromium.org>
Cr-Commit-Position: refs/heads/master@{#521790}

content/renderer/media/user_media_client_impl.cc

@@ -117,8 +117,7 @@ UserMediaClientImpl::UserMediaClientImpl(
 UserMediaClientImpl::UserMediaClientImpl(
     RenderFrame* render_frame,
     PeerConnectionDependencyFactory* dependency_factory,
-    std::unique_ptr<MediaStreamDeviceObserver> media_stream_device_observer,
-    const scoped_refptr<base::TaskRunner>& worker_task_runner)
+    std::unique_ptr<MediaStreamDeviceObserver> media_stream_device_observer)
     : UserMediaClientImpl(
           render_frame,
           std::make_unique<UserMediaProcessor>(
@@ -127,8 +126,7 @@ UserMediaClientImpl::UserMediaClientImpl(
               std::move(media_stream_device_observer),
               base::BindRepeating(
                   &UserMediaClientImpl::GetMediaDevicesDispatcher,
-                  base::Unretained(this)),
-              worker_task_runner)) {}
+                  base::Unretained(this)))) {}
 
 UserMediaClientImpl::~UserMediaClientImpl() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

content/renderer/media/user_media_client_impl.h

@@ -26,10 +26,6 @@
 #include "third_party/WebKit/public/web/WebUserMediaClient.h"
 #include "third_party/WebKit/public/web/WebUserMediaRequest.h"
 
-namespace base {
-class TaskRunner;
-}
-
 namespace content {
 
 class ApplyConstraintsProcessor;
@@ -49,8 +45,7 @@ class CONTENT_EXPORT UserMediaClientImpl : public RenderFrameObserver,
   UserMediaClientImpl(
       RenderFrame* render_frame,
       PeerConnectionDependencyFactory* dependency_factory,
-      std::unique_ptr<MediaStreamDeviceObserver> media_stream_device_observer,
-      const scoped_refptr<base::TaskRunner>& worker_task_runner);
+      std::unique_ptr<MediaStreamDeviceObserver> media_stream_device_observer);
   UserMediaClientImpl(RenderFrame* render_frame,
                       std::unique_ptr<UserMediaProcessor> user_media_processor);
   ~UserMediaClientImpl() override;

content/renderer/media/user_media_client_impl_unittest.cc

@@ -298,8 +298,7 @@ class UserMediaProcessorUnderTest : public UserMediaProcessor {
             std::move(media_stream_device_observer),
             base::BindRepeating(
                 &UserMediaProcessorUnderTest::media_devices_dispatcher,
-                base::Unretained(this)),
-            base::ThreadTaskRunnerHandle::Get()),
+                base::Unretained(this))),
         factory_(dependency_factory),
         media_devices_dispatcher_(std::move(media_devices_dispatcher)),
         state_(state) {}

content/renderer/media/user_media_processor.cc

@@ -324,12 +324,10 @@ UserMediaProcessor::UserMediaProcessor(
     RenderFrame* render_frame,
     PeerConnectionDependencyFactory* dependency_factory,
     std::unique_ptr<MediaStreamDeviceObserver> media_stream_device_observer,
-    MediaDevicesDispatcherCallback media_devices_dispatcher_cb,
-    const scoped_refptr<base::TaskRunner>& worker_task_runner)
+    MediaDevicesDispatcherCallback media_devices_dispatcher_cb)
     : dependency_factory_(dependency_factory),
       media_stream_device_observer_(std::move(media_stream_device_observer)),
       media_devices_dispatcher_cb_(std::move(media_devices_dispatcher_cb)),
-      worker_task_runner_(worker_task_runner),
       render_frame_id_(render_frame ? render_frame->GetRoutingID()
                                     : MSG_ROUTING_NONE),
       weak_factory_(this) {
@@ -486,24 +484,11 @@ void UserMediaProcessor::SelectVideoDeviceSettings(
   capabilities.noise_reduction_capabilities = {base::Optional<bool>(),
                                                base::Optional<bool>(true),
                                                base::Optional<bool>(false)};
-  base::PostTaskAndReplyWithResult(
-      worker_task_runner_.get(), FROM_HERE,
-      base::Bind(&SelectSettingsVideoDeviceCapture, std::move(capabilities),
-                 web_request.VideoConstraints(),
+  VideoCaptureSettings settings = SelectSettingsVideoDeviceCapture(
+      std::move(capabilities), web_request.VideoConstraints(),
       MediaStreamVideoSource::kDefaultWidth,
       MediaStreamVideoSource::kDefaultHeight,
-                 MediaStreamVideoSource::kDefaultFrameRate),
-      base::Bind(&UserMediaProcessor::FinalizeSelectVideoDeviceSettings,
-                 weak_factory_.GetWeakPtr(), web_request));
-}
-
-void UserMediaProcessor::FinalizeSelectVideoDeviceSettings(
-    const blink::WebUserMediaRequest& web_request,
-    const VideoCaptureSettings& settings) {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  if (!IsCurrentRequestInfo(web_request))
-    return;
-
+      MediaStreamVideoSource::kDefaultFrameRate);
   if (!settings.HasValue()) {
     blink::WebString failed_constraint_name =
         blink::WebString::FromASCII(settings.failed_constraint_name());

content/renderer/media/user_media_processor.h

@@ -23,10 +23,6 @@
 #include "third_party/WebKit/public/platform/modules/mediastream/media_devices.mojom.h"
 #include "third_party/WebKit/public/web/WebUserMediaRequest.h"
 
-namespace base {
-class TaskRunner;
-}
-
 namespace blink {
 class WebMediaConstraints;
 class WebMediaStream;
@@ -72,8 +68,7 @@ class CONTENT_EXPORT UserMediaProcessor
       RenderFrame* render_frame,
       PeerConnectionDependencyFactory* dependency_factory,
       std::unique_ptr<MediaStreamDeviceObserver> media_stream_device_observer,
-      MediaDevicesDispatcherCallback media_devices_dispatcher_cb,
-      const scoped_refptr<base::TaskRunner>& worker_task_runner);
+      MediaDevicesDispatcherCallback media_devices_dispatcher_cb);
   ~UserMediaProcessor() override;
 
   // It can be assumed that the output of CurrentRequest() remains the same
@@ -289,8 +284,6 @@ class CONTENT_EXPORT UserMediaProcessor
   MediaDevicesDispatcherCallback media_devices_dispatcher_cb_;
   base::OnceClosure request_completed_cb_;
 
-  const scoped_refptr<base::TaskRunner> worker_task_runner_;
-
   const int render_frame_id_;
 
   SEQUENCE_CHECKER(sequence_checker_);

content/renderer/render_frame_impl.cc

@@ -6691,8 +6691,7 @@ void RenderFrameImpl::InitializeUserMediaClient() {
   DCHECK(!web_user_media_client_);
   web_user_media_client_ = new UserMediaClientImpl(
       this, RenderThreadImpl::current()->GetPeerConnectionDependencyFactory(),
-      std::make_unique<MediaStreamDeviceObserver>(this),
-      render_thread->GetWorkerTaskRunner());
+      std::make_unique<MediaStreamDeviceObserver>(this));
   registry_.AddInterface(
       base::Bind(&MediaDevicesListenerImpl::Create, GetRoutingID()));
 #endif