[PTZ] Move pan_tilt_zoom_allowed to video track creation part

This CL moves pan_tilt_zoom_allowed from MediaStream to MediaStreamTrack
for consistency with existing pan, tilt, zoom MediaStreamTrack values.

Bug: 934063
Change-Id: Iaa107290100393c51d7309e140adacd24c9e5dfd
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2270301
Commit-Queue: François Beaufort <beaufort.francois@gmail.com>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Cr-Commit-Position: refs/heads/master@{#783031}

third_party/blink/public/web/modules/mediastream/media_stream_video_track.h

@@ -53,6 +53,7 @@ class BLINK_MODULES_EXPORT MediaStreamVideoTrack
       const base::Optional<double>& pan,
       const base::Optional<double>& tilt,
       const base::Optional<double>& zoom,
+      bool pan_tilt_zoom_allowed,
       MediaStreamVideoSource::ConstraintsOnceCallback callback,
       bool enabled);
 
@@ -73,6 +74,7 @@ class BLINK_MODULES_EXPORT MediaStreamVideoTrack
       const base::Optional<double>& pan,
       const base::Optional<double>& tilt,
       const base::Optional<double>& zoom,
+      bool pan_tilt_zoom_allowed,
       MediaStreamVideoSource::ConstraintsOnceCallback callback,
       bool enabled);
   ~MediaStreamVideoTrack() override;
@@ -122,6 +124,7 @@ class BLINK_MODULES_EXPORT MediaStreamVideoTrack
   const base::Optional<double>& pan() const { return pan_; }
   const base::Optional<double>& tilt() const { return tilt_; }
   const base::Optional<double>& zoom() const { return zoom_; }
+  bool pan_tilt_zoom_allowed() const { return pan_tilt_zoom_allowed_; }
 
   // Setting information about the track size.
   // Called from MediaStreamVideoSource at track initialization.
@@ -187,6 +190,7 @@ class BLINK_MODULES_EXPORT MediaStreamVideoTrack
   base::Optional<double> pan_;
   base::Optional<double> tilt_;
   base::Optional<double> zoom_;
+  bool pan_tilt_zoom_allowed_;
 
   // Weak ref to the source this tracks is connected to.
   base::WeakPtr<MediaStreamVideoSource> source_;

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

