media: Switch error callbacks to base::OnceClosure.

Switching several error callback implementations to use
base::OnceClosure explicitly. All of these previously used
base::Closure (implicitly repeating), but all of them would
only ever run the error callback the first time an error
orrurred. The affected classes are:

1. DemuxerStreamAdapter
2. StreamProvider
3. MediaStream

Bug: 1007810
Change-Id: I872ea38eb27ec00c99137435c0408a93f292f9f0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1879949Reviewed-by: mark a. foltz <mfoltz@chromium.org>
Commit-Queue: Chris Mumford <cmumford@google.com>
Cr-Commit-Position: refs/heads/master@{#709733}

media/remoting/courier_renderer.cc

@@ -334,7 +334,8 @@ void CourierRenderer::OnDataPipeCreated(
         main_task_runner_, media_task_runner_, "audio", audio_demuxer_stream,
         rpc_broker_, audio_rpc_handle, std::move(audio),
         std::move(audio_handle),
-        base::Bind(&CourierRenderer::OnFatalError, base::Unretained(this))));
+        base::BindOnce(&CourierRenderer::OnFatalError,
+                       base::Unretained(this))));
   }
 
   // Create video demuxer stream adapter if video is available.
@@ -345,7 +346,8 @@ void CourierRenderer::OnDataPipeCreated(
         main_task_runner_, media_task_runner_, "video", video_demuxer_stream,
         rpc_broker_, video_rpc_handle, std::move(video),
         std::move(video_handle),
-        base::Bind(&CourierRenderer::OnFatalError, base::Unretained(this))));
+        base::BindOnce(&CourierRenderer::OnFatalError,
+                       base::Unretained(this))));
   }
 
   // Checks if data pipe is created successfully.

media/remoting/demuxer_stream_adapter.cc

@@ -36,7 +36,7 @@ DemuxerStreamAdapter::DemuxerStreamAdapter(
     int rpc_handle,
     mojom::RemotingDataStreamSenderPtrInfo stream_sender_info,
     mojo::ScopedDataPipeProducerHandle producer_handle,
-    const ErrorCallback& error_callback)
+    ErrorCallback error_callback)
     : main_task_runner_(std::move(main_task_runner)),
       media_task_runner_(std::move(media_task_runner)),
       name_(name),
@@ -44,7 +44,7 @@ DemuxerStreamAdapter::DemuxerStreamAdapter(
       rpc_handle_(rpc_handle),
       demuxer_stream_(demuxer_stream),
       type_(demuxer_stream ? demuxer_stream->type() : DemuxerStream::UNKNOWN),
-      error_callback_(error_callback),
+      error_callback_(std::move(error_callback)),
       remote_callback_handle_(RpcBroker::kInvalidHandle),
       read_until_callback_handle_(RpcBroker::kInvalidHandle),
       read_until_count_(0),
@@ -58,7 +58,7 @@ DemuxerStreamAdapter::DemuxerStreamAdapter(
   DCHECK(media_task_runner_);
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK(demuxer_stream);
-  DCHECK(!error_callback.is_null());
+  DCHECK(!error_callback_.is_null());
   const RpcBroker::ReceiveMessageCallback receive_callback =
       BindToCurrentLoop(base::BindRepeating(
           &DemuxerStreamAdapter::OnReceivedRpc, weak_factory_.GetWeakPtr()));

media/remoting/demuxer_stream_adapter.h

@@ -40,7 +40,7 @@ namespace remoting {
 // while RPC message should be sent on main thread using |main_task_runner|.
 class DemuxerStreamAdapter {
  public:
-  using ErrorCallback = base::Callback<void(StopTrigger)>;
+  using ErrorCallback = base::OnceCallback<void(StopTrigger)>;
 
   // |main_task_runner|: Task runner to post RPC message on main thread
   // |media_task_runner|: Task runner to run whole class on media thread.
@@ -63,7 +63,7 @@ class DemuxerStreamAdapter {
       int rpc_handle,
       mojom::RemotingDataStreamSenderPtrInfo stream_sender_info,
       mojo::ScopedDataPipeProducerHandle producer_handle,
-      const ErrorCallback& error_callback);
+      ErrorCallback error_callback);
   ~DemuxerStreamAdapter();
 
   // Rpc handle for this class. This is used for sending/receiving RPC message

media/remoting/demuxer_stream_adapter_unittest.cc

@@ -44,8 +44,8 @@ class MockDemuxerStreamAdapter {
         demuxer_stream, rpc_broker_->GetWeakPtr(),
         rpc_broker_->GetUniqueHandle(), std::move(stream_sender_info),
         std::move(producer_handle),
-        base::Bind(&MockDemuxerStreamAdapter::OnError,
-                   weak_factory_.GetWeakPtr())));
+        base::BindOnce(&MockDemuxerStreamAdapter::OnError,
+                       weak_factory_.GetWeakPtr())));
 
     // Faking initialization with random callback handle to start mojo watcher.
     demuxer_stream_adapter_->Initialize(3);

media/remoting/receiver.cc

