Finish plumbing MojoVideoDecoder.

media/mojo/common/media_type_converters.cc

 // Copyright 2014 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/common/media_type_converters.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/buffering_state.h"
 #include "media/base/cdm_config.h"
 #include "media/base/cdm_key_information.h"
+#include "media/base/decode_status.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/decryptor.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/encryption_scheme.h"
 #include "media/base/media_keys.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/mojo/common/mojo_shared_buffer_video_frame.h"
 #include "media/mojo/interfaces/demuxer_stream.mojom.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/public/cpp/system/buffer.h"
 
 namespace mojo {
 
 #define ASSERT_ENUM_EQ(media_enum, media_prefix, mojo_prefix, value)        \
   static_assert(media::media_prefix##value ==                               \
                     static_cast<media::media_enum>(                         \
                         media::mojom::media_enum::mojo_prefix##value),      \
                 "Mismatched enum: " #media_prefix #value " != " #media_enum \
                 "::" #mojo_prefix #value)
 
 #define ASSERT_ENUM_EQ_RAW(media_enum, media_enum_value, mojo_enum_value)      \
   static_assert(media::media_enum_value == static_cast<media::media_enum>(     \
                                                media::mojom::mojo_enum_value), \
                 "Mismatched enum: " #media_enum_value " != " #mojo_enum_value)
 
+#define ASSERT_ENUM_CLASS_EQ(media_enum, value)                            \
+  static_assert(                                                           \
+      media::media_enum::value ==                                          \
+          static_cast<media::media_enum>(media::mojom::media_enum::value), \
+      "Mismatched enum: " #media_enum #value)
+
 // BufferingState.
 ASSERT_ENUM_EQ(BufferingState, BUFFERING_, , HAVE_NOTHING);
 ASSERT_ENUM_EQ(BufferingState, BUFFERING_, , HAVE_ENOUGH);
 
+// DecodeStatus.
+ASSERT_ENUM_CLASS_EQ(DecodeStatus, OK);
+ASSERT_ENUM_CLASS_EQ(DecodeStatus, ABORTED);
+ASSERT_ENUM_CLASS_EQ(DecodeStatus, DECODE_ERROR);
+
 // AudioCodec.
 ASSERT_ENUM_EQ_RAW(AudioCodec, kUnknownAudioCodec, AudioCodec::UNKNOWN);
 ASSERT_ENUM_EQ(AudioCodec, kCodec, , AAC);
 ASSERT_ENUM_EQ(AudioCodec, kCodec, , MP3);
 ASSERT_ENUM_EQ(AudioCodec, kCodec, , PCM);
 ASSERT_ENUM_EQ(AudioCodec, kCodec, , Vorbis);
 ASSERT_ENUM_EQ(AudioCodec, kCodec, , FLAC);
 ASSERT_ENUM_EQ(AudioCodec, kCodec, , AMR_NB);
 ASSERT_ENUM_EQ(AudioCodec, kCodec, , PCM_MULAW);
 ASSERT_ENUM_EQ(AudioCodec, kCodec, , GSM_MS);
@@ skipping 362 matching lines @@
 
   media::mojom::DecoderBufferPtr mojo_buffer(
       media::mojom::DecoderBuffer::New());
   if (input->end_of_stream())
     return mojo_buffer;
 
   mojo_buffer->timestamp_usec = input->timestamp().InMicroseconds();
   mojo_buffer->duration_usec = input->duration().InMicroseconds();
   mojo_buffer->is_key_frame = input->is_key_frame();
   mojo_buffer->data_size = base::checked_cast<uint32_t>(input->data_size());
-  mojo_buffer->side_data_size =
-      base::checked_cast<uint32_t>(input->side_data_size());

[dcheng, 2016/05/20 21:18:22]

Can we wholly remove this field from the mojom in this patch?

[sandersd (OOO until July 31), 2016/05/20 22:27:14]

I already did that; was this comment intended for a different field?

[dcheng, 2016/05/20 22:52:59]

Oops, I missed that.

   mojo_buffer->front_discard_usec =
       input->discard_padding().first.InMicroseconds();
   mojo_buffer->back_discard_usec =
       input->discard_padding().second.InMicroseconds();
   mojo_buffer->splice_timestamp_usec =
       input->splice_timestamp().InMicroseconds();
 
   // Note: The side data is always small, so this copy is okay.
   std::vector<uint8_t> side_data(input->side_data(),
                                  input->side_data() + input->side_data_size());
@@ skipping 14 matching lines @@
 // static
 scoped_refptr<media::DecoderBuffer>
 TypeConverter<scoped_refptr<media::DecoderBuffer>,
               media::mojom::DecoderBufferPtr>::
     Convert(const media::mojom::DecoderBufferPtr& input) {
   if (!input->data_size)
     return media::DecoderBuffer::CreateEOSBuffer();
 
   scoped_refptr<media::DecoderBuffer> buffer(
       new media::DecoderBuffer(input->data_size));
-  if (input->side_data_size)
-    buffer->CopySideDataFrom(&input->side_data.front(), input->side_data_size);
+
+  buffer->CopySideDataFrom(&input->side_data.front(), input->side_data.size());

[dcheng, 2016/05/20 21:18:22]

Existing semantics don't copy this data if it's zero-length, having a
zero-length side data won't be a problem, right?

[sandersd (OOO until July 31), 2016/05/20 22:27:14]

That's correct, the media::DecoderBuffer structure doesn't distinguish between
no side data and zero-length side data.

 
   buffer->set_timestamp(
       base::TimeDelta::FromMicroseconds(input->timestamp_usec));
   buffer->set_duration(base::TimeDelta::FromMicroseconds(input->duration_usec));
 
   if (input->is_key_frame)
     buffer->set_is_key_frame(true);
 
   if (input->decrypt_config) {
     buffer->set_decrypt_config(
@@ skipping 235 matching lines @@
       input->natural_size.To<gfx::Size>(), std::move(input->frame_data),
       base::saturated_cast<size_t>(input->frame_data_size),
       base::saturated_cast<size_t>(input->y_offset),
       base::saturated_cast<size_t>(input->u_offset),
       base::saturated_cast<size_t>(input->v_offset), input->y_stride,
       input->u_stride, input->v_stride,
       base::TimeDelta::FromMicroseconds(input->timestamp_usec));
 }
 
 }  // namespace mojo