@@ -92,15 +92,7 @@ MediaStream* MediaStream::Create(ExecutionContext* context,
 
 MediaStream* MediaStream::Create(ExecutionContext* context,
                                  MediaStreamDescriptor* stream_descriptor) {
-  return MakeGarbageCollected<MediaStream>(context, stream_descriptor,
-                                           /*pan_tilt_zoom_allowed=*/false);
-}
-
-MediaStream* MediaStream::Create(ExecutionContext* context,
-                                 MediaStreamDescriptor* stream_descriptor,
-                                 bool pan_tilt_zoom_allowed) {
-  return MakeGarbageCollected<MediaStream>(context, stream_descriptor,
-                                           pan_tilt_zoom_allowed);
+  return MakeGarbageCollected<MediaStream>(context, stream_descriptor);
 }
 
 MediaStream* MediaStream::Create(ExecutionContext* context,
@@ -112,8 +104,7 @@ MediaStream* MediaStream::Create(ExecutionContext* context,
 }
 
 MediaStream::MediaStream(ExecutionContext* context,
-                         MediaStreamDescriptor* stream_descriptor,
-                         bool pan_tilt_zoom_allowed)
+                         MediaStreamDescriptor* stream_descriptor)
     : ExecutionContextClient(context),
       descriptor_(stream_descriptor),
       scheduled_event_timer_(
@@ -135,7 +126,7 @@ MediaStream::MediaStream(ExecutionContext* context,
   video_tracks_.ReserveCapacity(number_of_video_tracks);
   for (uint32_t i = 0; i < number_of_video_tracks; i++) {
     auto* new_track = MakeGarbageCollected<MediaStreamTrack>(
-        context, descriptor_->VideoComponent(i), pan_tilt_zoom_allowed);
+        context, descriptor_->VideoComponent(i));
     new_track->RegisterMediaStream(this);
     video_tracks_.push_back(new_track);
   }

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

@@ -67,9 +67,6 @@ class MODULES_EXPORT MediaStream final
   // Creates a MediaStream matching the MediaStreamDescriptor. MediaStreamTracks
   // are created for any MediaStreamComponents attached to the descriptor.
   static MediaStream* Create(ExecutionContext*, MediaStreamDescriptor*);
-  static MediaStream* Create(ExecutionContext*,
-                             MediaStreamDescriptor*,
-                             bool pan_tilt_zoom_allowed);
   // Creates a MediaStream with the specified MediaStreamDescriptor and
   // MediaStreamTracks. The tracks must match the MediaStreamComponents attached
   // to the descriptor (or else a DCHECK fails). This allows you to create
@@ -84,9 +81,7 @@ class MODULES_EXPORT MediaStream final
                              const MediaStreamTrackVector& audio_tracks,
                              const MediaStreamTrackVector& video_tracks);
 
-  MediaStream(ExecutionContext*,
-              MediaStreamDescriptor*,
-              bool pan_tilt_zoom_allowed);
+  MediaStream(ExecutionContext*, MediaStreamDescriptor*);
   MediaStream(ExecutionContext*,
               MediaStreamDescriptor*,
               const MediaStreamTrackVector& audio_tracks,

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

@@ -187,6 +187,7 @@ void CloneNativeVideoMediaStreamTrack(MediaStreamComponent* original,
       original_track->noise_reduction(), original_track->is_screencast(),
       original_track->min_frame_rate(), original_track->pan(),
       original_track->tilt(), original_track->zoom(),
+      original_track->pan_tilt_zoom_allowed(),
       MediaStreamVideoSource::ConstraintsOnceCallback(), clone->Enabled()));
 }
 
