Migrate blink::MediaStreamVideoSource to WTF::Bind

This CL is the 3rd out of n CLs to convert modules/mediastream/
away from base::Bind{Once,Repeating} to their respective Blink/WTF
counterparts.

In this particular CL, a weak reference of MediaStreamVideoSource is
passed to VideoTrackAdapter ctor to avoid double-bind methods with
CrossThreadBind -> ConvertToBaseCallback -> CrossThreadBind.

R=dgozman@chromium.org, guidou@chromium.org
CC=​​blink-reviews-vendor@chromium.org

BUG=923394

Change-Id: Ibd75c5fef80bef1a4328c4abb007fb07efbcc095
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1594114
Commit-Queue: Antonio Gomes <tonikitoo@igalia.com>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Reviewed-by: Hiroshige Hayashizaki <hiroshige@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#660725}

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

@@ -16,11 +16,13 @@
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/threading/sequenced_task_runner_handle.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/web/modules/mediastream/media_stream_constraints_util_video_device.h"
 #include "third_party/blink/public/web/modules/mediastream/media_stream_video_track.h"
 #include "third_party/blink/renderer/modules/mediastream/video_track_adapter.h"
+#include "third_party/blink/renderer/platform/cross_thread_functional.h"
+#include "third_party/blink/renderer/platform/scheduler/public/post_cross_thread_task.h"
+#include "third_party/blink/renderer/platform/scheduler/public/thread.h"
 
 namespace blink {
 
@@ -36,9 +38,7 @@ MediaStreamVideoSource* MediaStreamVideoSource::GetVideoSource(
 MediaStreamVideoSource::MediaStreamVideoSource()
     : state_(NEW), weak_factory_(this) {
   track_adapter_ = base::MakeRefCounted<VideoTrackAdapter>(
-      Platform::Current()->GetIOTaskRunner(),
-      base::BindRepeating(&MediaStreamVideoSource::OnFrameDropped,
-                          weak_factory_.GetWeakPtr()));
+      Platform::Current()->GetIOTaskRunner(), GetWeakPtr());
 }
 
 MediaStreamVideoSource::~MediaStreamVideoSource() {
@@ -65,8 +65,8 @@ void MediaStreamVideoSource::AddTrack(
   switch (state_) {
     case NEW: {
       state_ = STARTING;
-      StartSourceImpl(
-          base::Bind(&VideoTrackAdapter::DeliverFrameOnIO, track_adapter_));
+      StartSourceImpl(ConvertToBaseCallback(CrossThreadBind(
+          &VideoTrackAdapter::DeliverFrameOnIO, track_adapter_)));
       break;
     }
     case STARTING:
@@ -128,9 +128,9 @@ void MediaStreamVideoSource::RemoveTrack(MediaStreamVideoTrack* video_track,
       // stopping a source with StopSource() can have side effects that affect
       // sources created after that StopSource() call, but before the actual
       // stop takes place. See https://crbug.com/778039.
-      StopForRestart(base::BindOnce(&MediaStreamVideoSource::DidStopSource,
-                                    weak_factory_.GetWeakPtr(),
-                                    std::move(callback)));
+      StopForRestart(WTF::Bind(&MediaStreamVideoSource::DidStopSource,
+                               weak_factory_.GetWeakPtr(),
+                               std::move(callback)));
       if (state_ == STOPPING_FOR_RESTART || state_ == STOPPED_FOR_RESTART) {
         // If the source supports restarting, it is necessary to call
         // FinalizeStopSource() to ensure the same behavior as StopSource(),
@@ -186,9 +186,9 @@ void MediaStreamVideoSource::ReconfigureTrack(
 void MediaStreamVideoSource::StopForRestart(RestartCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (state_ != STARTED) {
-    base::SequencedTaskRunnerHandle::Get()->PostTask(
+    Thread::Current()->GetTaskRunner()->PostTask(
         FROM_HERE,
-        base::BindOnce(std::move(callback), RestartResult::INVALID_STATE));
+        WTF::Bind(std::move(callback), RestartResult::INVALID_STATE));
     return;
   }
 
@@ -223,8 +223,8 @@ void MediaStreamVideoSource::OnStopForRestartDone(bool did_stop_for_restart) {
 
   RestartResult result = did_stop_for_restart ? RestartResult::IS_STOPPED
                                               : RestartResult::IS_RUNNING;
-  base::SequencedTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(std::move(restart_callback_), result));
+  Thread::Current()->GetTaskRunner()->PostTask(
+      FROM_HERE, WTF::Bind(std::move(restart_callback_), result));
 }
 
 void MediaStreamVideoSource::Restart(
@@ -232,9 +232,9 @@ void MediaStreamVideoSource::Restart(
     RestartCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (state_ != STOPPED_FOR_RESTART) {
-    base::SequencedTaskRunnerHandle::Get()->PostTask(
+    Thread::Current()->GetTaskRunner()->PostTask(
         FROM_HERE,
-        base::BindOnce(std::move(callback), RestartResult::INVALID_STATE));
+        WTF::Bind(std::move(callback), RestartResult::INVALID_STATE));
     return;
   }
   DCHECK(!restart_callback_);
@@ -264,8 +264,8 @@ void MediaStreamVideoSource::OnRestartDone(bool did_restart) {
 
   RestartResult result =
       did_restart ? RestartResult::IS_RUNNING : RestartResult::IS_STOPPED;
-  base::SequencedTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(std::move(restart_callback_), result));
+  Thread::Current()->GetTaskRunner()->PostTask(
+      FROM_HERE, WTF::Bind(std::move(restart_callback_), result));
 }
 
 void MediaStreamVideoSource::UpdateHasConsumers(MediaStreamVideoTrack* track,
@@ -400,8 +400,8 @@ void MediaStreamVideoSource::StartFrameMonitoring() {
     track_adapter_->SetSourceFrameSize(IntSize(current_format->frame_size));
   }
   track_adapter_->StartFrameMonitoring(
-      frame_rate, base::Bind(&MediaStreamVideoSource::SetMutedState,
-                             weak_factory_.GetWeakPtr()));
+      frame_rate, WTF::BindRepeating(&MediaStreamVideoSource::SetMutedState,
+                                     weak_factory_.GetWeakPtr()));
 }
 
 void MediaStreamVideoSource::SetReadyState(

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

@@ -143,8 +143,7 @@ class VideoTrackAdapter::VideoFrameResolutionAdapter
   VideoFrameResolutionAdapter(
       scoped_refptr<base::SingleThreadTaskRunner> render_message_loop,
       const VideoTrackAdapterSettings& settings,
-      base::RepeatingCallback<void(media::VideoCaptureFrameDropReason)>
-          frame_dropped_cb);
+      base::WeakPtr<MediaStreamVideoSource> media_stream_video_source);
 
   // Add |frame_callback| to receive video frames on the IO-thread and
   // |settings_callback| to set track settings on the main thread.
@@ -210,8 +209,7 @@ class VideoTrackAdapter::VideoFrameResolutionAdapter
   // registered in AddCallbacks.
   const scoped_refptr<base::SingleThreadTaskRunner> renderer_task_runner_;
 
-  base::RepeatingCallback<void(media::VideoCaptureFrameDropReason)>
-      frame_dropped_cb_;
+  base::WeakPtr<MediaStreamVideoSource> media_stream_video_source_;
 
   VideoTrackAdapterSettings settings_;
   double frame_rate_;
@@ -229,10 +227,9 @@ class VideoTrackAdapter::VideoFrameResolutionAdapter
 VideoTrackAdapter::VideoFrameResolutionAdapter::VideoFrameResolutionAdapter(
     scoped_refptr<base::SingleThreadTaskRunner> render_message_loop,
     const VideoTrackAdapterSettings& settings,
-    base::RepeatingCallback<void(media::VideoCaptureFrameDropReason)>
-        frame_dropped_cb)
+    base::WeakPtr<MediaStreamVideoSource> media_stream_video_source)
     : renderer_task_runner_(render_message_loop),
-      frame_dropped_cb_(std::move(frame_dropped_cb)),
+      media_stream_video_source_(media_stream_video_source),
       settings_(settings),
       frame_rate_(MediaStreamVideoSource::kDefaultFrameRate),
       last_time_stamp_(base::TimeDelta::Max()),
@@ -482,17 +479,18 @@ void VideoTrackAdapter::VideoFrameResolutionAdapter::ResetFrameRate() {
 void VideoTrackAdapter::VideoFrameResolutionAdapter::
     PostFrameDroppedToMainTaskRunner(
         media::VideoCaptureFrameDropReason reason) {
-  PostCrossThreadTask(*renderer_task_runner_, FROM_HERE,
-                      CrossThreadBind(frame_dropped_cb_, reason));
+  PostCrossThreadTask(
+      *renderer_task_runner_, FROM_HERE,
+      CrossThreadBindOnce(&MediaStreamVideoSource::OnFrameDropped,
+                          media_stream_video_source_, reason));
 }
 
 VideoTrackAdapter::VideoTrackAdapter(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-    base::RepeatingCallback<void(media::VideoCaptureFrameDropReason)>
-        frame_dropped_cb)
+    base::WeakPtr<MediaStreamVideoSource> media_stream_video_source)
     : io_task_runner_(io_task_runner),
+      media_stream_video_source_(media_stream_video_source),
       renderer_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      frame_dropped_cb_(std::move(frame_dropped_cb)),
       monitoring_frame_rate_(false),
       muted_state_(false),
       frame_counter_(0),
@@ -537,7 +535,7 @@ void VideoTrackAdapter::AddTrackOnIO(
   }
   if (!adapter.get()) {
     adapter = base::MakeRefCounted<VideoFrameResolutionAdapter>(
-        renderer_task_runner_, settings, frame_dropped_cb_);
+        renderer_task_runner_, settings, media_stream_video_source_);
     adapters_.push_back(adapter);
   }
 
@@ -748,9 +746,10 @@ void VideoTrackAdapter::DeliverFrameOnIO(
   if (adapters_.IsEmpty()) {
     PostCrossThreadTask(
         *renderer_task_runner_, FROM_HERE,
-        CrossThreadBind(frame_dropped_cb_,
-                        media::VideoCaptureFrameDropReason::
-                            kVideoTrackAdapterHasNoResolutionAdapters));
+        CrossThreadBindOnce(&MediaStreamVideoSource::OnFrameDropped,
+                            media_stream_video_source_,
+                            media::VideoCaptureFrameDropReason::
+                                kVideoTrackAdapterHasNoResolutionAdapters));
   }
   for (const auto& adapter : adapters_)
     adapter->DeliverFrame(frame, estimated_capture_time, is_device_rotated);

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

@@ -9,6 +9,7 @@
 
 #include "base/callback.h"
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 #include "base/optional.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
@@ -41,8 +42,7 @@ class BLINK_EXPORT VideoTrackAdapter
 
   VideoTrackAdapter(
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-      base::RepeatingCallback<void(media::VideoCaptureFrameDropReason)>
-          frame_dropped_cb);
+      base::WeakPtr<MediaStreamVideoSource> media_stream_video_source);
 
   // Register |track| to receive video frames in |frame_callback| with
   // a resolution within the boundaries of the arguments, and settings
@@ -130,13 +130,12 @@ class BLINK_EXPORT VideoTrackAdapter
 
   const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
+  base::WeakPtr<MediaStreamVideoSource> media_stream_video_source_;
+
   // |renderer_task_runner_| is used to ensure that
   // VideoCaptureDeliverFrameCB is released on the main render thread.
   const scoped_refptr<base::SingleThreadTaskRunner> renderer_task_runner_;
 
-  const base::RepeatingCallback<void(media::VideoCaptureFrameDropReason)>
-      frame_dropped_cb_;
-
   // VideoFrameResolutionAdapter is an inner class that lives on the IO-thread.
   // It does the resolution adaptation and delivers frames to all registered
   // tracks.