@@ -74,14 +74,15 @@ void Receiver::AcquireRenderer(std::unique_ptr<pb::RpcMessage> message) {
 
   remote_handle_ = message->integer_value();
   if (stream_provider_) {
-    VLOG(1) << "Acquire renderer error: Already aquired.";
+    VLOG(1) << "Acquire renderer error: Already acquired.";
     OnError(PipelineStatus::PIPELINE_ERROR_DECODE);
     return;
   }
 
   stream_provider_.reset(new StreamProvider(
-      rpc_broker_, base::Bind(&Receiver::OnError, weak_factory_.GetWeakPtr(),
-                              PipelineStatus::PIPELINE_ERROR_DECODE)));
+      rpc_broker_,
+      base::BindOnce(&Receiver::OnError, weak_factory_.GetWeakPtr(),
+                     PipelineStatus::PIPELINE_ERROR_DECODE)));
 
   DVLOG(3) << __func__
            << ": Issues RPC_ACQUIRE_RENDERER_DONE RPC message. remote_handle="

media/remoting/stream_provider.cc

@@ -30,7 +30,7 @@ class MediaStream final : public DemuxerStream {
   MediaStream(RpcBroker* rpc_broker,
               Type type,
               int remote_handle,
-              const base::Closure& error_callback);
+              base::OnceClosure error_callback);
   ~MediaStream() override;
 
   // DemuxerStream implementation.
@@ -92,7 +92,7 @@ class MediaStream final : public DemuxerStream {
   // Set when Read() is called. Run only once when read completes.
   ReadCB read_complete_callback_;
 
-  base::Closure error_callback_;  // Called only once when first error occurs.
+  base::OnceClosure error_callback_;  // Called when first error occurs.
 
   base::circular_deque<scoped_refptr<DecoderBuffer>> buffers_;
 
@@ -112,12 +112,12 @@ class MediaStream final : public DemuxerStream {
 MediaStream::MediaStream(RpcBroker* rpc_broker,
                          Type type,
                          int remote_handle,
-                         const base::Closure& error_callback)
+                         base::OnceClosure error_callback)
     : rpc_broker_(rpc_broker),
       type_(type),
       remote_handle_(remote_handle),
       rpc_handle_(rpc_broker_->GetUniqueHandle()),
-      error_callback_(error_callback) {
+      error_callback_(std::move(error_callback)) {
   DCHECK(remote_handle_ != RpcBroker::kInvalidHandle);
   rpc_broker_->RegisterMessageReceiverCallback(
       rpc_handle_,
@@ -391,8 +391,8 @@ void MediaStream::OnError(const std::string& error) {
 }
 
 StreamProvider::StreamProvider(RpcBroker* rpc_broker,
-                               const base::Closure& error_callback)
-    : rpc_broker_(rpc_broker), error_callback_(error_callback) {}
+                               base::OnceClosure error_callback)
+    : rpc_broker_(rpc_broker), error_callback_(std::move(error_callback)) {}
 
 StreamProvider::~StreamProvider() = default;
 
@@ -415,16 +415,16 @@ void StreamProvider::Initialize(int remote_audio_handle,
   if (remote_audio_handle != RpcBroker::kInvalidHandle) {
     audio_stream_.reset(new MediaStream(
         rpc_broker_, DemuxerStream::AUDIO, remote_audio_handle,
-        base::Bind(&StreamProvider::OnError, weak_factory_.GetWeakPtr(),
-                   "Media stream error")));
+        base::BindOnce(&StreamProvider::OnError, weak_factory_.GetWeakPtr(),
+                       "Media stream error")));
     audio_stream_->Initialize(base::Bind(
         &StreamProvider::AudioStreamInitialized, weak_factory_.GetWeakPtr()));
   }
   if (remote_video_handle != RpcBroker::kInvalidHandle) {
     video_stream_.reset(new MediaStream(
         rpc_broker_, DemuxerStream::VIDEO, remote_video_handle,
-        base::Bind(&StreamProvider::OnError, weak_factory_.GetWeakPtr(),
-                   "Media stream error")));
+        base::BindOnce(&StreamProvider::OnError, weak_factory_.GetWeakPtr(),
+                       "Media stream error")));
     video_stream_->Initialize(base::Bind(
         &StreamProvider::VideoStreamInitialized, weak_factory_.GetWeakPtr()));
   }

media/remoting/stream_provider.h

@@ -20,7 +20,7 @@ class MediaStream;
 // The media stream provider for Media Remoting receiver.
 class StreamProvider final : public MediaResource {
  public:
-  StreamProvider(RpcBroker* rpc_broker, const base::Closure& error_callback);
+  StreamProvider(RpcBroker* rpc_broker, base::OnceClosure error_callback);
 
   ~StreamProvider() override;
 
@@ -52,8 +52,8 @@ class StreamProvider final : public MediaResource {
   // and audio streams are initialized or error occurs.
   base::Closure init_done_callback_;
 
-  // Run only once when first error occurs;
-  base::Closure error_callback_;
+  // Run when first error occurs;
+  base::OnceClosure error_callback_;
 
   base::WeakPtrFactory<StreamProvider> weak_factory_{this};