@@ -220,21 +221,11 @@ MediaStreamTrack::MediaStreamTrack(ExecutionContext* context,
                                    MediaStreamComponent* component)
     : MediaStreamTrack(context,
                        component,
-                       component->Source()->GetReadyState(),
-                       /*pan_tilt_zoom_allowed=*/false) {}
+                       component->Source()->GetReadyState()) {}
 
 MediaStreamTrack::MediaStreamTrack(ExecutionContext* context,
                                    MediaStreamComponent* component,
-                                   bool pan_tilt_zoom_allowed)
-    : MediaStreamTrack(context,
-                       component,
-                       component->Source()->GetReadyState(),
-                       pan_tilt_zoom_allowed) {}
-
-MediaStreamTrack::MediaStreamTrack(ExecutionContext* context,
-                                   MediaStreamComponent* component,
-                                   MediaStreamSource::ReadyState ready_state,
-                                   bool pan_tilt_zoom_allowed)
+                                   MediaStreamSource::ReadyState ready_state)
     : ready_state_(ready_state),
       component_(component),
       execution_context_(context) {
@@ -245,8 +236,13 @@ MediaStreamTrack::MediaStreamTrack(ExecutionContext* context,
   // been called. Update the muted state manually.
   component_->SetMuted(ready_state_ == MediaStreamSource::kReadyStateMuted);
 
-  if (component_->Source() &&
+  MediaStreamVideoTrack* const video_track =
+      MediaStreamVideoTrack::GetVideoTrack(Component());
+  if (video_track && component_->Source() &&
       component_->Source()->GetType() == MediaStreamSource::kTypeVideo) {
+    bool pan_tilt_zoom_allowed =
+        image_capture_ ? image_capture_->HasPanTiltZoomPermissionGranted()
+                       : video_track->pan_tilt_zoom_allowed();
     image_capture_ = MakeGarbageCollected<ImageCapture>(context, this,
                                                         pan_tilt_zoom_allowed);
   }
@@ -403,12 +399,8 @@ void MediaStreamTrack::stopTrack(ExecutionContext* execution_context) {
 
 MediaStreamTrack* MediaStreamTrack::clone(ScriptState* script_state) {
   MediaStreamComponent* cloned_component = Component()->Clone();
-  bool pan_tilt_zoom_allowed =
-      image_capture_ ? image_capture_->HasPanTiltZoomPermissionGranted()
-                     : false;
   MediaStreamTrack* cloned_track = MakeGarbageCollected<MediaStreamTrack>(
-      ExecutionContext::From(script_state), cloned_component, ready_state_,
-      pan_tilt_zoom_allowed);
+      ExecutionContext::From(script_state), cloned_component, ready_state_);
   DidCloneMediaStreamTrack(Component(), cloned_component);
   return cloned_track;
 }

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

@@ -57,11 +57,7 @@ class MODULES_EXPORT MediaStreamTrack
   MediaStreamTrack(ExecutionContext*, MediaStreamComponent*);
   MediaStreamTrack(ExecutionContext*,
                    MediaStreamComponent*,
-                   bool pan_tilt_zoom_allowed);
-  MediaStreamTrack(ExecutionContext*,
-                   MediaStreamComponent*,
-                   MediaStreamSource::ReadyState,
-                   bool pan_tilt_zoom_allowed);
+                   MediaStreamSource::ReadyState);
   ~MediaStreamTrack() override;
 
   String kind() const;

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

@@ -143,7 +143,7 @@ class MediaStreamVideoCapturerSourceTest : public testing::Test {
     // CreateVideoTrack will trigger OnConstraintsApplied.
     return MediaStreamVideoTrack::CreateVideoTrack(
         source_, adapter_settings, noise_reduction, is_screencast,
-        min_frame_rate, base::nullopt, base::nullopt, base::nullopt,
+        min_frame_rate, base::nullopt, base::nullopt, base::nullopt, false,
         WTF::Bind(&MediaStreamVideoCapturerSourceTest::OnConstraintsApplied,
                   base::Unretained(this)),
         enabled);

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

@@ -92,7 +92,7 @@ class MediaStreamVideoSourceTest : public testing::Test {
     bool enabled = true;
     return MediaStreamVideoTrack::CreateVideoTrack(
         mock_source_, adapter_settings, noise_reduction, is_screencast,
-        min_frame_rate, base::nullopt, base::nullopt, base::nullopt,
+        min_frame_rate, base::nullopt, base::nullopt, base::nullopt, false,
         WTF::Bind(&MediaStreamVideoSourceTest::OnConstraintsApplied,
                   base::Unretained(this)),
         enabled);

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

@@ -354,13 +354,14 @@ WebMediaStreamTrack MediaStreamVideoTrack::CreateVideoTrack(
     const base::Optional<double>& pan,
     const base::Optional<double>& tilt,
     const base::Optional<double>& zoom,
+    bool pan_tilt_zoom_allowed,
     MediaStreamVideoSource::ConstraintsOnceCallback callback,
     bool enabled) {
   WebMediaStreamTrack track;
   track.Initialize(source->Owner());
   track.SetPlatformTrack(std::make_unique<MediaStreamVideoTrack>(
       source, adapter_settings, noise_reduction, is_screencast, min_frame_rate,
-      pan, tilt, zoom, std::move(callback), enabled));
+      pan, tilt, zoom, pan_tilt_zoom_allowed, std::move(callback), enabled));
   return track;
 }
 
@@ -412,6 +413,7 @@ MediaStreamVideoTrack::MediaStreamVideoTrack(
     const base::Optional<double>& pan,
     const base::Optional<double>& tilt,
     const base::Optional<double>& zoom,
+    bool pan_tilt_zoom_allowed,
     MediaStreamVideoSource::ConstraintsOnceCallback callback,
     bool enabled)
     : WebPlatformMediaStreamTrack(true),
@@ -423,6 +425,7 @@ MediaStreamVideoTrack::MediaStreamVideoTrack(
       pan_(pan),
       tilt_(tilt),
       zoom_(zoom),
+      pan_tilt_zoom_allowed_(pan_tilt_zoom_allowed),
       source_(source->GetWeakPtr()) {
   frame_deliverer_ =
       base::MakeRefCounted<MediaStreamVideoTrack::FrameDeliverer>(

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

@@ -122,7 +122,7 @@ class MediaStreamVideoTrackTest
     const bool enabled = true;
     WebMediaStreamTrack track = MediaStreamVideoTrack::CreateVideoTrack(
         mock_source_, adapter_settings, base::Optional<bool>(), false, 0.0,
-        base::nullopt, base::nullopt, base::nullopt,
+        base::nullopt, base::nullopt, base::nullopt, false,
         WebPlatformMediaStreamSource::ConstraintsOnceCallback(), enabled);
     if (!source_started_) {
       mock_source_->StartMockedSource();

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

@@ -75,7 +75,7 @@ MockMediaStreamVideoSource* MockMediaStreamRegistry::AddVideoTrack(
   component->SetPlatformTrack(std::make_unique<MediaStreamVideoTrack>(
       native_source_ptr, adapter_settings, noise_reduction, is_screencast,
       min_frame_rate, base::nullopt /* pan */, base::nullopt /* tilt */,
-      base::nullopt /* zoom */,
+      base::nullopt /* zoom */, false /* pan_tilt_zoom_allowed */,
       MediaStreamVideoSource::ConstraintsOnceCallback(), true /* enabled */));
   descriptor_->AddRemoteTrack(component);
   return native_source_ptr;

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

@@ -406,8 +406,7 @@ class UserMediaProcessorUnderTest : public UserMediaProcessor {
   }
 
   void GetUserMediaRequestSucceeded(const blink::WebMediaStream& stream,
-                                    UserMediaRequest* request_info,
-                                    bool pan_tilt_zoom_allowed) override {
+                                    UserMediaRequest* request_info) override {
     last_generated_stream_ = stream;
     *state_ = REQUEST_SUCCEEDED;
   }

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

@@ -507,6 +507,7 @@ MediaStreamComponent* UserMediaProcessor::RequestInfo::CreateAndStartVideoTrack(
       video_capture_settings_.noise_reduction(), is_video_content_capture_,
       video_capture_settings_.min_frame_rate(), video_capture_settings_.pan(),
       video_capture_settings_.tilt(), video_capture_settings_.zoom(),
+      pan_tilt_zoom_allowed(),
       WTF::Bind(&UserMediaProcessor::RequestInfo::OnTrackStarted,
                 WrapWeakPersistent(this)),
       true);
@@ -1483,8 +1484,7 @@ void UserMediaProcessor::OnCreateNativeTracksCompleted(
       request_info->request_id(), label.Utf8().c_str()));
   if (result == MediaStreamRequestResult::OK) {
     GetUserMediaRequestSucceeded(*request_info->web_stream(),
-                                 request_info->request(),
-                                 request_info->pan_tilt_zoom_allowed());
+                                 request_info->request());
     GetMediaStreamDispatcherHost()->OnStreamStarted(label);
   } else {
     GetUserMediaRequestFailed(result, constraint_name);
@@ -1509,8 +1509,7 @@ void UserMediaProcessor::OnCreateNativeTracksCompleted(
 
 void UserMediaProcessor::GetUserMediaRequestSucceeded(
     const blink::WebMediaStream& stream,
-    UserMediaRequest* user_media_request,
-    bool pan_tilt_zoom_allowed) {
+    UserMediaRequest* user_media_request) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(IsCurrentRequestInfo(user_media_request));
   SendLogMessage(
@@ -1525,15 +1524,13 @@ void UserMediaProcessor::GetUserMediaRequestSucceeded(
       FROM_HERE,
       WTF::Bind(&UserMediaProcessor::DelayedGetUserMediaRequestSucceeded,
                 WrapWeakPersistent(this), current_request_info_->request_id(),
-                stream, WrapPersistent(user_media_request),
-                pan_tilt_zoom_allowed));
+                stream, WrapPersistent(user_media_request)));
 }
 
 void UserMediaProcessor::DelayedGetUserMediaRequestSucceeded(
     int request_id,
     const blink::WebMediaStream& stream,
-    UserMediaRequest* user_media_request,
-    bool pan_tilt_zoom_allowed) {
+    UserMediaRequest* user_media_request) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   SendLogMessage(base::StringPrintf(
       "DelayedGetUserMediaRequestSucceeded({request_id=%d}, {result=%s})",
@@ -1541,7 +1538,7 @@ void UserMediaProcessor::DelayedGetUserMediaRequestSucceeded(
       MediaStreamRequestResultToString(MediaStreamRequestResult::OK)));
   blink::LogUserMediaRequestResult(MediaStreamRequestResult::OK);
   DeleteUserMediaRequest(user_media_request);
-  user_media_request->Succeed(stream, pan_tilt_zoom_allowed);
+  user_media_request->Succeed(stream);
 }
 
 void UserMediaProcessor::GetUserMediaRequestFailed(

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

@@ -102,8 +102,7 @@ class MODULES_EXPORT UserMediaProcessor
   // |request| have completed.
   virtual void GetUserMediaRequestSucceeded(
       const blink::WebMediaStream& stream,
-      UserMediaRequest* user_media_request,
-      bool pan_tilt_zoom_allowed);
+      UserMediaRequest* user_media_request);
   virtual void GetUserMediaRequestFailed(
       blink::mojom::blink::MediaStreamRequestResult result,
       const String& constraint_name = String());
@@ -156,10 +155,10 @@ class MODULES_EXPORT UserMediaProcessor
 
   bool IsCurrentRequestInfo(int request_id) const;
   bool IsCurrentRequestInfo(UserMediaRequest* user_media_request) const;
-  void DelayedGetUserMediaRequestSucceeded(int request_id,
-                                           const blink::WebMediaStream& stream,
-                                           UserMediaRequest* user_media_request,
-                                           bool pan_tilt_zoom_allowed);
+  void DelayedGetUserMediaRequestSucceeded(
+      int request_id,
+      const blink::WebMediaStream& stream,
+      UserMediaRequest* user_media_request);
   void DelayedGetUserMediaRequestFailed(
       int request_id,
       UserMediaRequest* user_media_request,

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

@@ -512,14 +512,13 @@ void UserMediaRequest::Start() {
     controller_->RequestUserMedia(this);
 }
 
-void UserMediaRequest::Succeed(MediaStreamDescriptor* stream_descriptor,
-                               bool pan_tilt_zoom_allowed) {
+void UserMediaRequest::Succeed(MediaStreamDescriptor* stream_descriptor) {
   DCHECK(!is_resolved_);
   if (!GetExecutionContext())
     return;
 
-  MediaStream* stream = MediaStream::Create(
-      GetExecutionContext(), stream_descriptor, pan_tilt_zoom_allowed);
+  MediaStream* stream =
+      MediaStream::Create(GetExecutionContext(), stream_descriptor);
 
   MediaStreamTrackVector audio_tracks = stream->getAudioTracks();
   for (MediaStreamTrackVector::iterator iter = audio_tracks.begin();

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

@@ -118,7 +118,7 @@ class MODULES_EXPORT UserMediaRequest final
 
   void Start();
 
-  void Succeed(MediaStreamDescriptor*, bool pan_tilt_zoom_allowed);
+  void Succeed(MediaStreamDescriptor*);
   void FailConstraint(const String& constraint_name, const String& message);
   void Fail(Error name, const String& message);