media: Add MojoDecoderBuffer{Reader|Writer}

media/mojo/clients/mojo_decryptor.cc

Index: media/mojo/clients/mojo_decryptor.cc
diff --git a/media/mojo/clients/mojo_decryptor.cc b/media/mojo/clients/mojo_decryptor.cc
index 25c8d943f387b935d14b12659d69fabc3afe290a..4aa09f4c41815f094edec155a92bfba69e5bb155 100644
--- a/media/mojo/clients/mojo_decryptor.cc
+++ b/media/mojo/clients/mojo_decryptor.cc
@@ -15,6 +15,7 @@
 #include "media/base/decoder_buffer.h"
 #include "media/base/video_frame.h"
 #include "media/mojo/common/media_type_converters.h"
+#include "media/mojo/common/mojo_decoder_buffer_converter.h"
 #include "media/mojo/common/mojo_shared_buffer_video_frame.h"
 #include "media/mojo/interfaces/decryptor.mojom.h"
 #include "services/shell/public/cpp/connect.h"
@@ -24,7 +25,20 @@ namespace media {
 MojoDecryptor::MojoDecryptor(mojom::DecryptorPtr remote_decryptor)
     : remote_decryptor_(std::move(remote_decryptor)), weak_factory_(this) {
   DVLOG(1) << __FUNCTION__;
-  CreateDataPipes();
+
+  // Allocate DataPipe size based on video content.
+
+  mojo::ScopedDataPipeConsumerHandle remote_consumer_handle;
+  mojo_decoder_buffer_writer_ = MojoDecoderBufferWriter::Create(
+      DemuxerStream::VIDEO, &remote_consumer_handle);
+
+  mojo::ScopedDataPipeProducerHandle remote_producer_handle;
+  mojo_decoder_buffer_reader_ = MojoDecoderBufferReader::Create(
+      DemuxerStream::VIDEO, &remote_producer_handle);
+
+  // Pass the other end of each pipe to |remote_decryptor_|.
+  remote_decryptor_->Initialize(std::move(remote_consumer_handle),
+                                std::move(remote_producer_handle));
 }
 
 MojoDecryptor::~MojoDecryptor() {
@@ -53,9 +67,16 @@ void MojoDecryptor::Decrypt(StreamType stream_type,
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  mojom::DecoderBufferPtr mojo_buffer =
+      mojo_decoder_buffer_writer_->WriteDecoderBuffer(encrypted);
+  if (!mojo_buffer) {
+    decrypt_cb.Run(kError, nullptr);
+    return;
+  }
+
   remote_decryptor_->Decrypt(
       static_cast<mojom::DemuxerStream::Type>(stream_type),
-      TransferDecoderBuffer(encrypted),
+      std::move(mojo_buffer),
       base::Bind(&MojoDecryptor::OnBufferDecrypted, weak_factory_.GetWeakPtr(),
                  decrypt_cb));
 }
@@ -92,8 +113,15 @@ void MojoDecryptor::DecryptAndDecodeAudio(
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  mojom::DecoderBufferPtr mojo_buffer =
+      mojo_decoder_buffer_writer_->WriteDecoderBuffer(encrypted);
+  if (!mojo_buffer) {
+    audio_decode_cb.Run(kError, AudioFrames());
+    return;
+  }
+
   remote_decryptor_->DecryptAndDecodeAudio(
-      TransferDecoderBuffer(encrypted),
+      std::move(mojo_buffer),
       base::Bind(&MojoDecryptor::OnAudioDecoded, weak_factory_.GetWeakPtr(),
                  audio_decode_cb));
 }
@@ -104,8 +132,15 @@ void MojoDecryptor::DecryptAndDecodeVideo(
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  mojom::DecoderBufferPtr mojo_buffer =
+      mojo_decoder_buffer_writer_->WriteDecoderBuffer(encrypted);
+  if (!mojo_buffer) {
+    video_decode_cb.Run(kError, nullptr);
+    return;
+  }
+
   remote_decryptor_->DecryptAndDecodeVideo(
-      TransferDecoderBuffer(encrypted),
+      std::move(mojo_buffer),
       base::Bind(&MojoDecryptor::OnVideoDecoded, weak_factory_.GetWeakPtr(),
                  video_decode_cb));
 }
@@ -150,8 +185,14 @@ void MojoDecryptor::OnBufferDecrypted(const DecryptCB& decrypt_cb,
     return;
   }
 
-  decrypt_cb.Run(static_cast<Decryptor::Status>(status),
-                 ReadDecoderBuffer(std::move(buffer)));
+  scoped_refptr<DecoderBuffer> media_buffer =
+      mojo_decoder_buffer_reader_->ReadDecoderBuffer(buffer);
+  if (!media_buffer) {
+    decrypt_cb.Run(kError, nullptr);
+    return;
+  }
+
+  decrypt_cb.Run(static_cast<Decryptor::Status>(status), media_buffer);
 }
 
 void MojoDecryptor::OnAudioDecoded(
@@ -205,67 +246,4 @@ void MojoDecryptor::ReleaseSharedBuffer(mojo::ScopedSharedBufferHandle buffer,
   remote_decryptor_->ReleaseSharedBuffer(std::move(buffer), buffer_size);
 }
 
-void MojoDecryptor::CreateDataPipes() {
-  // Allocate DataPipe size based on video content. Video can get quite large;
-  // at 4K, VP9 delivers packets which are ~1MB in size; so allow for 50%
-  // headroom.
-  MojoCreateDataPipeOptions options;
-  options.struct_size = sizeof(MojoCreateDataPipeOptions);
-  options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
-  options.element_num_bytes = 1;
-  options.capacity_num_bytes = 1.5 * (1024 * 1024);
-
-  // Create 2 pipes, one for each direction.
-  mojo::DataPipe write_pipe(options);
-  mojo::DataPipe read_pipe(options);
-
-  // Keep one end of each pipe.
-  producer_handle_ = std::move(write_pipe.producer_handle);
-  consumer_handle_ = std::move(read_pipe.consumer_handle);
-
-  // Pass the other end of each pipe to |remote_decryptor_|.
-  remote_decryptor_->Initialize(std::move(write_pipe.consumer_handle),
-                                std::move(read_pipe.producer_handle));
-}
-
-mojom::DecoderBufferPtr MojoDecryptor::TransferDecoderBuffer(
-    const scoped_refptr<DecoderBuffer>& encrypted) {
-  mojom::DecoderBufferPtr buffer = mojom::DecoderBuffer::From(encrypted);
-  if (encrypted->end_of_stream())
-    return buffer;
-
-  // Serialize the data section of the DecoderBuffer into our pipe.
-  uint32_t num_bytes = base::checked_cast<uint32_t>(encrypted->data_size());
-  DCHECK_GT(num_bytes, 0u);
-  CHECK_EQ(WriteDataRaw(producer_handle_.get(), encrypted->data(), &num_bytes,
-                        MOJO_READ_DATA_FLAG_ALL_OR_NONE),
-           MOJO_RESULT_OK);
-  CHECK_EQ(num_bytes, static_cast<uint32_t>(encrypted->data_size()));
-  return buffer;
-}
-
-scoped_refptr<DecoderBuffer> MojoDecryptor::ReadDecoderBuffer(
-    mojom::DecoderBufferPtr buffer) {
-  scoped_refptr<DecoderBuffer> media_buffer(
-      buffer.To<scoped_refptr<DecoderBuffer>>());
-  if (media_buffer->end_of_stream())
-    return media_buffer;
-
-  // Wait for the data to become available in the DataPipe.
-  MojoHandleSignalsState state;
-  CHECK_EQ(MOJO_RESULT_OK,
-           MojoWait(consumer_handle_.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
-                    MOJO_DEADLINE_INDEFINITE, &state));
-  CHECK_EQ(MOJO_HANDLE_SIGNAL_READABLE, state.satisfied_signals);
-
-  // Read the inner data for the DecoderBuffer from our DataPipe.
-  uint32_t num_bytes = base::checked_cast<uint32_t>(media_buffer->data_size());
-  DCHECK_GT(num_bytes, 0u);
-  CHECK_EQ(ReadDataRaw(consumer_handle_.get(), media_buffer->writable_data(),
-                       &num_bytes, MOJO_READ_DATA_FLAG_ALL_OR_NONE),
-           MOJO_RESULT_OK);
-  CHECK_EQ(num_bytes, static_cast<uint32_t>(media_buffer->data_size()));
-  return media_buffer;
-}
-
 }  // namespace media