Use ApplyConstraintsRequest instead of WebApplyConstraintsRequest

... in renderer/modules/mediastream.

WebApplyConstraintsRequest will be removed altogether in a follow up
CL.

BUG=704136
R=guidou@chromium.org, haraken@chromium.org

Change-Id: I06fc9a2ca93f2bcb924b2491676d3457e2dd1067
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1768778
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Cr-Commit-Position: refs/heads/master@{#690336}

third_party/blink/renderer/modules/mediastream/apply_constraints_processor.cc

@@ -23,14 +23,16 @@
 namespace blink {
 namespace {
 
-void RequestFailed(blink::WebApplyConstraintsRequest request,
+void RequestFailed(blink::ApplyConstraintsRequest* request,
                    const String& constraint,
                    const String& message) {
-  request.RequestFailed(constraint, message);
+  DCHECK(request);
+  request->RequestFailed(constraint, message);
 }
 
-void RequestSucceeded(blink::WebApplyConstraintsRequest request) {
-  request.RequestSucceeded();
+void RequestSucceeded(blink::ApplyConstraintsRequest* request) {
+  DCHECK(request);
+  request->RequestSucceeded();
 }
 
 }  // namespace
@@ -46,24 +48,24 @@ ApplyConstraintsProcessor::~ApplyConstraintsProcessor() {
 }
 
 void ApplyConstraintsProcessor::ProcessRequest(
-    const blink::WebApplyConstraintsRequest& request,
+    blink::ApplyConstraintsRequest* request,
     base::OnceClosure callback) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(!request_completed_cb_);
-  DCHECK(current_request_.IsNull());
-  DCHECK(!request.Track().IsNull());
-  if (request.Track().Source().IsNull()) {
+  DCHECK(!current_request_);
+  DCHECK(!request->Track().IsNull());
+  if (request->Track().Source().IsNull()) {
     CannotApplyConstraints(
         "Track has no source. ApplyConstraints not possible.");
     return;
   }
   request_completed_cb_ = std::move(callback);
   current_request_ = request;
-  if (current_request_.Track().Source().GetType() ==
+  if (current_request_->Track().Source().GetType() ==
       blink::WebMediaStreamSource::kTypeVideo) {
     ProcessVideoRequest();
   } else {
-    DCHECK_EQ(current_request_.Track().Source().GetType(),
+    DCHECK_EQ(current_request_->Track().Source().GetType(),
               blink::WebMediaStreamSource::kTypeAudio);
     ProcessAudioRequest();
   }
@@ -71,8 +73,8 @@ void ApplyConstraintsProcessor::ProcessRequest(
 
 void ApplyConstraintsProcessor::ProcessAudioRequest() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  DCHECK(!current_request_.IsNull());
-  DCHECK_EQ(current_request_.Track().Source().GetType(),
+  DCHECK(current_request_);
+  DCHECK_EQ(current_request_->Track().Source().GetType(),
             blink::WebMediaStreamSource::kTypeAudio);
   DCHECK(request_completed_cb_);
   blink::MediaStreamAudioSource* audio_source = GetCurrentAudioSource();
@@ -82,7 +84,7 @@ void ApplyConstraintsProcessor::ProcessAudioRequest() {
   }
 
   blink::AudioCaptureSettings settings =
-      SelectSettingsAudioCapture(audio_source, current_request_.Constraints());
+      SelectSettingsAudioCapture(audio_source, current_request_->Constraints());
   if (settings.HasValue()) {
     ApplyConstraintsSucceeded();
   } else {
@@ -92,8 +94,8 @@ void ApplyConstraintsProcessor::ProcessAudioRequest() {
 
 void ApplyConstraintsProcessor::ProcessVideoRequest() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  DCHECK(!current_request_.IsNull());
-  DCHECK_EQ(current_request_.Track().Source().GetType(),
+  DCHECK(current_request_);
+  DCHECK_EQ(current_request_->Track().Source().GetType(),
             blink::WebMediaStreamSource::kTypeVideo);
   DCHECK(request_completed_cb_);
   video_source_ = GetCurrentVideoSource();
@@ -232,15 +234,15 @@ void ApplyConstraintsProcessor::FinalizeVideoRequest() {
 blink::VideoCaptureSettings ApplyConstraintsProcessor::SelectVideoSettings(
     Vector<media::VideoCaptureFormat> formats) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  DCHECK(!current_request_.IsNull());
-  DCHECK_EQ(current_request_.Track().Source().GetType(),
+  DCHECK(current_request_);
+  DCHECK_EQ(current_request_->Track().Source().GetType(),
             blink::WebMediaStreamSource::kTypeVideo);
   DCHECK(request_completed_cb_);
   DCHECK_GT(formats.size(), 0U);
 
   blink::VideoInputDeviceCapabilities device_capabilities;
-  device_capabilities.device_id = current_request_.Track().Source().Id();
-  device_capabilities.group_id = current_request_.Track().Source().GroupId();
+  device_capabilities.device_id = current_request_->Track().Source().Id();
+  device_capabilities.group_id = current_request_->Track().Source().GroupId();
   device_capabilities.facing_mode =
       GetCurrentVideoSource() ? GetCurrentVideoSource()->device().video_facing
                               : media::MEDIA_VIDEO_FACING_NONE;
@@ -263,22 +265,24 @@ blink::VideoCaptureSettings ApplyConstraintsProcessor::SelectVideoSettings(
   GetCurrentVideoTrack()->GetSettings(settings);
 
   return SelectSettingsVideoDeviceCapture(
-      video_capabilities, current_request_.Constraints(), settings.width,
+      video_capabilities, current_request_->Constraints(), settings.width,
       settings.height, settings.frame_rate);
 }
 
 blink::MediaStreamAudioSource*
 ApplyConstraintsProcessor::GetCurrentAudioSource() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  DCHECK(!current_request_.Track().IsNull());
-  return blink::MediaStreamAudioSource::From(current_request_.Track().Source());
+  DCHECK(current_request_);
+  DCHECK(!current_request_->Track().IsNull());
+  return blink::MediaStreamAudioSource::From(
+      current_request_->Track().Source());
 }
 
 blink::MediaStreamVideoTrack*
 ApplyConstraintsProcessor::GetCurrentVideoTrack() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   blink::MediaStreamVideoTrack* track =
-      blink::MediaStreamVideoTrack::GetVideoTrack(current_request_.Track());
+      blink::MediaStreamVideoTrack::GetVideoTrack(current_request_->Track());
   DCHECK(track);
   return track;
 }
@@ -291,8 +295,8 @@ ApplyConstraintsProcessor::GetCurrentVideoSource() {
 
 bool ApplyConstraintsProcessor::AbortIfVideoRequestStateInvalid() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  DCHECK(!current_request_.IsNull());
-  DCHECK_EQ(current_request_.Track().Source().GetType(),
+  DCHECK(current_request_);
+  DCHECK_EQ(current_request_->Track().Source().GetType(),
             blink::WebMediaStreamSource::kTypeVideo);
   DCHECK(request_completed_cb_);
   if (GetCurrentVideoSource() != video_source_) {
@@ -306,18 +310,21 @@ bool ApplyConstraintsProcessor::AbortIfVideoRequestStateInvalid() {
 void ApplyConstraintsProcessor::ApplyConstraintsSucceeded() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   task_runner_->PostTask(
-      FROM_HERE, WTF::Bind(&ApplyConstraintsProcessor::CleanupRequest,
+      FROM_HERE,
+      WTF::Bind(&ApplyConstraintsProcessor::CleanupRequest,
                 WrapWeakPersistent(this),
-                           WTF::Bind(&RequestSucceeded, current_request_)));
+                WTF::Bind(&RequestSucceeded,
+                          WrapWeakPersistent(current_request_.Get()))));
 }
 
 void ApplyConstraintsProcessor::ApplyConstraintsFailed(
     const char* failed_constraint_name) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   task_runner_->PostTask(
-      FROM_HERE, WTF::Bind(&ApplyConstraintsProcessor::CleanupRequest,
-                           WrapWeakPersistent(this),
-                           WTF::Bind(&RequestFailed, current_request_,
+      FROM_HERE,
+      WTF::Bind(
+          &ApplyConstraintsProcessor::CleanupRequest, WrapWeakPersistent(this),
+          WTF::Bind(&RequestFailed, WrapWeakPersistent(current_request_.Get()),
                     String(failed_constraint_name),
                     String("Cannot satisfy constraints"))));
 }
@@ -328,17 +335,18 @@ void ApplyConstraintsProcessor::CannotApplyConstraints(const String& message) {
       FROM_HERE,
       WTF::Bind(
           &ApplyConstraintsProcessor::CleanupRequest, WrapWeakPersistent(this),
-          WTF::Bind(&RequestFailed, current_request_, String(), message)));
+          WTF::Bind(&RequestFailed, WrapWeakPersistent(current_request_.Get()),
+                    String(), message)));
 }
 
 void ApplyConstraintsProcessor::CleanupRequest(
     base::OnceClosure web_request_callback) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  DCHECK(!current_request_.IsNull());
+  DCHECK(current_request_);
   DCHECK(request_completed_cb_);
   std::move(request_completed_cb_).Run();
   std::move(web_request_callback).Run();
-  current_request_.Reset();
+  current_request_ = nullptr;
   video_source_ = nullptr;
 }
 

third_party/blink/renderer/modules/mediastream/apply_constraints_processor.h

@@ -13,7 +13,7 @@
 #include "third_party/blink/public/mojom/mediastream/media_devices.mojom-blink.h"
 #include "third_party/blink/public/web/modules/mediastream/media_stream_constraints_util.h"
 #include "third_party/blink/public/web/modules/mediastream/media_stream_video_source.h"
-#include "third_party/blink/public/web/web_apply_constraints_request.h"
+#include "third_party/blink/renderer/modules/mediastream/apply_constraints_request.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"
 #include "third_party/blink/renderer/platform/wtf/vector.h"
@@ -40,10 +40,10 @@ class MODULES_EXPORT ApplyConstraintsProcessor
   // it notifies by invoking |callback|.
   // This method must be called only if there is no request currently being
   // processed.
-  void ProcessRequest(const blink::WebApplyConstraintsRequest& request,
+  void ProcessRequest(blink::ApplyConstraintsRequest* request,
                       base::OnceClosure callback);
 
-  void Trace(Visitor*) {}
+  void Trace(Visitor* visitor) { visitor->Trace(current_request_); }
 
  private:
   // Helpers for video device-capture requests.
@@ -82,7 +82,7 @@ class MODULES_EXPORT ApplyConstraintsProcessor
   // contains the request currently being processed, if any.
   // |video_source_| and |request_completed_cb_| are the video source and
   // reply callback for the current request.
-  blink::WebApplyConstraintsRequest current_request_;
+  WeakMember<blink::ApplyConstraintsRequest> current_request_;
 
   // TODO(crbug.com/704136): Change to use Member.
   blink::MediaStreamVideoSource* video_source_ = nullptr;

third_party/blink/renderer/modules/mediastream/user_media_client.cc

@@ -52,14 +52,13 @@ void UpdateAPICount(blink::WebUserMediaRequest::MediaType media_type) {
 UserMediaClient::Request::Request(std::unique_ptr<UserMediaRequestInfo> request)
     : user_media_request_(std::move(request)) {
   DCHECK(user_media_request_);
-  DCHECK(apply_constraints_request_.IsNull());
+  DCHECK(!apply_constraints_request_);
   DCHECK(web_track_to_stop_.IsNull());
 }
 
-UserMediaClient::Request::Request(
-    const blink::WebApplyConstraintsRequest& request)
+UserMediaClient::Request::Request(blink::ApplyConstraintsRequest* request)
     : apply_constraints_request_(request) {
-  DCHECK(!apply_constraints_request_.IsNull());
+  DCHECK(apply_constraints_request_);
   DCHECK(!user_media_request_);
   DCHECK(web_track_to_stop_.IsNull());
 }
@@ -69,28 +68,9 @@ UserMediaClient::Request::Request(
     : web_track_to_stop_(web_track_to_stop) {
   DCHECK(!web_track_to_stop_.IsNull());
   DCHECK(!user_media_request_);
-  DCHECK(apply_constraints_request_.IsNull());
-}
-
-UserMediaClient::Request::Request(Request&& other)
-    : user_media_request_(std::move(other.user_media_request_)),
-      apply_constraints_request_(other.apply_constraints_request_),
-      web_track_to_stop_(other.web_track_to_stop_) {
-#if DCHECK_IS_ON()
-  int num_types = 0;
-  if (IsUserMedia())
-    num_types++;
-  if (IsApplyConstraints())
-    num_types++;
-  if (IsStopTrack())
-    num_types++;
-
-  DCHECK_EQ(num_types, 1);
-#endif
+  DCHECK(!apply_constraints_request_);
 }
 
-UserMediaClient::Request& UserMediaClient::Request::operator=(Request&& other) =
-    default;
 UserMediaClient::Request::~Request() = default;
 
 std::unique_ptr<UserMediaRequestInfo>
@@ -188,22 +168,22 @@ void UserMediaClient::RequestUserMedia(
       std::make_unique<UserMediaRequestInfo>(request_id, web_request,
                                              user_gesture);
   pending_request_infos_.push_back(
-      std::make_unique<Request>(std::move(request_info)));
+      MakeGarbageCollected<Request>(std::move(request_info)));
   if (!is_processing_request_)
     MaybeProcessNextRequestInfo();
 }
 
 void UserMediaClient::ApplyConstraints(
-    const blink::WebApplyConstraintsRequest& web_request) {
+    blink::ApplyConstraintsRequest* web_request) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
-  pending_request_infos_.push_back(std::make_unique<Request>(web_request));
+  pending_request_infos_.push_back(MakeGarbageCollected<Request>(web_request));
   if (!is_processing_request_)
     MaybeProcessNextRequestInfo();
 }
 
 void UserMediaClient::StopTrack(const blink::WebMediaStreamTrack& web_track) {
-  pending_request_infos_.push_back(std::make_unique<Request>(web_track));
+  pending_request_infos_.push_back(MakeGarbageCollected<Request>(web_track));
   if (!is_processing_request_)
     MaybeProcessNextRequestInfo();
 }
@@ -311,6 +291,7 @@ void UserMediaClient::Trace(Visitor* visitor) {
   visitor->Trace(frame_);
   visitor->Trace(user_media_processor_);
   visitor->Trace(apply_constraints_processor_);
+  visitor->Trace(pending_request_infos_);
 }
 
 void UserMediaClient::SetMediaDevicesDispatcherForTesting(

third_party/blink/renderer/modules/mediastream/user_media_client.h

@@ -12,9 +12,9 @@
 #include "base/threading/thread_checker.h"
 #include "third_party/blink/public/common/mediastream/media_devices.h"
 #include "third_party/blink/public/mojom/mediastream/media_devices.mojom-blink.h"
-#include "third_party/blink/public/web/web_apply_constraints_request.h"
 #include "third_party/blink/public/web/web_user_media_request.h"
 #include "third_party/blink/renderer/core/execution_context/context_lifecycle_observer.h"
+#include "third_party/blink/renderer/modules/mediastream/apply_constraints_request.h"
 #include "third_party/blink/renderer/modules/mediastream/user_media_processor.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
 #include "third_party/blink/renderer/platform/wtf/deque.h"
@@ -47,7 +47,7 @@ class MODULES_EXPORT UserMediaClient
 
   void RequestUserMedia(const blink::WebUserMediaRequest& web_request);
   void CancelUserMediaRequest(const blink::WebUserMediaRequest& web_request);
-  void ApplyConstraints(const blink::WebApplyConstraintsRequest& web_request);
+  void ApplyConstraints(blink::ApplyConstraintsRequest* web_request);
   void StopTrack(const blink::WebMediaStreamTrack& web_track);
   void ContextDestroyed();
 
@@ -60,13 +60,11 @@ class MODULES_EXPORT UserMediaClient
           media_devices_dispatcher);
 
  private:
-  class Request {
+  class Request : public GarbageCollectedFinalized<Request> {
    public:
     explicit Request(std::unique_ptr<UserMediaRequestInfo> request);
-    explicit Request(const blink::WebApplyConstraintsRequest& request);
+    explicit Request(blink::ApplyConstraintsRequest* request);
     explicit Request(const blink::WebMediaStreamTrack& request);
-    Request(Request&& other);
-    Request& operator=(Request&& other);
     ~Request();
 
     std::unique_ptr<UserMediaRequestInfo> MoveUserMediaRequest();
@@ -74,7 +72,7 @@ class MODULES_EXPORT UserMediaClient
     UserMediaRequestInfo* user_media_request() const {
       return user_media_request_.get();
     }
-    const blink::WebApplyConstraintsRequest& apply_constraints_request() const {
+    blink::ApplyConstraintsRequest* apply_constraints_request() const {
       return apply_constraints_request_;
     }
     const blink::WebMediaStreamTrack& web_track_to_stop() const {
@@ -82,14 +80,14 @@ class MODULES_EXPORT UserMediaClient
     }
 
     bool IsUserMedia() const { return !!user_media_request_; }
-    bool IsApplyConstraints() const {
-      return !apply_constraints_request_.IsNull();
-    }
+    bool IsApplyConstraints() const { return apply_constraints_request_; }
     bool IsStopTrack() const { return !web_track_to_stop_.IsNull(); }
 
+    void Trace(Visitor* visitor) { visitor->Trace(apply_constraints_request_); }
+
    private:
     std::unique_ptr<UserMediaRequestInfo> user_media_request_;
-    blink::WebApplyConstraintsRequest apply_constraints_request_;
+    Member<blink::ApplyConstraintsRequest> apply_constraints_request_;
     blink::WebMediaStreamTrack web_track_to_stop_;
 
     DISALLOW_COPY_AND_ASSIGN(Request);
@@ -121,7 +119,7 @@ class MODULES_EXPORT UserMediaClient
   // and |pending_request_infos_| is a list of queued requests.
   bool is_processing_request_ = false;
 
-  Deque<std::unique_ptr<Request>> pending_request_infos_;
+  HeapDeque<Member<Request>> pending_request_infos_;
 
   THREAD_CHECKER(thread_checker_);
 

third_party/blink/renderer/modules/mediastream/user_media_client_test.cc

@@ -634,8 +634,8 @@ class UserMediaClientTest : public ::testing::Test {
     if (frame_rate)
       factory.basic().frame_rate.SetExact(*frame_rate);
 
-    blink::WebApplyConstraintsRequest apply_constraints_request =
-        blink::WebApplyConstraintsRequest::CreateForTesting(
+    auto* apply_constraints_request =
+        blink::ApplyConstraintsRequest::CreateForTesting(
             web_track, factory.CreateWebMediaConstraints());
     user_media_client_impl_->ApplyConstraints(apply_constraints_request);
     base::RunLoop().RunUntilIdle();

third_party/blink/renderer/modules/mediastream/user_media_controller.h

@@ -81,7 +81,7 @@ inline void UserMediaController::CancelUserMediaRequest(
 
 inline void UserMediaController::ApplyConstraints(
     ApplyConstraintsRequest* request) {
-  Client()->ApplyConstraints(WebApplyConstraintsRequest(request));
+  Client()->ApplyConstraints(request);
 }
 
 inline void UserMediaController::StopTrack(MediaStreamComponent* track) {