media: Migrate ReceiveEncodedFrameCallback to once callback.

This is a once callback because it is run to indicate the completion of
the RequestEncodedFrame method:
* https://cs.chromium.org/chromium/src/media/cast/cast_receiver.h?rcl=dbfabe22380e821376c625ccabce8cc92e1c4b2b&l=43
* https://cs.chromium.org/chromium/src/media/cast/receiver/frame_receiver.h?rcl=dbfabe22380e821376c625ccabce8cc92e1c4b2b&l=62

This callback is placed in a queue by RequestEncodedFrame in:
* https://cs.chromium.org/chromium/src/media/cast/receiver/frame_receiver.cc?rcl=dbfabe22380e821376c625ccabce8cc92e1c4b2b&l=80

And it is extracted from the queue in:
* https://cs.chromium.org/chromium/src/media/cast/receiver/frame_receiver.cc?rcl=dbfabe22380e821376c625ccabce8cc92e1c4b2b&l=281

And passed to EmitOneFrame to be executed once in:
* https://cs.chromium.org/chromium/src/media/cast/receiver/frame_receiver.cc?rcl=dbfabe22380e821376c625ccabce8cc92e1c4b2b&l=301

This is part of the base::Callback migration.

Context: https://cs.chromium.org/chromium/src/docs/callback.md?rcl=9fcc3764aea8f97e9f6de4a9ee61d554e67edcda&l=40

Bug: 714018
Change-Id: Iaaaa1b830c5f8e65a94124233d28614e36c8f1de
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2077994
Commit-Queue: Jose Lopes <jabolopes@google.com>
Reviewed-by: Yuri Wiitala <miu@chromium.org>
Reviewed-by: Albert J. Wong <ajwong@chromium.org>
Cr-Commit-Position: refs/heads/master@{#747613}

media/cast/cast_receiver.h

@@ -39,13 +39,6 @@ using VideoFrameDecodedCallback =
                                  base::TimeTicks playout_time,
                                  bool is_continuous)>;
 
