[Cast] Use the PushBufferQueue

This CL adds the PushBufferQueue as introduced in
https://chromium-review.googlesource.com/c/chromium/src/+/2509338 to the
ProxyCallTranslator, as defined in
https://chromium-review.googlesource.com/c/chromium/src/+/2519156

Change-Id: I35c1e6c686476b428a12ab500d48bbca223701f4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2581138Reviewed-by: Yuchen Liu <yucliu@chromium.org>
Commit-Queue: Ryan Keane <rwkeane@google.com>
Cr-Commit-Position: refs/heads/master@{#835985}

chromecast/media/cma/backend/proxy/cast_runtime_audio_channel_broker.h

@@ -8,6 +8,7 @@
 #include <memory>
 
 #include "base/memory/weak_ptr.h"
+#include "base/optional.h"
 #include "third_party/openscreen/src/cast/cast_core/api/runtime/cast_audio_decoder_service.pb.h"
 
 namespace chromecast {
@@ -66,7 +67,7 @@ class CastRuntimeAudioChannelBroker {
 
     // Returns a PushBufferRequest to be sent across the |PushBuffer| RPC. May
     // only be called if |HasBufferedData()| is true.
-    virtual PushBufferRequest GetBufferedData() = 0;
+    virtual base::Optional<PushBufferRequest> GetBufferedData() = 0;
     virtual bool HasBufferedData() = 0;
 
     // Handlers for the responses of the messages defined in

chromecast/media/cma/backend/proxy/proxy_call_translator.cc

@@ -143,9 +143,12 @@ cast::media::CastAudioDecoderMode ToGrpcTypes(
 CastRuntimeAudioChannelBroker::Handler::PushBufferRequest ToGrpcTypes(
     scoped_refptr<DecoderBufferBase> buffer) {
   auto* decode_buffer = new cast::media::AudioDecoderBuffer;
+
+  decode_buffer->set_end_of_stream(buffer->end_of_stream());
+  if (!buffer->end_of_stream()) {
     decode_buffer->set_pts_micros(buffer->timestamp());
     decode_buffer->set_data(buffer->data(), buffer->data_size());
-  decode_buffer->set_end_of_stream(buffer->end_of_stream());
+  }
 
   CastRuntimeAudioChannelBroker::Handler::PushBufferRequest request;
 
@@ -257,29 +260,20 @@ void ProxyCallTranslator::SetVolume(float multiplier) {
 }
 
 bool ProxyCallTranslator::SetConfig(const AudioConfig& config) {
-  return ProcessPushBufferRequest(ToGrpcTypes(config));
+  return push_buffer_queue_.PushBuffer(ToGrpcTypes(config));
 }
 
 bool ProxyCallTranslator::PushBuffer(scoped_refptr<DecoderBufferBase> buffer) {
-  return ProcessPushBufferRequest(ToGrpcTypes(std::move(buffer)));
+  return push_buffer_queue_.PushBuffer(ToGrpcTypes(std::move(buffer)));
 }
 
-bool ProxyCallTranslator::ProcessPushBufferRequest(PushBufferRequest request) {
-  // TODO(rwkeane)
-  NOTIMPLEMENTED();
-  return false;
-}
-
-ProxyCallTranslator::PushBufferRequest ProxyCallTranslator::GetBufferedData() {
-  // TODO(rwkeane)
-  NOTIMPLEMENTED();
-  return PushBufferRequest{};
+base::Optional<ProxyCallTranslator::PushBufferRequest>
+ProxyCallTranslator::GetBufferedData() {
+  return push_buffer_queue_.GetBufferedData();
 }
 
 bool ProxyCallTranslator::HasBufferedData() {
-  // TODO(rwkeane)
-  NOTIMPLEMENTED();
-  return false;
+  return push_buffer_queue_.HasBufferedData();
 }
 
 void ProxyCallTranslator::HandleInitializeResponse(

chromecast/media/cma/backend/proxy/proxy_call_translator.h

@@ -12,6 +12,7 @@
 #include "chromecast/media/api/decoder_buffer_base.h"
 #include "chromecast/media/cma/backend/proxy/cast_runtime_audio_channel_broker.h"
 #include "chromecast/media/cma/backend/proxy/cma_proxy_handler.h"
+#include "chromecast/media/cma/backend/proxy/push_buffer_queue.h"
 
 namespace chromecast {
 
@@ -61,7 +62,7 @@ class ProxyCallTranslator : public CmaProxyHandler,
       std::unique_ptr<CastRuntimeAudioChannelBroker> decoder_channel);
 
   // CastRuntimeAudioChannelBroker::Handler overrides:
-  PushBufferRequest GetBufferedData() override;
+  base::Optional<PushBufferRequest> GetBufferedData() override;
   bool HasBufferedData() override;
   void HandleInitializeResponse(
       CastRuntimeAudioChannelBroker::StatusCode status) override;
@@ -79,8 +80,6 @@ class ProxyCallTranslator : public CmaProxyHandler,
       base::Optional<MediaTime> time,
       CastRuntimeAudioChannelBroker::StatusCode status) override;
 
-  bool ProcessPushBufferRequest(PushBufferRequest request);
-
   // Helper to share error handling code.
   bool HandleError(CastRuntimeAudioChannelBroker::StatusCode status);
 
@@ -90,6 +89,9 @@ class ProxyCallTranslator : public CmaProxyHandler,
   void OnPipelineStateChangeTask(CmaProxyHandler::PipelineState state);
   void OnBytesDecodedTask(int64_t decoded_byte_count);
 
+  // Queue storing data from PushBuffer and SetConfig calls.
+  PushBufferQueue push_buffer_queue_;
+
   std::unique_ptr<CastRuntimeAudioChannelBroker> decoder_channel_;
   TaskRunner* const client_task_runner_;
   CmaProxyHandler::Client* const client_;

chromecast/media/cma/backend/proxy/proxy_call_translator_unittest.cc

@@ -9,8 +9,11 @@
 #include "base/memory/scoped_refptr.h"
 #include "base/test/test_simple_task_runner.h"
 #include "chromecast/base/task_runner_impl.h"
+#include "chromecast/media/base/cast_decoder_buffer_impl.h"
 #include "chromecast/media/cma/backend/proxy/cast_runtime_audio_channel_broker.h"
 #include "chromecast/media/cma/backend/proxy/cma_proxy_handler.h"
+#include "chromecast/public/media/decoder_config.h"
+#include "chromecast/public/media/stream_id.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -139,6 +142,78 @@ TEST_F(ProxyCallTranslatorTest, TestExternalSetVolume) {
   translator_.SetVolume(multiplier);
 }
 
+TEST_F(ProxyCallTranslatorTest, TestExternalPushBuffer) {
+  scoped_refptr<CastDecoderBufferImpl> buffer(
+      new CastDecoderBufferImpl(3, StreamId::kPrimary));
+  buffer->writable_data()[0] = 1;
+  buffer->writable_data()[1] = 2;
+  buffer->writable_data()[2] = 3;
+  EXPECT_TRUE(translator_.PushBuffer(buffer));
+
+  EXPECT_TRUE(translator_.PushBuffer(CastDecoderBufferImpl::CreateEOSBuffer()));
+
+  ASSERT_TRUE(translator_as_handler_->HasBufferedData());
+  auto result = translator_as_handler_->GetBufferedData();
+  ASSERT_TRUE(result.has_value());
+  EXPECT_FALSE(result.value().has_audio_config());
+  ASSERT_TRUE(result.value().has_buffer());
+  EXPECT_FALSE(result.value().buffer().end_of_stream());
+  EXPECT_EQ(result.value().buffer().data().size(), size_t{3});
+  EXPECT_EQ(result.value().buffer().data()[0], 1);
+  EXPECT_EQ(result.value().buffer().data()[1], 2);
+  EXPECT_EQ(result.value().buffer().data()[2], 3);
+
+  ASSERT_TRUE(translator_as_handler_->HasBufferedData());
+  result = translator_as_handler_->GetBufferedData();
+  ASSERT_TRUE(result.has_value());
+  EXPECT_FALSE(result.value().has_audio_config());
+  ASSERT_TRUE(result.value().has_buffer());
+  EXPECT_TRUE(result.value().buffer().end_of_stream());
+  EXPECT_EQ(result.value().buffer().data().size(), size_t{0});
+}
+
+TEST_F(ProxyCallTranslatorTest, TestExternalSetConfig) {
+  AudioConfig config;
+  config.codec = AudioCodec::kCodecPCM;
+  config.channel_layout = ChannelLayout::SURROUND_5_1;
+  config.sample_format = SampleFormat::kSampleFormatPlanarS16;
+  config.bytes_per_channel = 42;
+  config.channel_number = 5;
+  config.samples_per_second = 5000;
+  config.extra_data = {1, 2, 3};
+  config.encryption_scheme = EncryptionScheme::kUnencrypted;
+
+  EXPECT_TRUE(translator_.SetConfig(config));
+
+  ASSERT_TRUE(translator_as_handler_->HasBufferedData());
+  auto result = translator_as_handler_->GetBufferedData();
+  ASSERT_TRUE(result.has_value());
+  EXPECT_FALSE(result.value().has_buffer());
+  ASSERT_TRUE(result.value().has_audio_config());
+  EXPECT_EQ(result.value().audio_config().codec(),
+            cast::media::AudioConfiguration_AudioCodec_AUDIO_CODEC_PCM);
+  EXPECT_EQ(result.value().audio_config().channel_layout(),
+            cast::media::
+                AudioConfiguration_ChannelLayout_CHANNEL_LAYOUT_SURROUND_5_1);
+  EXPECT_EQ(
+      result.value().audio_config().sample_format(),
+      cast::media::AudioConfiguration_SampleFormat_SAMPLE_FORMAT_PLANAR_S16);
+  EXPECT_EQ(result.value().audio_config().bytes_per_channel(),
+            config.bytes_per_channel);
+  EXPECT_EQ(result.value().audio_config().channel_number(),
+            config.channel_number);
+  EXPECT_EQ(result.value().audio_config().samples_per_second(),
+            config.samples_per_second);
+  EXPECT_EQ(result.value().audio_config().extra_data().size(),
+            config.extra_data.size());
+  EXPECT_EQ(result.value().audio_config().extra_data()[0],
+            config.extra_data[0]);
+  EXPECT_EQ(result.value().audio_config().extra_data()[1],
+            config.extra_data[1]);
+  EXPECT_EQ(result.value().audio_config().extra_data()[2],
+            config.extra_data[2]);
+}
+
 TEST_F(ProxyCallTranslatorTest, TestInternalHandleInitializeFailure) {
   EXPECT_CALL(translator_client_, OnError());
   translator_as_handler_->HandleInitializeResponse(failure_status_);