Finish plumbing MojoVideoDecoder.

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 "media/base/decoder_buffer.h"
+#include "media/base/video_decoder.h"
+#include "media/base/video_decoder_config.h"
+#include "media/mojo/common/media_type_converters.h"
+#include "media/mojo/services/mojo_media_client.h"
+
+namespace media {
+
+MojoVideoDecoderService::MojoVideoDecoderService(
+    mojo::InterfaceRequest<interfaces::VideoDecoder> request,
+    MojoMediaClient* mojo_media_client)
+    : binding_(this, std::move(request)),
+      mojo_media_client_(mojo_media_client),
+      weak_factory_(this) {
+  weak_this_ = weak_factory_.GetWeakPtr();
+}
+
+MojoVideoDecoderService::~MojoVideoDecoderService() {}
+
+void MojoVideoDecoderService::Initialize(
+    interfaces::VideoDecoderClientPtr client,
+    mojo::ScopedDataPipeConsumerHandle decoder_buffer_consumer) {
+  DVLOG(1) << __FUNCTION__;
+  CHECK(!decoder_);
+
+  // TODO(sandersd): Handle nullptr (by killing the connection).
+  decoder_ = mojo_media_client_->CreateVideoDecoder();
+
+  client_ = std::move(client);
+  decoder_buffer_consumer_ = std::move(decoder_buffer_consumer);
+}
+
+void MojoVideoDecoderService::Configure(
+    interfaces::VideoDecoderConfigPtr config,
+    bool low_delay,
+    const ConfigureCallback& callback) {
+  DVLOG(1) << __FUNCTION__;
+  CHECK(decoder_);
+
+  VideoDecoderConfig media_config = config.To<VideoDecoderConfig>();
+
+  // decoder_->Initialize(media_config, low_delay, nullptr, ?, ?)
+  callback.Run();
+}
+
+void MojoVideoDecoderService::Decode(interfaces::DecoderBufferPtr buffer,
+                                     const DecodeCallback& callback) {
+  DVLOG(1) << __FUNCTION__;
+  CHECK(decoder_);
+
+  scoped_refptr<DecoderBuffer> media_buffer(
+      buffer.To<scoped_refptr<DecoderBuffer>>());
+  if (!media_buffer->end_of_stream()) {
+    MojoHandleSignalsState state;
+    CHECK_EQ(
+        MojoWait(decoder_buffer_consumer_.get().value(),
+                 MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, &state),
+        MOJO_RESULT_OK);
+    CHECK_EQ(state.satisfied_signals, MOJO_HANDLE_SIGNAL_READABLE);
+    uint32_t data_size =
+        base::checked_cast<uint32_t>(media_buffer->data_size());
+    DCHECK_GT(data_size, 0u);
+    uint32_t bytes_read = data_size;
+    CHECK_EQ(ReadDataRaw(decoder_buffer_consumer_.get(),
+                         media_buffer->writable_data(), &bytes_read,
+                         MOJO_READ_DATA_FLAG_ALL_OR_NONE),
+             MOJO_RESULT_OK);
+    CHECK_EQ(bytes_read, data_size);
+  }
+
+  // decoder_->Decode(media_buffer, ?);
+  callback.Run(interfaces::DecodeStatus::OK);
+}
+
+void MojoVideoDecoderService::Reset(const ResetCallback& callback) {
+  DVLOG(1) << __FUNCTION__;
+  CHECK(decoder_);
+  // decoder_->Reset(?);
+  callback.Run();
+}
+
+}  // namespace media