media: Add MojoDecoderBuffer{Reader|Writer}

media/mojo/services/mojo_video_decoder_service.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/mojo/services/mojo_video_decoder_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_decoder_config.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/services/mojo_media_client.h"
 #include "mojo/public/c/system/types.h"
 #include "mojo/public/cpp/system/buffer.h"
 #include "mojo/public/cpp/system/handle.h"
 
 namespace media {
 
 MojoVideoDecoderService::MojoVideoDecoderService(
     mojo::InterfaceRequest<mojom::VideoDecoder> request,
     MojoMediaClient* mojo_media_client)
@@ skipping 11 matching lines @@
   DVLOG(1) << __FUNCTION__;
 
   if (decoder_)
     return;
 
   // TODO(sandersd): Provide callback for requesting a stub.
   decoder_ = mojo_media_client_->CreateVideoDecoder(
       base::ThreadTaskRunnerHandle::Get());
 
   client_ = std::move(client);
-  decoder_buffer_pipe_ = std::move(decoder_buffer_pipe);
+
+  mojo_decoder_buffer_reader_.reset(
+      new MojoDecoderBufferReader(std::move(decoder_buffer_pipe)));
 }
 
 void MojoVideoDecoderService::Initialize(mojom::VideoDecoderConfigPtr config,
                                          bool low_delay,
                                          const InitializeCallback& callback) {
   DVLOG(1) << __FUNCTION__;
 
   if (!decoder_) {
     callback.Run(false);
     return;
@@ skipping 24 matching lines @@
                                      const DecodeCallback& callback) {
   DVLOG(1) << __FUNCTION__;
 
   if (!decoder_) {
     callback.Run(mojom::DecodeStatus::DECODE_ERROR);
     return;
   }
 
   // TODO(sandersd): After a decode error, we should enter an error state and
   // reject all future method calls.
-  // TODO(sandersd): Extract and share with MojoAudioDecoderService.
-  scoped_refptr<DecoderBuffer> media_buffer(
-      buffer.To<scoped_refptr<DecoderBuffer>>());
-  if (!media_buffer->end_of_stream()) {
-    MojoResult result;
-    MojoHandleSignalsState state;
-
-    // TODO(sandersd): Do not wait indefinitely.
-    result =
-        MojoWait(decoder_buffer_pipe_.get().value(),
-                 MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, &state);
-    if (result != MOJO_RESULT_OK ||
-        !(state.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)) {
-      callback.Run(mojom::DecodeStatus::DECODE_ERROR);
-      return;
-    }
-
-    uint32_t data_size = buffer->data_size;
-    uint32_t bytes_read = data_size;
-    DCHECK_EQ(data_size, media_buffer->data_size());
-    result =
-        ReadDataRaw(decoder_buffer_pipe_.get(), media_buffer->writable_data(),
-                    &bytes_read, MOJO_READ_DATA_FLAG_ALL_OR_NONE);
-    if (result != MOJO_RESULT_OK || bytes_read != data_size) {
-      callback.Run(mojom::DecodeStatus::DECODE_ERROR);
-      return;
-    }
+  scoped_refptr<DecoderBuffer> media_buffer =
+      mojo_decoder_buffer_reader_->ReadDecoderBuffer(buffer);
+  if (!media_buffer) {
+    callback.Run(mojom::DecodeStatus::DECODE_ERROR);
+    return;
   }
 
   decoder_->Decode(media_buffer,
                    base::Bind(&MojoVideoDecoderService::OnDecoderDecoded,
                               weak_this_, callback));
 }
 
 void MojoVideoDecoderService::OnDecoderDecoded(const DecodeCallback& callback,
                                                DecodeStatus status) {
   DVLOG(1) << __FUNCTION__;
@@ skipping 11 matching lines @@
   decoder_->Reset(base::Bind(&MojoVideoDecoderService::OnDecoderReset,
                              weak_this_, callback));
 }
 
 void MojoVideoDecoderService::OnDecoderReset(const ResetCallback& callback) {
   DVLOG(1) << __FUNCTION__;
   callback.Run();
 }
 
 }  // namespace media