Convert chromecast/media to base::Bind and base::Callback to

Once/Repeating

Modified coded_frame_provider and its subclass buffering_frame_provider
and demuxer_stream_adapter to use OnceClosure and BindOnce.
Modified mock_frame_consumer/provider to use
OnceClosure and BindOnce.

Bug: 1007649
Change-Id: I9f464c65065c8676be8ee793a9ba6d099eff9863
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2278583Reviewed-by: Kenneth MacKay <kmackay@chromium.org>
Commit-Queue: Shengfa Lin <shengfa@google.com>
Cr-Commit-Position: refs/heads/master@{#785831}

chromecast/media/cma/base/buffering_frame_provider.cc

@@ -52,18 +52,18 @@ BufferingFrameProvider::~BufferingFrameProvider() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
-void BufferingFrameProvider::Read(const ReadCB& read_cb) {
+void BufferingFrameProvider::Read(ReadCB read_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DCHECK(!read_cb.is_null());
-  read_cb_ = read_cb;
+  read_cb_ = std::move(read_cb);
 
   CompleteReadIfNeeded();
 
   RequestBufferIfNeeded();
 }
 
-void BufferingFrameProvider::Flush(const base::Closure& flush_cb) {
+void BufferingFrameProvider::Flush(base::OnceClosure flush_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Invalidate all the buffers that belong to this media timeline.
@@ -79,7 +79,7 @@ void BufferingFrameProvider::Flush(const base::Closure& flush_cb) {
   buffer_list_.clear();
   total_buffer_size_ = 0;
   read_cb_.Reset();
-  coded_frame_provider_->Flush(flush_cb);
+  coded_frame_provider_->Flush(std::move(flush_cb));
 }
 
 void BufferingFrameProvider::OnNewBuffer(
@@ -118,7 +118,7 @@ void BufferingFrameProvider::RequestBufferIfNeeded() {
 
   is_pending_request_ = true;
   coded_frame_provider_->Read(::media::BindToCurrentLoop(
-      base::Bind(&BufferingFrameProvider::OnNewBuffer, weak_this_)));
+      base::BindOnce(&BufferingFrameProvider::OnNewBuffer, weak_this_)));
 }
 
 void BufferingFrameProvider::CompleteReadIfNeeded() {

chromecast/media/cma/base/buffering_frame_provider.h

@@ -46,8 +46,8 @@ class BufferingFrameProvider : public CodedFrameProvider {
   ~BufferingFrameProvider() override;
 
   // CodedFrameProvider implementation.
-  void Read(const ReadCB& read_cb) override;
-  void Flush(const base::Closure& flush_cb) override;
+  void Read(ReadCB read_cb) override;
+  void Flush(base::OnceClosure flush_cb) override;
 
  private:
   class BufferWithConfig {

chromecast/media/cma/base/buffering_frame_provider_unittest.cc

@@ -102,9 +102,8 @@ void BufferingFrameProviderTest::Configure(
 }
 
 void BufferingFrameProviderTest::Start() {
-  frame_consumer_->Start(
-      base::Bind(&BufferingFrameProviderTest::OnTestCompleted,
-                 base::Unretained(this)));
+  frame_consumer_->Start(base::BindOnce(
+      &BufferingFrameProviderTest::OnTestCompleted, base::Unretained(this)));
 }
 
 void BufferingFrameProviderTest::OnTestTimeout() {

chromecast/media/cma/base/coded_frame_provider.h

@@ -20,9 +20,10 @@ class DecoderBufferBase;
 
 class CodedFrameProvider {
  public:
-  typedef base::Callback<void(const scoped_refptr<DecoderBufferBase>&,
-                              const ::media::AudioDecoderConfig&,
-                              const ::media::VideoDecoderConfig&)> ReadCB;
+  typedef base::OnceCallback<void(const scoped_refptr<DecoderBufferBase>&,
+                                  const ::media::AudioDecoderConfig&,
+                                  const ::media::VideoDecoderConfig&)>
+      ReadCB;
 
   CodedFrameProvider();
   virtual ~CodedFrameProvider();
@@ -33,14 +34,14 @@ class CodedFrameProvider {
   // these configurations are returned as part of the |read_cb| callback.
   // Invoking the |read_cb| callback with invalid audio/video configurations
   // means the configurations have not changed.
-  virtual void Read(const ReadCB& read_cb) = 0;
+  virtual void Read(ReadCB read_cb) = 0;
 
   // Flush the coded frames held by the frame provider.
   // Invoke callback |flush_cb| when completed.
   // Note: any pending read is cancelled, meaning that any pending |read_cb|
   // callback will not be invoked.
   // TODO(alokp): Delete this function once CmaRenderer is deprecated.
-  virtual void Flush(const base::Closure& flush_cb) = 0;
+  virtual void Flush(base::OnceClosure flush_cb) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CodedFrameProvider);

chromecast/media/cma/base/demuxer_stream_adapter.cc

@@ -43,7 +43,7 @@ DemuxerStreamAdapter::~DemuxerStreamAdapter() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
-void DemuxerStreamAdapter::Read(const ReadCB& read_cb) {
+void DemuxerStreamAdapter::Read(ReadCB read_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DCHECK(flush_cb_.is_null());
@@ -51,18 +51,19 @@ void DemuxerStreamAdapter::Read(const ReadCB& read_cb) {
   // Support only one read at a time.
   DCHECK(!is_pending_read_);
   is_pending_read_ = true;
-  ReadInternal(read_cb);
+  ReadInternal(std::move(read_cb));
 }
 
-void DemuxerStreamAdapter::ReadInternal(const ReadCB& read_cb) {
+void DemuxerStreamAdapter::ReadInternal(ReadCB read_cb) {
   bool may_run_in_future = media_task_runner_->PostMediaTask(
       FROM_HERE,
-      base::Bind(&DemuxerStreamAdapter::RequestBuffer, weak_this_, read_cb),
+      base::BindOnce(&DemuxerStreamAdapter::RequestBuffer, weak_this_,
+                     std::move(read_cb)),
       max_pts_);
   DCHECK(may_run_in_future);
 }
 
-void DemuxerStreamAdapter::Flush(const base::Closure& flush_cb) {
+void DemuxerStreamAdapter::Flush(base::OnceClosure flush_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LOG(INFO) << __FUNCTION__;
 
@@ -81,7 +82,7 @@ void DemuxerStreamAdapter::Flush(const base::Closure& flush_cb) {
     // If there is a pending demuxer read, the implicit contract
     // is that the pending read must be completed before invoking the
     // flush callback.
-    flush_cb_ = flush_cb;
+    flush_cb_ = std::move(flush_cb);
     return;
   }
 
@@ -92,7 +93,7 @@ void DemuxerStreamAdapter::Flush(const base::Closure& flush_cb) {
   weak_this_ = weak_factory_.GetWeakPtr();
 
   LOG(INFO) << "Flush done";
-  flush_cb.Run();
+  std::move(flush_cb).Run();
 }
 
 void DemuxerStreamAdapter::ResetMediaTaskRunner() {
@@ -105,15 +106,15 @@ void DemuxerStreamAdapter::ResetMediaTaskRunner() {
   }
 }
 
-void DemuxerStreamAdapter::RequestBuffer(const ReadCB& read_cb) {
+void DemuxerStreamAdapter::RequestBuffer(ReadCB read_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   is_pending_demuxer_read_ = true;
-  demuxer_stream_->Read(::media::BindToCurrentLoop(
-      base::Bind(&DemuxerStreamAdapter::OnNewBuffer, weak_this_, read_cb)));
+  demuxer_stream_->Read(::media::BindToCurrentLoop(base::BindOnce(
+      &DemuxerStreamAdapter::OnNewBuffer, weak_this_, std::move(read_cb))));
 }
 
 void DemuxerStreamAdapter::OnNewBuffer(
-    const ReadCB& read_cb,
+    ReadCB read_cb,
     ::media::DemuxerStream::Status status,
     scoped_refptr<::media::DecoderBuffer> input) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ -140,7 +141,7 @@ void DemuxerStreamAdapter::OnNewBuffer(
       audio_config_ = demuxer_stream_->audio_decoder_config();
 
     // Got a new config, but we still need to get a frame.
-    ReadInternal(read_cb);
+    ReadInternal(std::move(read_cb));
     return;
   }
 
@@ -163,7 +164,7 @@ void DemuxerStreamAdapter::OnNewBuffer(
   is_pending_read_ = false;
   scoped_refptr<DecoderBufferBase> buffer(
       new DecoderBufferAdapter(std::move(input)));
-  read_cb.Run(buffer, audio_config_, video_config_);
+  std::move(read_cb).Run(buffer, audio_config_, video_config_);
 
   // Back to the default audio/video config:
   // an invalid audio/video config means there is no config update.

chromecast/media/cma/base/demuxer_stream_adapter.h

@@ -41,17 +41,17 @@ class DemuxerStreamAdapter : public CodedFrameProvider {
   ~DemuxerStreamAdapter() override;
 
   // CodedFrameProvider implementation.
-  void Read(const ReadCB& read_cb) override;
-  void Flush(const base::Closure& flush_cb) override;
+  void Read(ReadCB read_cb) override;
+  void Flush(base::OnceClosure flush_cb) override;
 
  private:
   void ResetMediaTaskRunner();
 
-  void ReadInternal(const ReadCB& read_cb);
-  void RequestBuffer(const ReadCB& read_cb);
+  void ReadInternal(ReadCB read_cb);
+  void RequestBuffer(ReadCB read_cb);
 
   // Callback invoked from the demuxer stream to signal a buffer is ready.
-  void OnNewBuffer(const ReadCB& read_cb,
+  void OnNewBuffer(ReadCB read_cb,
                    ::media::DemuxerStream::Status status,
                    scoped_refptr<::media::DecoderBuffer> input);
 
@@ -77,7 +77,7 @@ class DemuxerStreamAdapter : public CodedFrameProvider {
 
   // In case of a pending flush operation, this is the callback
   // that is invoked when flush is completed.
-  base::Closure flush_cb_;
+  base::OnceClosure flush_cb_;
 
   // Audio/video configuration that applies to the next frame.
   ::media::AudioDecoderConfig audio_config_;

chromecast/media/cma/base/demuxer_stream_adapter_unittest.cc

@@ -96,8 +96,8 @@ void DemuxerStreamAdapterTest::Start() {
                      base::Unretained(this)),
       base::TimeDelta::FromSeconds(5));
 
-  coded_frame_provider_->Read(base::Bind(&DemuxerStreamAdapterTest::OnNewFrame,
-                                         base::Unretained(this)));
+  coded_frame_provider_->Read(base::BindOnce(
+      &DemuxerStreamAdapterTest::OnNewFrame, base::Unretained(this)));
 }
 
 void DemuxerStreamAdapterTest::OnTestTimeout() {
@@ -122,26 +122,26 @@ void DemuxerStreamAdapterTest::OnNewFrame(
   frame_received_count_++;
 
   if (frame_received_count_ >= total_frames_) {
-    coded_frame_provider_->Flush(base::Bind(
+    coded_frame_provider_->Flush(base::BindOnce(
         &DemuxerStreamAdapterTest::OnFlushCompleted, base::Unretained(this)));
     return;
   }
 
-  coded_frame_provider_->Read(base::Bind(&DemuxerStreamAdapterTest::OnNewFrame,
-                                         base::Unretained(this)));
+  coded_frame_provider_->Read(base::BindOnce(
+      &DemuxerStreamAdapterTest::OnNewFrame, base::Unretained(this)));
 
   ASSERT_LE(frame_received_count_, early_flush_idx_);
   if (frame_received_count_ == early_flush_idx_) {
-    base::Closure flush_cb = base::Bind(
+    base::OnceClosure flush_cb = base::BindOnce(
         &DemuxerStreamAdapterTest::OnFlushCompleted, base::Unretained(this));
     if (use_post_task_for_flush_) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::BindOnce(&CodedFrameProvider::Flush,
                          base::Unretained(coded_frame_provider_.get()),
-                         flush_cb));
+                         std::move(flush_cb)));
     } else {
-      coded_frame_provider_->Flush(flush_cb);
+      coded_frame_provider_->Flush(std::move(flush_cb));
     }
     return;
   }

chromecast/media/cma/base/multi_demuxer_stream_adapter_unittest.cc

@@ -101,14 +101,14 @@ void MultiDemuxerStreamAdaptersTest::Start() {
   // read each stream
   for (const auto& code_frame_provider : coded_frame_providers_) {
     auto read_cb =
-        base::Bind(&MultiDemuxerStreamAdaptersTest::OnNewFrame,
-                   base::Unretained(this), code_frame_provider.get());
+        base::BindOnce(&MultiDemuxerStreamAdaptersTest::OnNewFrame,
+                       base::Unretained(this), code_frame_provider.get());
 
-    base::Closure task =
-        base::Bind(&CodedFrameProvider::Read,
-                   base::Unretained(code_frame_provider.get()), read_cb);
+    base::OnceClosure task = base::BindOnce(
+        &CodedFrameProvider::Read, base::Unretained(code_frame_provider.get()),
+        std::move(read_cb));
 
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, task);
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, std::move(task));
   }
 }
 
@@ -129,10 +129,9 @@ void MultiDemuxerStreamAdaptersTest::OnNewFrame(
   }
 
   frame_received_count_++;
-  auto read_cb = base::Bind(&MultiDemuxerStreamAdaptersTest::OnNewFrame,
-                            base::Unretained(this),
-                            frame_provider);
-  frame_provider->Read(read_cb);
+  auto read_cb = base::BindOnce(&MultiDemuxerStreamAdaptersTest::OnNewFrame,
+                                base::Unretained(this), frame_provider);
+  frame_provider->Read(std::move(read_cb));
 }
 
 void MultiDemuxerStreamAdaptersTest::OnEos() {

chromecast/media/cma/test/mock_frame_consumer.cc

@@ -37,8 +37,8 @@ void MockFrameConsumer::Configure(
   frame_generator_ = std::move(frame_generator);
 }
 
-void MockFrameConsumer::Start(const base::Closure& done_cb) {
-  done_cb_ = done_cb;
+void MockFrameConsumer::Start(base::OnceClosure done_cb) {
+  done_cb_ = std::move(done_cb);
 
   pattern_idx_ = 0;
 
@@ -51,22 +51,19 @@ void MockFrameConsumer::ReadFrame() {
   // Once all the frames have been read, flush the frame provider.
   if (frame_generator_->RemainingFrameCount() == 0 &&
       !last_read_aborted_by_flush_) {
-    coded_frame_provider_->Flush(
-        base::Bind(&MockFrameConsumer::OnFlushCompleted,
-                   base::Unretained(this)));
+    coded_frame_provider_->Flush(base::BindOnce(
+        &MockFrameConsumer::OnFlushCompleted, base::Unretained(this)));
     return;
   }
 
   coded_frame_provider_->Read(
-      base::Bind(&MockFrameConsumer::OnNewFrame,
-                 base::Unretained(this)));
+      base::BindOnce(&MockFrameConsumer::OnNewFrame, base::Unretained(this)));
 
   // The last read is right away aborted by a Flush.
   if (frame_generator_->RemainingFrameCount() == 0 &&
       last_read_aborted_by_flush_) {
-    coded_frame_provider_->Flush(
-        base::Bind(&MockFrameConsumer::OnFlushCompleted,
-                   base::Unretained(this)));
+    coded_frame_provider_->Flush(base::BindOnce(
+        &MockFrameConsumer::OnFlushCompleted, base::Unretained(this)));
     return;
   }
 }
@@ -108,7 +105,7 @@ void MockFrameConsumer::OnNewFrame(
 
 void MockFrameConsumer::OnFlushCompleted() {
   EXPECT_EQ(frame_generator_->RemainingFrameCount(), 0u);
-  done_cb_.Run();
+  std::move(done_cb_).Run();
 }
 
 }  // namespace media

chromecast/media/cma/test/mock_frame_consumer.h

@@ -35,7 +35,7 @@ class MockFrameConsumer {
 
   // Starts consuming frames. Invoke |done_cb| when all the expected frames
   // have been received.
-  void Start(const base::Closure& done_cb);
+  void Start(base::OnceClosure done_cb);
 
  private:
   void ReadFrame();
@@ -47,7 +47,7 @@ class MockFrameConsumer {
 
   CodedFrameProvider* const coded_frame_provider_;
 
-  base::Closure done_cb_;
+  base::OnceClosure done_cb_;
 
   // Parameterization of the frame consumer:
   // |delayed_task_pattern_| indicates the pattern for fetching frames,

chromecast/media/cma/test/mock_frame_provider.cc

@@ -41,7 +41,7 @@ void MockFrameProvider::SetDelayFlush(bool delay_flush) {
   delay_flush_ = delay_flush;
 }
 
-void MockFrameProvider::Read(const ReadCB& read_cb) {
+void MockFrameProvider::Read(ReadCB read_cb) {
   bool delayed = delayed_task_pattern_[pattern_idx_];
   pattern_idx_ = (pattern_idx_ + 1) % delayed_task_pattern_.size();
 
@@ -49,25 +49,25 @@ void MockFrameProvider::Read(const ReadCB& read_cb) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::BindOnce(&MockFrameProvider::DoRead, base::Unretained(this),
-                       read_cb),
+                       std::move(read_cb)),
         base::TimeDelta::FromMilliseconds(1));
   } else {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::BindOnce(&MockFrameProvider::DoRead,
-                                  base::Unretained(this), read_cb));
+                                  base::Unretained(this), std::move(read_cb)));
   }
 }
 
-void MockFrameProvider::Flush(const base::Closure& flush_cb) {
+void MockFrameProvider::Flush(base::OnceClosure flush_cb) {
   if (delay_flush_) {
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE, flush_cb, base::TimeDelta::FromMilliseconds(10));
+        FROM_HERE, std::move(flush_cb), base::TimeDelta::FromMilliseconds(10));
   } else {
-    flush_cb.Run();
+    std::move(flush_cb).Run();
   }
 }
 
-void MockFrameProvider::DoRead(const ReadCB& read_cb) {
+void MockFrameProvider::DoRead(ReadCB read_cb) {
   bool has_config = frame_generator_->HasDecoderConfig();
 
   scoped_refptr<DecoderBufferBase> buffer(frame_generator_->Generate());
@@ -92,7 +92,7 @@ void MockFrameProvider::DoRead(const ReadCB& read_cb) {
         ::media::EncryptionScheme::kUnencrypted);
   }
 
-  read_cb.Run(buffer, audio_config, video_config);
+  std::move(read_cb).Run(buffer, audio_config, video_config);
 }
 
 }  // namespace media

chromecast/media/cma/test/mock_frame_provider.h

@@ -27,11 +27,11 @@ class MockFrameProvider : public CodedFrameProvider {
   void SetDelayFlush(bool delay_flush);
 
   // CodedFrameProvider implementation.
-  void Read(const ReadCB& read_cb) override;
-  void Flush(const base::Closure& flush_cb) override;
+  void Read(ReadCB read_cb) override;
+  void Flush(base::OnceClosure flush_cb) override;
 
  private:
-  void DoRead(const ReadCB& read_cb);
+  void DoRead(ReadCB read_cb);
 
   // Parameterization of the frame provider.
   // |delayed_task_pattern_| indicates the pattern for delivering frames,