-// The following callback delivers encoded frame data and metadata.  The client
-// should examine the |frame_id| field to determine whether any frames have been
-// dropped (i.e., frame_id should be incrementing by one each time).  Note: A
-// NULL pointer can be returned on error.
-typedef base::Callback<void(std::unique_ptr<EncodedFrame>)>
-    ReceiveEncodedFrameCallback;
-
 class CastReceiver {
  public:
   static std::unique_ptr<CastReceiver> Create(

media/cast/receiver/frame_receiver.cc

@@ -74,10 +74,9 @@ FrameReceiver::~FrameReceiver() {
   cast_environment_->logger()->Unsubscribe(&event_subscriber_);
 }
 
-void FrameReceiver::RequestEncodedFrame(
-    const ReceiveEncodedFrameCallback& callback) {
+void FrameReceiver::RequestEncodedFrame(ReceiveEncodedFrameCallback callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  frame_request_queue_.push_back(callback);
+  frame_request_queue_.push_back(std::move(callback));
   EmitAvailableEncodedFrames();
 }
 
@@ -282,7 +281,7 @@ void FrameReceiver::EmitAvailableEncodedFrames() {
     cast_environment_->PostTask(
         CastEnvironment::MAIN, FROM_HERE,
         base::BindOnce(&FrameReceiver::EmitOneFrame, AsWeakPtr(),
-                       frame_request_queue_.front(),
+                       base::Passed(std::move(*frame_request_queue_.begin())),
                        base::Passed(&encoded_frame)));
     frame_request_queue_.pop_front();
   }
@@ -296,11 +295,11 @@ void FrameReceiver::EmitAvailableEncodedFramesAfterWaiting() {
 }
 
 void FrameReceiver::EmitOneFrame(
-    const ReceiveEncodedFrameCallback& callback,
+    ReceiveEncodedFrameCallback callback,
     std::unique_ptr<EncodedFrame> encoded_frame) const {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (!callback.is_null())
-    callback.Run(std::move(encoded_frame));
+    std::move(callback).Run(std::move(encoded_frame));
 }
 
 base::TimeTicks FrameReceiver::GetPlayoutTime(const EncodedFrame& frame) const {

media/cast/receiver/frame_receiver.h

@@ -32,6 +32,13 @@ namespace cast {
 
 class CastEnvironment;
 
+// The following callback delivers encoded frame data and metadata.  The client
+// should examine the |frame_id| field to determine whether any frames have been
+// dropped (i.e., frame_id should be incrementing by one each time).  Note: A
+// nullptr can be returned on error.
+using ReceiveEncodedFrameCallback =
+    base::OnceCallback<void(std::unique_ptr<EncodedFrame>)>;
+
 // FrameReceiver receives packets out-of-order while clients make requests for
 // complete frames in-order.  (A frame consists of one or more packets.)
 //
@@ -63,7 +70,7 @@ class FrameReceiver : public RtpPayloadFeedback {
   //
   // The given |callback| is guaranteed to be run at some point in the future,
   // except for those requests still enqueued at destruction time.
-  void RequestEncodedFrame(const ReceiveEncodedFrameCallback& callback);
+  void RequestEncodedFrame(ReceiveEncodedFrameCallback callback);
 
   // Called to deliver another packet, possibly a duplicate, and possibly
   // out-of-order.  Returns true if the parsing of the packet succeeded.
@@ -96,7 +103,7 @@ class FrameReceiver : public RtpPayloadFeedback {
   // This method is used by EmitAvailableEncodedFrames() to return to the event
   // loop, but make sure that FrameReceiver is still alive before the callback
   // is run.
-  void EmitOneFrame(const ReceiveEncodedFrameCallback& callback,
+  void EmitOneFrame(ReceiveEncodedFrameCallback callback,
                     std::unique_ptr<EncodedFrame> encoded_frame) const;
 
   // Computes the playout time for a frame with the given |rtp_timestamp|.

media/cast/receiver/frame_receiver_unittest.cc

@@ -254,10 +254,8 @@ TEST_F(FrameReceiverTest, ReceivesFramesSkippingWhenAppropriate) {
   const base::TimeTicks first_frame_capture_time = testing_clock_.NowTicks();
 
   // Enqueue a request for a frame.
-  const ReceiveEncodedFrameCallback frame_encoded_callback =
-      base::Bind(&FakeFrameClient::DeliverEncodedFrame,
-                 base::Unretained(&frame_client_));
-  receiver_->RequestEncodedFrame(frame_encoded_callback);
+  receiver_->RequestEncodedFrame(base::BindOnce(
+      &FakeFrameClient::DeliverEncodedFrame, base::Unretained(&frame_client_)));
   task_runner_->RunTasks();
   EXPECT_EQ(0, frame_client_.number_times_called());
 
@@ -272,7 +270,8 @@ TEST_F(FrameReceiverTest, ReceivesFramesSkippingWhenAppropriate) {
   EXPECT_EQ(1, frame_client_.number_times_called());
 
   // Enqueue a second request for a frame, but it should not be fulfilled yet.
-  receiver_->RequestEncodedFrame(frame_encoded_callback);
+  receiver_->RequestEncodedFrame(base::BindOnce(
+      &FakeFrameClient::DeliverEncodedFrame, base::Unretained(&frame_client_)));
   task_runner_->RunTasks();
   EXPECT_EQ(1, frame_client_.number_times_called());
 
@@ -292,7 +291,8 @@ TEST_F(FrameReceiverTest, ReceivesFramesSkippingWhenAppropriate) {
   EXPECT_EQ(1, frame_client_.number_times_called());
 
   // Enqueue a third request for a frame.
-  receiver_->RequestEncodedFrame(frame_encoded_callback);
+  receiver_->RequestEncodedFrame(base::BindOnce(
+      &FakeFrameClient::DeliverEncodedFrame, base::Unretained(&frame_client_)));
   task_runner_->RunTasks();
   EXPECT_EQ(1, frame_client_.number_times_called());
 
@@ -368,10 +368,8 @@ TEST_F(FrameReceiverTest, ReceivesFramesRefusingToSkipAny) {
   const base::TimeTicks first_frame_capture_time = testing_clock_.NowTicks();
 
   // Enqueue a request for a frame.
-  const ReceiveEncodedFrameCallback frame_encoded_callback =
-      base::Bind(&FakeFrameClient::DeliverEncodedFrame,
-                 base::Unretained(&frame_client_));
-  receiver_->RequestEncodedFrame(frame_encoded_callback);
+  receiver_->RequestEncodedFrame(base::BindOnce(
+      &FakeFrameClient::DeliverEncodedFrame, base::Unretained(&frame_client_)));
   task_runner_->RunTasks();
   EXPECT_EQ(0, frame_client_.number_times_called());
 
@@ -386,7 +384,8 @@ TEST_F(FrameReceiverTest, ReceivesFramesRefusingToSkipAny) {
   EXPECT_EQ(1, frame_client_.number_times_called());
 
   // Enqueue a second request for a frame, but it should not be fulfilled yet.
-  receiver_->RequestEncodedFrame(frame_encoded_callback);
+  receiver_->RequestEncodedFrame(base::BindOnce(
+      &FakeFrameClient::DeliverEncodedFrame, base::Unretained(&frame_client_)));
   task_runner_->RunTasks();
   EXPECT_EQ(1, frame_client_.number_times_called());
 
@@ -403,7 +402,8 @@ TEST_F(FrameReceiverTest, ReceivesFramesRefusingToSkipAny) {
   EXPECT_EQ(1, frame_client_.number_times_called());
 
   // Enqueue a third request for a frame.
-  receiver_->RequestEncodedFrame(frame_encoded_callback);
+  receiver_->RequestEncodedFrame(base::BindOnce(
+      &FakeFrameClient::DeliverEncodedFrame, base::Unretained(&frame_client_)));
   task_runner_->RunTasks();
   EXPECT_EQ(1, frame_client_.number_times_called());