Define mojo type map for media::{Audio|Video}DecoderConfig

Also includes type mapping for media::EncryptionScheme.

Bug: 611224
Change-Id: I151aacd4ea2dfe9e02ff7c82c922bc5a982e1fd4
Reviewed-on: https://chromium-review.googlesource.com/544913Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Dan Sanders <sandersd@chromium.org>
Commit-Queue: Chrome Cunningham <chcunningham@chromium.org>
Cr-Commit-Position: refs/heads/master@{#485133}

media/base/test_helpers.cc

@@ -180,6 +180,12 @@ gfx::Size TestVideoConfig::LargeCodedSize() {
   return kLargeSize;
 }
 
+AudioDecoderConfig TestAudioConfig::Normal() {
+  return AudioDecoderConfig(kCodecVorbis, kSampleFormatPlanarF32,
+                            CHANNEL_LAYOUT_STEREO, 44100, EmptyExtraData(),
+                            Unencrypted());
+}
+
 // static
 AudioParameters TestAudioParameters::Normal() {
   return AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY,

media/base/test_helpers.h

@@ -101,6 +101,13 @@ class TestVideoConfig {
   DISALLOW_COPY_AND_ASSIGN(TestVideoConfig);
 };
 
+// Provides pre-canned AudioDecoderConfig. These types are used for tests that
+// don't care about detailed parameters of the config.
+class TestAudioConfig {
+ public:
+  static AudioDecoderConfig Normal();
+};
+
 // Provides pre-canned AudioParameters objects.
 class TestAudioParameters {
  public:

media/base/video_decoder_config.cc

@@ -53,7 +53,8 @@ VideoCodec VideoCodecProfileToVideoCodec(VideoCodecProfile profile) {
 VideoDecoderConfig::VideoDecoderConfig()
     : codec_(kUnknownVideoCodec),
       profile_(VIDEO_CODEC_PROFILE_UNKNOWN),
-      format_(PIXEL_FORMAT_UNKNOWN) {}
+      format_(PIXEL_FORMAT_UNKNOWN),
+      color_space_(COLOR_SPACE_UNSPECIFIED) {}
 
 VideoDecoderConfig::VideoDecoderConfig(
     VideoCodec codec,
@@ -79,7 +80,7 @@ void VideoDecoderConfig::set_color_space_info(
   color_space_info_ = color_space_info;
 }
 
-VideoColorSpace VideoDecoderConfig::color_space_info() const {
+const VideoColorSpace& VideoDecoderConfig::color_space_info() const {
   return color_space_info_;
 }
 
@@ -87,7 +88,7 @@ void VideoDecoderConfig::set_hdr_metadata(const HDRMetadata& hdr_metadata) {
   hdr_metadata_ = hdr_metadata;
 }
 
-base::Optional<HDRMetadata> VideoDecoderConfig::hdr_metadata() const {
+const base::Optional<HDRMetadata>& VideoDecoderConfig::hdr_metadata() const {
   return hdr_metadata_;
 }
 

media/base/video_decoder_config.h

@@ -89,14 +89,14 @@ class MEDIA_EXPORT VideoDecoderConfig {
   // Deprecated. TODO(wolenetz): Remove. See https://crbug.com/665539.
   // Width and height of video frame immediately post-decode. Not all pixels
   // in this region are valid.
-  gfx::Size coded_size() const { return coded_size_; }
+  const gfx::Size& coded_size() const { return coded_size_; }
 
   // Region of |coded_size_| that is visible.
-  gfx::Rect visible_rect() const { return visible_rect_; }
+  const gfx::Rect& visible_rect() const { return visible_rect_; }
 
   // Final visible width and height of a video frame with aspect ratio taken
   // into account.
-  gfx::Size natural_size() const { return natural_size_; }
+  const gfx::Size& natural_size() const { return natural_size_; }
 
   // Optional byte data required to initialize video decoders, such as H.264
   // AVCC data.
@@ -114,10 +114,10 @@ class MEDIA_EXPORT VideoDecoderConfig {
   }
 
   void set_color_space_info(const VideoColorSpace& color_space_info);
-  VideoColorSpace color_space_info() const;
+  const VideoColorSpace& color_space_info() const;
 
   void set_hdr_metadata(const HDRMetadata& hdr_metadata);
-  base::Optional<HDRMetadata> hdr_metadata() const;
+  const base::Optional<HDRMetadata>& hdr_metadata() const;
 
   // Sets the config to be encrypted or not encrypted manually. This can be
   // useful for decryptors that decrypts an encrypted stream to a clear stream.

media/mojo/BUILD.gn

@@ -74,6 +74,9 @@ source_set("unit_tests") {
     "common/media_type_converters_unittest.cc",
     "common/mojo_decoder_buffer_converter_unittest.cc",
     "common/mojo_shared_buffer_video_frame_unittest.cc",
+    "interfaces/audio_decoder_config_struct_traits_unittest.cc",
+    "interfaces/encryption_scheme_struct_traits_unittest.cc",
+    "interfaces/video_decoder_config_struct_traits_unittest.cc",
     "interfaces/video_frame_struct_traits_unittest.cc",
     "services/mojo_audio_output_stream_unittest.cc",
     "services/mojo_cdm_allocator_unittest.cc",

media/mojo/clients/mojo_audio_decoder.cc

@@ -70,7 +70,7 @@ void MojoAudioDecoder::Initialize(const AudioDecoderConfig& config,
   // Using base::Unretained(this) is safe because |this| owns |remote_decoder_|,
   // and the callback won't be dispatched if |remote_decoder_| is destroyed.
   remote_decoder_->Initialize(
-      mojom::AudioDecoderConfig::From(config), cdm_id,
+      config, cdm_id,
       base::Bind(&MojoAudioDecoder::OnInitialized, base::Unretained(this)));
 }
 

media/mojo/clients/mojo_decryptor.cc

@@ -102,8 +102,7 @@ void MojoDecryptor::InitializeAudioDecoder(const AudioDecoderConfig& config,
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  remote_decryptor_->InitializeAudioDecoder(
-      mojom::AudioDecoderConfig::From(config), init_cb);
+  remote_decryptor_->InitializeAudioDecoder(config, init_cb);
 }
 
 void MojoDecryptor::InitializeVideoDecoder(const VideoDecoderConfig& config,
@@ -111,8 +110,7 @@ void MojoDecryptor::InitializeVideoDecoder(const VideoDecoderConfig& config,
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  remote_decryptor_->InitializeVideoDecoder(
-      mojom::VideoDecoderConfig::From(config), init_cb);
+  remote_decryptor_->InitializeVideoDecoder(config, init_cb);
 }
 
 void MojoDecryptor::DecryptAndDecodeAudio(

media/mojo/clients/mojo_demuxer_stream_impl.cc

@@ -33,14 +33,12 @@ void MojoDemuxerStreamImpl::Initialize(const InitializeCallback& callback) {
   DVLOG(2) << __func__;
 
   // Prepare the initial config.
-  mojom::AudioDecoderConfigPtr audio_config;
-  mojom::VideoDecoderConfigPtr video_config;
+  base::Optional<AudioDecoderConfig> audio_config;
+  base::Optional<VideoDecoderConfig> video_config;
   if (stream_->type() == Type::AUDIO) {
-    audio_config =
-        mojom::AudioDecoderConfig::From(stream_->audio_decoder_config());
+    audio_config = stream_->audio_decoder_config();
   } else if (stream_->type() == Type::VIDEO) {
-    video_config =
-        mojom::VideoDecoderConfig::From(stream_->video_decoder_config());
+    video_config = stream_->video_decoder_config();
   } else {
     NOTREACHED() << "Unsupported stream type: " << stream_->type();
     return;
@@ -50,8 +48,8 @@ void MojoDemuxerStreamImpl::Initialize(const InitializeCallback& callback) {
   mojo_decoder_buffer_writer_ =
       MojoDecoderBufferWriter::Create(stream_->type(), &remote_consumer_handle);
 
-  callback.Run(stream_->type(), std::move(remote_consumer_handle),
-               std::move(audio_config), std::move(video_config));
+  callback.Run(stream_->type(), std::move(remote_consumer_handle), audio_config,
+               video_config);
 }
 
 void MojoDemuxerStreamImpl::Read(const ReadCallback& callback) {
@@ -67,32 +65,30 @@ void MojoDemuxerStreamImpl::OnBufferReady(
     const ReadCallback& callback,
     Status status,
     const scoped_refptr<media::DecoderBuffer>& buffer) {
-  mojom::AudioDecoderConfigPtr audio_config;
-  mojom::VideoDecoderConfigPtr video_config;
+  base::Optional<AudioDecoderConfig> audio_config;
+  base::Optional<VideoDecoderConfig> video_config;
 
   if (status == Status::kConfigChanged) {
     DVLOG(2) << __func__ << ": ConfigChange!";
     // Send the config change so our client can read it once it parses the
     // Status obtained via Run() below.
     if (stream_->type() == Type::AUDIO) {
-      audio_config =
-          mojom::AudioDecoderConfig::From(stream_->audio_decoder_config());
+      audio_config = stream_->audio_decoder_config();
     } else if (stream_->type() == Type::VIDEO) {
-      video_config =
-          mojom::VideoDecoderConfig::From(stream_->video_decoder_config());
+      video_config = stream_->video_decoder_config();
     } else {
       NOTREACHED() << "Unsupported config change encountered for type: "
                    << stream_->type();
     }
 
     callback.Run(Status::kConfigChanged, mojom::DecoderBufferPtr(),
-                 std::move(audio_config), std::move(video_config));
+                 audio_config, video_config);
     return;
   }
 
   if (status == Status::kAborted) {
-    callback.Run(Status::kAborted, mojom::DecoderBufferPtr(),
-                 std::move(audio_config), std::move(video_config));
+    callback.Run(Status::kAborted, mojom::DecoderBufferPtr(), audio_config,
+                 video_config);
     return;
   }
 
@@ -101,16 +97,15 @@ void MojoDemuxerStreamImpl::OnBufferReady(
   mojom::DecoderBufferPtr mojo_buffer =
       mojo_decoder_buffer_writer_->WriteDecoderBuffer(buffer);
   if (!mojo_buffer) {
-    callback.Run(Status::kAborted, mojom::DecoderBufferPtr(),
-                 std::move(audio_config), std::move(video_config));
+    callback.Run(Status::kAborted, mojom::DecoderBufferPtr(), audio_config,
+                 video_config);
     return;
   }
 
   // TODO(dalecurtis): Once we can write framed data to the DataPipe, fill via
   // the producer handle and then read more to keep the pipe full.  Waiting for
   // space can be accomplished using an AsyncWaiter.
-  callback.Run(status, std::move(mojo_buffer), std::move(audio_config),
-               std::move(video_config));
+  callback.Run(status, std::move(mojo_buffer), audio_config, video_config);
 }
 
 }  // namespace media

media/mojo/clients/mojo_renderer_unittest.cc

@@ -105,6 +105,7 @@ class MojoRendererTest : public ::testing::Test {
 
   void CreateAudioStream() {
     audio_stream_ = CreateStream(DemuxerStream::AUDIO);
+    audio_stream_->set_audio_decoder_config(TestAudioConfig::Normal());
     streams_.push_back(audio_stream_.get());
     EXPECT_CALL(demuxer_, GetAllStreams()).WillRepeatedly(Return(streams_));
   }

media/mojo/clients/mojo_video_decoder.cc

@@ -70,7 +70,7 @@ void MojoVideoDecoder::Initialize(const VideoDecoderConfig& config,
   init_cb_ = init_cb;
   output_cb_ = output_cb;
   remote_decoder_->Initialize(
-      mojom::VideoDecoderConfig::From(config), low_delay,
+      config, low_delay,
       base::Bind(&MojoVideoDecoder::OnInitializeDone, base::Unretained(this)));
 }
 

media/mojo/common/media_type_converters.cc

@@ -17,7 +17,6 @@
 #include "media/base/decrypt_config.h"
 #include "media/base/encryption_scheme.h"
 #include "media/base/subsample_entry.h"
-#include "media/base/video_decoder_config.h"
 #include "mojo/public/cpp/system/buffer.h"
 
 namespace mojo {
@@ -35,44 +34,6 @@ struct TypeConverter<media::EncryptionScheme::Pattern,
       const media::mojom::PatternPtr& input);
 };
 
-// static
-media::mojom::PatternPtr
-TypeConverter<media::mojom::PatternPtr, media::EncryptionScheme::Pattern>::
-    Convert(const media::EncryptionScheme::Pattern& input) {
-  media::mojom::PatternPtr mojo_pattern(media::mojom::Pattern::New());
-  mojo_pattern->encrypt_blocks = input.encrypt_blocks();
-  mojo_pattern->skip_blocks = input.skip_blocks();
-  return mojo_pattern;
-}
-
-// static
-media::EncryptionScheme::Pattern TypeConverter<
-    media::EncryptionScheme::Pattern,
-    media::mojom::PatternPtr>::Convert(const media::mojom::PatternPtr& input) {
-  return media::EncryptionScheme::Pattern(input->encrypt_blocks,
-                                          input->skip_blocks);
-}
-
-// static
-media::mojom::EncryptionSchemePtr TypeConverter<
-    media::mojom::EncryptionSchemePtr,
-    media::EncryptionScheme>::Convert(const media::EncryptionScheme& input) {
-  media::mojom::EncryptionSchemePtr mojo_encryption_scheme(
-      media::mojom::EncryptionScheme::New());
-  mojo_encryption_scheme->mode = input.mode();
-  mojo_encryption_scheme->pattern =
-      media::mojom::Pattern::From(input.pattern());
-  return mojo_encryption_scheme;
-}
-
-// static
-media::EncryptionScheme
-TypeConverter<media::EncryptionScheme, media::mojom::EncryptionSchemePtr>::
-    Convert(const media::mojom::EncryptionSchemePtr& input) {
-  return media::EncryptionScheme(
-      input->mode, input->pattern.To<media::EncryptionScheme::Pattern>());
-}
-
 // static
 media::mojom::DecryptConfigPtr
 TypeConverter<media::mojom::DecryptConfigPtr, media::DecryptConfig>::Convert(
@@ -183,8 +144,7 @@ TypeConverter<media::mojom::AudioDecoderConfigPtr, media::AudioDecoderConfig>::
   config->extra_data = input.extra_data();
   config->seek_preroll = input.seek_preroll();
   config->codec_delay = input.codec_delay();
-  config->encryption_scheme =
-      media::mojom::EncryptionScheme::From(input.encryption_scheme());
+  config->encryption_scheme = input.encryption_scheme();
   return config;
 }
 
@@ -195,45 +155,8 @@ TypeConverter<media::AudioDecoderConfig, media::mojom::AudioDecoderConfigPtr>::
   media::AudioDecoderConfig config;
   config.Initialize(input->codec, input->sample_format, input->channel_layout,
                     input->samples_per_second, input->extra_data,
-                    input->encryption_scheme.To<media::EncryptionScheme>(),
-                    input->seek_preroll, input->codec_delay);
-  return config;
-}
-
-// static
-media::mojom::VideoDecoderConfigPtr
-TypeConverter<media::mojom::VideoDecoderConfigPtr, media::VideoDecoderConfig>::
-    Convert(const media::VideoDecoderConfig& input) {
-  media::mojom::VideoDecoderConfigPtr config(
-      media::mojom::VideoDecoderConfig::New());
-  config->codec = input.codec();
-  config->profile = input.profile();
-  config->format = input.format();
-  config->color_space = input.color_space();
-  config->coded_size = input.coded_size();
-  config->visible_rect = input.visible_rect();
-  config->natural_size = input.natural_size();
-  config->extra_data = input.extra_data();
-  config->encryption_scheme =
-      media::mojom::EncryptionScheme::From(input.encryption_scheme());
-  config->color_space_info = input.color_space_info();
-  if (input.hdr_metadata())
-    config->hdr_metadata = *input.hdr_metadata();
-  return config;
-}
-
-// static
-media::VideoDecoderConfig
-TypeConverter<media::VideoDecoderConfig, media::mojom::VideoDecoderConfigPtr>::
-    Convert(const media::mojom::VideoDecoderConfigPtr& input) {
-  media::VideoDecoderConfig config;
-  config.Initialize(input->codec, input->profile, input->format,
-                    input->color_space, input->coded_size, input->visible_rect,
-                    input->natural_size, input->extra_data,
-                    input->encryption_scheme.To<media::EncryptionScheme>());
-  config.set_color_space_info(input->color_space_info);
-  if (input->hdr_metadata)
-    config.set_hdr_metadata(*input->hdr_metadata);
+                    input->encryption_scheme, input->seek_preroll,
+                    input->codec_delay);
   return config;
 }
 

media/mojo/common/media_type_converters.h

@@ -17,8 +17,6 @@ class AudioBuffer;
 class AudioDecoderConfig;
 class DecoderBuffer;
 class DecryptConfig;
-class EncryptionScheme;
-class VideoDecoderConfig;
 struct CdmConfig;
 struct CdmKeyInformation;
 }
@@ -27,19 +25,6 @@ struct CdmKeyInformation;
 // namespace.
 namespace mojo {
 
-template <>
-struct TypeConverter<media::mojom::EncryptionSchemePtr,
-                     media::EncryptionScheme> {
-  static media::mojom::EncryptionSchemePtr Convert(
-      const media::EncryptionScheme& input);
-};
-template <>
-struct TypeConverter<media::EncryptionScheme,
-                     media::mojom::EncryptionSchemePtr> {
-  static media::EncryptionScheme Convert(
-      const media::mojom::EncryptionSchemePtr& input);
-};
-
 template <>
 struct TypeConverter<media::mojom::DecryptConfigPtr, media::DecryptConfig> {
   static media::mojom::DecryptConfigPtr Convert(
@@ -78,19 +63,6 @@ struct TypeConverter<media::AudioDecoderConfig,
       const media::mojom::AudioDecoderConfigPtr& input);
 };
 
-template <>
-struct TypeConverter<media::mojom::VideoDecoderConfigPtr,
-                     media::VideoDecoderConfig> {
-  static media::mojom::VideoDecoderConfigPtr Convert(
-      const media::VideoDecoderConfig& input);
-};
-template <>
-struct TypeConverter<media::VideoDecoderConfig,
-                     media::mojom::VideoDecoderConfigPtr> {
-  static media::VideoDecoderConfig Convert(
-      const media::mojom::VideoDecoderConfigPtr& input);
-};
-
 template <>
 struct TypeConverter<media::mojom::CdmKeyInformationPtr,
                      media::CdmKeyInformation> {

media/mojo/common/media_type_converters_unittest.cc

@@ -24,10 +24,6 @@ namespace media {
 
 namespace {
 
-static const gfx::Size kCodedSize(320, 240);
-static const gfx::Rect kVisibleRect(320, 240);
-static const gfx::Size kNaturalSize(320, 240);
-
 void CompareBytes(uint8_t* original_data, uint8_t* result_data, size_t length) {
   EXPECT_GT(length, 0u);
   EXPECT_EQ(memcmp(original_data, result_data, length), 0);
@@ -167,112 +163,6 @@ TEST(MediaTypeConvertersTest, ConvertDecoderBuffer_EncryptedBuffer) {
   EXPECT_TRUE(buffer->decrypt_config()->iv().empty());
 }
 
-// TODO(tim): Check other properties.
-
-TEST(MediaTypeConvertersTest, ConvertAudioDecoderConfig_Normal) {
-  const uint8_t kExtraData[] = "config extra data";
-  const std::vector<uint8_t> kExtraDataVector(
-      &kExtraData[0], &kExtraData[0] + arraysize(kExtraData));
-
-  AudioDecoderConfig config;
-  config.Initialize(kCodecAAC, kSampleFormatU8, CHANNEL_LAYOUT_SURROUND, 48000,
-                    kExtraDataVector, Unencrypted(), base::TimeDelta(), 0);
-  mojom::AudioDecoderConfigPtr ptr(mojom::AudioDecoderConfig::From(config));
-  EXPECT_FALSE(ptr->extra_data.empty());
-  AudioDecoderConfig result(ptr.To<AudioDecoderConfig>());
-  EXPECT_TRUE(result.Matches(config));
-}
-
-TEST(MediaTypeConvertersTest, ConvertAudioDecoderConfig_EmptyExtraData) {
-  AudioDecoderConfig config;
-  config.Initialize(kCodecAAC, kSampleFormatU8, CHANNEL_LAYOUT_SURROUND, 48000,
-                    EmptyExtraData(), Unencrypted(), base::TimeDelta(), 0);
-  mojom::AudioDecoderConfigPtr ptr(mojom::AudioDecoderConfig::From(config));
-  EXPECT_TRUE(ptr->extra_data.empty());
-  AudioDecoderConfig result(ptr.To<AudioDecoderConfig>());
-  EXPECT_TRUE(result.Matches(config));
-}
-
-TEST(MediaTypeConvertersTest, ConvertAudioDecoderConfig_Encrypted) {
-  AudioDecoderConfig config;
-  config.Initialize(kCodecAAC, kSampleFormatU8, CHANNEL_LAYOUT_SURROUND, 48000,
-                    EmptyExtraData(), AesCtrEncryptionScheme(),
-                    base::TimeDelta(), 0);
-  mojom::AudioDecoderConfigPtr ptr(mojom::AudioDecoderConfig::From(config));
-  AudioDecoderConfig result(ptr.To<AudioDecoderConfig>());
-  EXPECT_TRUE(result.Matches(config));
-}
-
-TEST(MediaTypeConvertersTest, ConvertVideoDecoderConfig_Normal) {
-  const uint8_t kExtraData[] = "config extra data";
-  const std::vector<uint8_t> kExtraDataVector(
-      &kExtraData[0], &kExtraData[0] + arraysize(kExtraData));
-
-  VideoDecoderConfig config(kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_YV12,
-                            COLOR_SPACE_UNSPECIFIED, kCodedSize, kVisibleRect,
-                            kNaturalSize, kExtraDataVector, Unencrypted());
-  mojom::VideoDecoderConfigPtr ptr(mojom::VideoDecoderConfig::From(config));
-  EXPECT_FALSE(ptr->extra_data.empty());
-  VideoDecoderConfig result(ptr.To<VideoDecoderConfig>());
-  EXPECT_TRUE(result.Matches(config));
-}
-
-TEST(MediaTypeConvertersTest, ConvertVideoDecoderConfig_EmptyExtraData) {
-  VideoDecoderConfig config(kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_YV12,
-                            COLOR_SPACE_UNSPECIFIED, kCodedSize, kVisibleRect,
-                            kNaturalSize, EmptyExtraData(), Unencrypted());
-  mojom::VideoDecoderConfigPtr ptr(mojom::VideoDecoderConfig::From(config));
-  EXPECT_TRUE(ptr->extra_data.empty());
-  VideoDecoderConfig result(ptr.To<VideoDecoderConfig>());
-  EXPECT_TRUE(result.Matches(config));
-}
-
-TEST(MediaTypeConvertersTest, ConvertVideoDecoderConfig_Encrypted) {
-  VideoDecoderConfig config(kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_YV12,
-                            COLOR_SPACE_UNSPECIFIED, kCodedSize, kVisibleRect,
-                            kNaturalSize, EmptyExtraData(),
-                            AesCtrEncryptionScheme());
-  mojom::VideoDecoderConfigPtr ptr(mojom::VideoDecoderConfig::From(config));
-  VideoDecoderConfig result(ptr.To<VideoDecoderConfig>());
-  EXPECT_TRUE(result.Matches(config));
-}
-
-TEST(MediaTypeConvertersTest, ConvertVideoDecoderConfig_ColorSpaceInfo) {
-  VideoDecoderConfig config(kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_YV12,
-                            COLOR_SPACE_UNSPECIFIED, kCodedSize, kVisibleRect,
-                            kNaturalSize, EmptyExtraData(), Unencrypted());
-  config.set_color_space_info(VideoColorSpace(
-      VideoColorSpace::PrimaryID::BT2020,
-      VideoColorSpace::TransferID::SMPTEST2084,
-      VideoColorSpace::MatrixID::BT2020_CL, gfx::ColorSpace::RangeID::LIMITED));
-  mojom::VideoDecoderConfigPtr ptr(mojom::VideoDecoderConfig::From(config));
-  VideoDecoderConfig result(ptr.To<VideoDecoderConfig>());
-  EXPECT_TRUE(result.Matches(config));
-}
-
-TEST(MediaTypeConvertersTest, ConvertVideoDecoderConfig_HDRMetadata) {
-  VideoDecoderConfig config(kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_YV12,
-                            COLOR_SPACE_UNSPECIFIED, kCodedSize, kVisibleRect,
-                            kNaturalSize, EmptyExtraData(), Unencrypted());
-  HDRMetadata hdr_metadata;
-  hdr_metadata.max_frame_average_light_level = 123;
-  hdr_metadata.max_content_light_level = 456;
-  hdr_metadata.mastering_metadata.primary_r.set_x(0.1f);
-  hdr_metadata.mastering_metadata.primary_r.set_y(0.2f);
-  hdr_metadata.mastering_metadata.primary_g.set_x(0.3f);
-  hdr_metadata.mastering_metadata.primary_g.set_y(0.4f);
-  hdr_metadata.mastering_metadata.primary_b.set_x(0.5f);
-  hdr_metadata.mastering_metadata.primary_b.set_y(0.6f);
-  hdr_metadata.mastering_metadata.white_point.set_x(0.7f);
-  hdr_metadata.mastering_metadata.white_point.set_y(0.8f);
-  hdr_metadata.mastering_metadata.luminance_max = 1000;
-  hdr_metadata.mastering_metadata.luminance_min = 0;
-  config.set_hdr_metadata(hdr_metadata);
-  mojom::VideoDecoderConfigPtr ptr(mojom::VideoDecoderConfig::From(config));
-  VideoDecoderConfig result(ptr.To<VideoDecoderConfig>());
-  EXPECT_TRUE(result.Matches(config));
-}
-
 TEST(MediaTypeConvertersTest, ConvertCdmConfig) {
   CdmConfig config;
   config.allow_distinctive_identifier = true;
@@ -334,20 +224,4 @@ TEST(MediaTypeConvertersTest, ConvertAudioBuffer_FLOAT) {
   CompareAudioBuffers(kSampleFormatPlanarF32, buffer, result);
 }
 
-TEST(MediaTypeConvertersTest, ConvertEncryptionSchemeAesCbcWithPattern) {
-  // Original.
-  EncryptionScheme scheme(EncryptionScheme::CIPHER_MODE_AES_CBC,
-                          EncryptionScheme::Pattern(1, 9));
-
-  // Convert to and back.
-  mojom::EncryptionSchemePtr ptr(mojom::EncryptionScheme::From(scheme));
-  EncryptionScheme result(ptr.To<EncryptionScheme>());
-
-  EXPECT_TRUE(result.Matches(scheme));
-
-  // Verify a couple of negative cases.
-  EXPECT_FALSE(result.Matches(Unencrypted()));
-  EXPECT_FALSE(result.Matches(AesCtrEncryptionScheme()));
-}
-
 }  // namespace media

media/mojo/interfaces/audio_decoder_config.typemap

+# Copyright 2017 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.
+
+mojom = "//media/mojo/interfaces/media_types.mojom"
+
+public_headers = [ "//media/base/audio_decoder_config.h" ]
+
+traits_headers =
+    [ "//media/mojo/interfaces/audio_decoder_config_struct_traits.h" ]
+
+sources = [
+  "//media/mojo/interfaces/audio_decoder_config_struct_traits.cc",
+]
+
+public_deps = [
+  "//base",
+  "//media",
+]
+
+deps = [
+  "//media/base/ipc",
+  "//mojo/common:struct_traits",
+]
+
+# See media_types.typemap for enum mappings.
+type_mappings = [ "media.mojom.AudioDecoderConfig=media::AudioDecoderConfig" ]

media/mojo/interfaces/audio_decoder_config_struct_traits.cc

+// Copyright 2017 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/interfaces/audio_decoder_config_struct_traits.h"
+
+namespace mojo {
+
+// static
+bool StructTraits<media::mojom::AudioDecoderConfigDataView,
+                  media::AudioDecoderConfig>::
+    Read(media::mojom::AudioDecoderConfigDataView input,
+         media::AudioDecoderConfig* output) {
+  media::AudioCodec codec;
+  if (!input.ReadCodec(&codec))
+    return false;
+
+  media::SampleFormat sample_format;
+  if (!input.ReadSampleFormat(&sample_format))
+    return false;
+
+  media::ChannelLayout channel_layout;
+  if (!input.ReadChannelLayout(&channel_layout))
+    return false;
+
+  std::vector<uint8_t> extra_data;
+  if (!input.ReadExtraData(&extra_data))
+    return false;
+
+  media::EncryptionScheme encryption_scheme;
+  if (!input.ReadEncryptionScheme(&encryption_scheme))
+    return false;
+
+  base::TimeDelta seek_preroll;
+  if (!input.ReadSeekPreroll(&seek_preroll))
+    return false;
+
+  output->Initialize(codec, sample_format, channel_layout,
+                     input.samples_per_second(), extra_data, encryption_scheme,
+                     seek_preroll, input.codec_delay());
+
+  if (!output->IsValidConfig())
+    return false;
+
+  return true;
+}
+
+}  // namespace mojo
\ No newline at end of file

media/mojo/interfaces/audio_decoder_config_struct_traits.h

+// Copyright 2017 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.
+
+#ifndef MEDIA_MOJO_INTERFACES_AUDIO_DECODER_CONFIG_STRUCT_TRAITS_H_
+#define MEDIA_MOJO_INTERFACES_AUDIO_DECODER_CONFIG_STRUCT_TRAITS_H_
+
+#include "media/base/audio_decoder_config.h"
+#include "media/base/ipc/media_param_traits.h"
+#include "media/mojo/interfaces/encryption_scheme_struct_traits.h"
+#include "media/mojo/interfaces/media_types.mojom.h"
+#include "mojo/common/common_custom_types_struct_traits.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<media::mojom::AudioDecoderConfigDataView,
+                    media::AudioDecoderConfig> {
+  static media::AudioCodec codec(const media::AudioDecoderConfig& input) {
+    return input.codec();
+  }
+
+  static media::SampleFormat sample_format(
+      const media::AudioDecoderConfig& input) {
+    return input.sample_format();
+  }
+
+  static media::ChannelLayout channel_layout(
+      const media::AudioDecoderConfig& input) {
+    return input.channel_layout();
+  }
+
+  static int samples_per_second(const media::AudioDecoderConfig& input) {
+    return input.samples_per_second();
+  }
+
+  static const std::vector<uint8_t>& extra_data(
+      const media::AudioDecoderConfig& input) {
+    return input.extra_data();
+  }
+
+  static base::TimeDelta seek_preroll(const media::AudioDecoderConfig& input) {
+    return input.seek_preroll();
+  }
+
+  static int codec_delay(const media::AudioDecoderConfig& input) {
+    return input.codec_delay();
+  }
+
+  static const media::EncryptionScheme& encryption_scheme(
+      const media::AudioDecoderConfig& input) {
+    return input.encryption_scheme();
+  }
+
+  static bool Read(media::mojom::AudioDecoderConfigDataView input,
+                   media::AudioDecoderConfig* output);
+};
+
+}  // namespace mojo
+
+#endif  // MEDIA_MOJO_INTERFACES_AUDIO_DECODER_CONFIG_STRUCT_TRAITS_H_

media/mojo/interfaces/audio_decoder_config_struct_traits_unittest.cc

+// Copyright 2017 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/interfaces/audio_decoder_config_struct_traits.h"
+
+#include <utility>
+
+#include "base/macros.h"
+#include "media/base/audio_decoder_config.h"
+#include "media/base/media_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+TEST(AudioDecoderConfigStructTraitsTest, ConvertAudioDecoderConfig_Normal) {
+  const uint8_t kExtraData[] = "input extra data";
+  const std::vector<uint8_t> kExtraDataVector(
+      &kExtraData[0], &kExtraData[0] + arraysize(kExtraData));
+
+  AudioDecoderConfig input;
+  input.Initialize(kCodecAAC, kSampleFormatU8, CHANNEL_LAYOUT_SURROUND, 48000,
+                   kExtraDataVector, Unencrypted(), base::TimeDelta(), 0);
+  std::vector<uint8_t> data =
+      media::mojom::AudioDecoderConfig::Serialize(&input);
+  AudioDecoderConfig output;
+  EXPECT_TRUE(
+      media::mojom::AudioDecoderConfig::Deserialize(std::move(data), &output));
+  EXPECT_TRUE(output.Matches(input));
+}
+
+TEST(AudioDecoderConfigStructTraitsTest,
+     ConvertAudioDecoderConfig_EmptyExtraData) {
+  AudioDecoderConfig input;
+  input.Initialize(kCodecAAC, kSampleFormatU8, CHANNEL_LAYOUT_SURROUND, 48000,
+                   EmptyExtraData(), Unencrypted(), base::TimeDelta(), 0);
+  std::vector<uint8_t> data =
+      media::mojom::AudioDecoderConfig::Serialize(&input);
+  AudioDecoderConfig output;
+  EXPECT_TRUE(
+      media::mojom::AudioDecoderConfig::Deserialize(std::move(data), &output));
+  EXPECT_TRUE(output.Matches(input));
+}
+
+TEST(AudioDecoderConfigStructTraitsTest, ConvertAudioDecoderConfig_Encrypted) {
+  AudioDecoderConfig input;
+  input.Initialize(kCodecAAC, kSampleFormatU8, CHANNEL_LAYOUT_SURROUND, 48000,
+                   EmptyExtraData(), AesCtrEncryptionScheme(),
+                   base::TimeDelta(), 0);
+  std::vector<uint8_t> data =
+      media::mojom::AudioDecoderConfig::Serialize(&input);
+  AudioDecoderConfig output;
+  EXPECT_TRUE(
+      media::mojom::AudioDecoderConfig::Deserialize(std::move(data), &output));
+  EXPECT_TRUE(output.Matches(input));
+}
+
+}  // namespace media

media/mojo/interfaces/encryption_scheme.typemap

+# Copyright 2017 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.
+
+mojom = "//media/mojo/interfaces/media_types.mojom"
+
+public_headers = [ "//media/base/encryption_scheme.h" ]
+
+traits_headers = [ "//media/mojo/interfaces/encryption_scheme_struct_traits.h" ]
+
+sources = [
+  "//media/mojo/interfaces/encryption_scheme_struct_traits.cc",
+]
+
+public_deps = [
+  "//media",
+]
+
+deps = [
+  "//media/base/ipc",
+]
+
+# See media_types.typemap for enum mappings.
+type_mappings = [
+  "media.mojom.Pattern=media::EncryptionScheme::Pattern",
+  "media.mojom.EncryptionScheme=media::EncryptionScheme",
+]

media/mojo/interfaces/encryption_scheme_struct_traits.cc

+// Copyright 2017 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/interfaces/encryption_scheme_struct_traits.h"
+
+namespace mojo {
+
+// static
+bool StructTraits<media::mojom::PatternDataView,
+                  media::EncryptionScheme::Pattern>::
+    Read(media::mojom::PatternDataView input,
+         media::EncryptionScheme::Pattern* output) {
+  *output = media::EncryptionScheme::Pattern(input.encrypt_blocks(),
+                                             input.skip_blocks());
+  return true;
+}
+
+// static
+bool StructTraits<
+    media::mojom::EncryptionSchemeDataView,
+    media::EncryptionScheme>::Read(media::mojom::EncryptionSchemeDataView input,
+                                   media::EncryptionScheme* output) {
+  media::EncryptionScheme::CipherMode mode;
+  if (!input.ReadMode(&mode))
+    return false;
+
+  media::EncryptionScheme::Pattern pattern;
+  if (!input.ReadPattern(&pattern))
+    return false;
+
+  *output = media::EncryptionScheme(mode, pattern);
+
+  return true;
+}
+
+}  // namespace mojo
\ No newline at end of file

media/mojo/interfaces/encryption_scheme_struct_traits.h

+// Copyright 2017 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.
+
+#ifndef MEDIA_MOJO_INTERFACES_ENCRYPTION_SCHEME_STRUCT_TRAITS_H_
+#define MEDIA_MOJO_INTERFACES_ENCRYPTION_SCHEME_STRUCT_TRAITS_H_
+
+#include "media/base/encryption_scheme.h"
+#include "media/base/ipc/media_param_traits.h"
+#include "media/mojo/interfaces/media_types.mojom.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<media::mojom::PatternDataView,
+                    media::EncryptionScheme::Pattern> {
+  static uint32_t encrypt_blocks(
+      const media::EncryptionScheme::Pattern& input) {
+    return input.encrypt_blocks();
+  }
+
+  static uint32_t skip_blocks(const media::EncryptionScheme::Pattern& input) {
+    return input.skip_blocks();
+  }
+
+  static bool Read(media::mojom::PatternDataView input,
+                   media::EncryptionScheme::Pattern* output);
+};
+
+template <>
+struct StructTraits<media::mojom::EncryptionSchemeDataView,
+                    media::EncryptionScheme> {
+  static media::EncryptionScheme::CipherMode mode(
+      const media::EncryptionScheme& input) {
+    return input.mode();
+  }
+
+  static media::EncryptionScheme::Pattern pattern(
+      const media::EncryptionScheme& input) {
+    return input.pattern();
+  }
+
+  static bool Read(media::mojom::EncryptionSchemeDataView input,
+                   media::EncryptionScheme* output);
+};
+
+}  // namespace mojo
+
+#endif  // MEDIA_MOJO_INTERFACES_ENCRYPTION_SCHEME_STRUCT_TRAITS_H_

media/mojo/interfaces/encryption_scheme_struct_traits_unittest.cc

+// Copyright 2017 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/interfaces/encryption_scheme_struct_traits.h"
+
+#include <utility>
+
+#include "media/base/encryption_scheme.h"
+#include "media/base/media_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+TEST(EncryptionSchemeStructTraitsTest,
+     ConvertEncryptionSchemeAesCbcWithPattern) {
+  EncryptionScheme input(EncryptionScheme::CIPHER_MODE_AES_CBC,
+                         EncryptionScheme::Pattern(1, 9));
+  std::vector<uint8_t> data = media::mojom::EncryptionScheme::Serialize(&input);
+
+  EncryptionScheme output;
+  EXPECT_TRUE(
+      media::mojom::EncryptionScheme::Deserialize(std::move(data), &output));
+  EXPECT_TRUE(output.Matches(input));
+
+  // Verify a couple of negative cases.
+  EXPECT_FALSE(output.Matches(Unencrypted()));
+  EXPECT_FALSE(output.Matches(AesCtrEncryptionScheme()));
+}
+
+}  // namespace media

media/mojo/interfaces/typemaps.gni

@@ -3,13 +3,16 @@
 # found in the LICENSE file.
 
 typemaps = [
+  "//media/mojo/interfaces/audio_decoder_config.typemap",
   "//media/mojo/interfaces/audio_parameters.typemap",
   "//media/mojo/interfaces/content_decryption_module.typemap",
   "//media/mojo/interfaces/decryptor.typemap",
   "//media/mojo/interfaces/demuxer_stream.typemap",
+  "//media/mojo/interfaces/encryption_scheme.typemap",
   "//media/mojo/interfaces/hdr_metadata.typemap",
   "//media/mojo/interfaces/media_types.typemap",
   "//media/mojo/interfaces/pipeline_statistics.typemap",
   "//media/mojo/interfaces/video_color_space.typemap",
+  "//media/mojo/interfaces/video_decoder_config.typemap",
   "//media/mojo/interfaces/video_frame.typemap",
 ]

media/mojo/interfaces/video_decoder_config.typemap

+# Copyright 2017 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.
+
+mojom = "//media/mojo/interfaces/media_types.mojom"
+
+public_headers = [ "//media/base/video_decoder_config.h" ]
+
+traits_headers =
+    [ "//media/mojo/interfaces/video_decoder_config_struct_traits.h" ]
+
+sources = [
+  "video_decoder_config_struct_traits.cc",
+]
+
+public_deps = [
+  "//base",
+  "//media",
+]
+
+deps = [
+  "//media/base/ipc",
+  "//ui/gfx/geometry/mojo:struct_traits",
+]
+
+# See media_types.typemap for enum mappings.
+type_mappings = [ "media.mojom.VideoDecoderConfig=media::VideoDecoderConfig" ]

media/mojo/interfaces/video_decoder_config_struct_traits.cc

+// Copyright 2017 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/interfaces/video_decoder_config_struct_traits.h"
+
+namespace mojo {
+
+// static
+bool StructTraits<media::mojom::VideoDecoderConfigDataView,
+                  media::VideoDecoderConfig>::
+    Read(media::mojom::VideoDecoderConfigDataView input,
+         media::VideoDecoderConfig* output) {
+  media::VideoCodec codec;
+  if (!input.ReadCodec(&codec))
+    return false;
+
+  media::VideoCodecProfile profile;
+  if (!input.ReadProfile(&profile))
+    return false;
+
+  media::VideoPixelFormat format;
+  if (!input.ReadFormat(&format))
+    return false;
+
+  media::ColorSpace color_space;
+  if (!input.ReadColorSpace(&color_space))
+    return false;
+
+  gfx::Size coded_size;
+  if (!input.ReadCodedSize(&coded_size))
+    return false;
+
+  gfx::Rect visible_rect;
+  if (!input.ReadVisibleRect(&visible_rect))
+    return false;
+
+  gfx::Size natural_size;
+  if (!input.ReadNaturalSize(&natural_size))
+    return false;
+
+  std::vector<uint8_t> extra_data;
+  if (!input.ReadExtraData(&extra_data))
+    return false;
+
+  media::EncryptionScheme encryption_scheme;
+  if (!input.ReadEncryptionScheme(&encryption_scheme))
+    return false;
+
+  media::VideoColorSpace color_space_info;
+  if (!input.ReadColorSpaceInfo(&color_space_info))
+    return false;
+
+  base::Optional<media::HDRMetadata> hdr_metadata;
+  if (!input.ReadHdrMetadata(&hdr_metadata))
+    return false;
+
+  output->Initialize(codec, profile, format, color_space, coded_size,
+                     visible_rect, natural_size, extra_data, encryption_scheme);
+
+  output->set_color_space_info(color_space_info);
+
+  if (hdr_metadata)
+    output->set_hdr_metadata(hdr_metadata.value());
+
+  if (!output->IsValidConfig())
+    return false;
+
+  return true;
+}
+
+}  // namespace mojo
\ No newline at end of file

media/mojo/interfaces/video_decoder_config_struct_traits.h

+// Copyright 2017 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.
+
+#ifndef MEDIA_MOJO_INTERFACES_VIDEO_DECODER_CONFIG_STRUCT_TRAITS_H_
+#define MEDIA_MOJO_INTERFACES_VIDEO_DECODER_CONFIG_STRUCT_TRAITS_H_
+
+#include "media/base/ipc/media_param_traits.h"
+#include "media/base/video_decoder_config.h"
+#include "media/mojo/interfaces/encryption_scheme_struct_traits.h"
+#include "media/mojo/interfaces/hdr_metadata_struct_traits.h"
+#include "media/mojo/interfaces/media_types.mojom.h"
+#include "media/mojo/interfaces/video_color_space_struct_traits.h"
+#include "ui/gfx/geometry/mojo/geometry_struct_traits.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<media::mojom::VideoDecoderConfigDataView,
+                    media::VideoDecoderConfig> {
+  static media::VideoCodec codec(const media::VideoDecoderConfig& input) {
+    return input.codec();
+  }
+
+  static media::VideoCodecProfile profile(
+      const media::VideoDecoderConfig& input) {
+    return input.profile();
+  }
+
+  static media::VideoPixelFormat format(
+      const media::VideoDecoderConfig& input) {
+    return input.format();
+  }
+
+  static media::ColorSpace color_space(const media::VideoDecoderConfig& input) {
+    return input.color_space();
+  }
+
+  static const gfx::Size& coded_size(const media::VideoDecoderConfig& input) {
+    return input.coded_size();
+  }
+
+  static const gfx::Rect& visible_rect(const media::VideoDecoderConfig& input) {
+    return input.visible_rect();
+  }
+
+  static const gfx::Size& natural_size(const media::VideoDecoderConfig& input) {
+    return input.natural_size();
+  }
+
+  static const std::vector<uint8_t>& extra_data(
+      const media::VideoDecoderConfig& input) {
+    return input.extra_data();
+  }
+
+  static const media::EncryptionScheme& encryption_scheme(
+      const media::VideoDecoderConfig& input) {
+    return input.encryption_scheme();
+  }
+
+  static const media::VideoColorSpace& color_space_info(
+      const media::VideoDecoderConfig& input) {
+    return input.color_space_info();
+  }
+
+  static const base::Optional<media::HDRMetadata>& hdr_metadata(
+      const media::VideoDecoderConfig& input) {
+    return input.hdr_metadata();
+  }
+
+  static bool Read(media::mojom::VideoDecoderConfigDataView input,
+                   media::VideoDecoderConfig* output);
+};
+
+}  // namespace mojo
+
+#endif  // MEDIA_MOJO_INTERFACES_VIDEO_DECODER_CONFIG_STRUCT_TRAITS_H_

media/mojo/interfaces/video_decoder_config_struct_traits_unittest.cc

+// Copyright 2017 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/interfaces/video_decoder_config_struct_traits.h"
+
+#include <utility>
+
+#include "base/macros.h"
+#include "media/base/media_util.h"
+#include "media/base/video_decoder_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+namespace {
+
+static const gfx::Size kCodedSize(320, 240);
+static const gfx::Rect kVisibleRect(320, 240);
+static const gfx::Size kNaturalSize(320, 240);
+
+}  // namespace
+
+TEST(VideoDecoderConfigStructTraitsTest, ConvertVideoDecoderConfig_Normal) {
+  const uint8_t kExtraData[] = "config extra data";
+  const std::vector<uint8_t> kExtraDataVector(
+      &kExtraData[0], &kExtraData[0] + arraysize(kExtraData));
+  VideoDecoderConfig input(kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_YV12,
+                           COLOR_SPACE_UNSPECIFIED, kCodedSize, kVisibleRect,
+                           kNaturalSize, kExtraDataVector, Unencrypted());
+  std::vector<uint8_t> data =
+      media::mojom::VideoDecoderConfig::Serialize(&input);
+  VideoDecoderConfig output;
+  EXPECT_TRUE(
+      media::mojom::VideoDecoderConfig::Deserialize(std::move(data), &output));
+  EXPECT_TRUE(output.Matches(input));
+}
+
+TEST(VideoDecoderConfigStructTraitsTest,
+     ConvertVideoDecoderConfig_EmptyExtraData) {
+  VideoDecoderConfig input(kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_YV12,
+                           COLOR_SPACE_UNSPECIFIED, kCodedSize, kVisibleRect,
+                           kNaturalSize, EmptyExtraData(), Unencrypted());
+  std::vector<uint8_t> data =
+      media::mojom::VideoDecoderConfig::Serialize(&input);
+  VideoDecoderConfig output;
+  EXPECT_TRUE(
+      media::mojom::VideoDecoderConfig::Deserialize(std::move(data), &output));
+  EXPECT_TRUE(output.Matches(input));
+}
+
+TEST(VideoDecoderConfigStructTraitsTest, ConvertVideoDecoderConfig_Encrypted) {
+  VideoDecoderConfig input(kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_YV12,
+                           COLOR_SPACE_UNSPECIFIED, kCodedSize, kVisibleRect,
+                           kNaturalSize, EmptyExtraData(),
+                           AesCtrEncryptionScheme());
+  std::vector<uint8_t> data =
+      media::mojom::VideoDecoderConfig::Serialize(&input);
+  VideoDecoderConfig output;
+  EXPECT_TRUE(
+      media::mojom::VideoDecoderConfig::Deserialize(std::move(data), &output));
+  EXPECT_TRUE(output.Matches(input));
+}
+
+TEST(VideoDecoderConfigStructTraitsTest,
+     ConvertVideoDecoderConfig_ColorSpaceInfo) {
+  VideoDecoderConfig input(kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_YV12,
+                           COLOR_SPACE_UNSPECIFIED, kCodedSize, kVisibleRect,
+                           kNaturalSize, EmptyExtraData(), Unencrypted());
+  input.set_color_space_info(VideoColorSpace(
+      VideoColorSpace::PrimaryID::BT2020,
+      VideoColorSpace::TransferID::SMPTEST2084,
+      VideoColorSpace::MatrixID::BT2020_CL, gfx::ColorSpace::RangeID::LIMITED));
+  std::vector<uint8_t> data =
+      media::mojom::VideoDecoderConfig::Serialize(&input);
+  VideoDecoderConfig output;
+  EXPECT_TRUE(
+      media::mojom::VideoDecoderConfig::Deserialize(std::move(data), &output));
+  EXPECT_TRUE(output.Matches(input));
+}
+
+TEST(VideoDecoderConfigStructTraitsTest,
+     ConvertVideoDecoderConfig_HDRMetadata) {
+  VideoDecoderConfig input(kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_YV12,
+                           COLOR_SPACE_UNSPECIFIED, kCodedSize, kVisibleRect,
+                           kNaturalSize, EmptyExtraData(), Unencrypted());
+  HDRMetadata hdr_metadata;
+  hdr_metadata.max_frame_average_light_level = 123;
+  hdr_metadata.max_content_light_level = 456;
+  hdr_metadata.mastering_metadata.primary_r.set_x(0.1f);
+  hdr_metadata.mastering_metadata.primary_r.set_y(0.2f);
+  hdr_metadata.mastering_metadata.primary_g.set_x(0.3f);
+  hdr_metadata.mastering_metadata.primary_g.set_y(0.4f);
+  hdr_metadata.mastering_metadata.primary_b.set_x(0.5f);
+  hdr_metadata.mastering_metadata.primary_b.set_y(0.6f);
+  hdr_metadata.mastering_metadata.white_point.set_x(0.7f);
+  hdr_metadata.mastering_metadata.white_point.set_y(0.8f);
+  hdr_metadata.mastering_metadata.luminance_max = 1000;
+  hdr_metadata.mastering_metadata.luminance_min = 0;
+  input.set_hdr_metadata(hdr_metadata);
+  std::vector<uint8_t> data =
+      media::mojom::VideoDecoderConfig::Serialize(&input);
+  VideoDecoderConfig output;
+  EXPECT_TRUE(
+      media::mojom::VideoDecoderConfig::Deserialize(std::move(data), &output));
+  EXPECT_TRUE(output.Matches(input));
+}
+
+TEST(VideoDecoderConfigStructTraitsTest,
+     ConvertVideoDecoderConfig_InvalidConfigs) {
+  // Create an invalid empty config.
+  VideoDecoderConfig input;
+  EXPECT_FALSE(input.IsValidConfig());
+
+  std::vector<uint8_t> data =
+      media::mojom::VideoDecoderConfig::Serialize(&input);
+  VideoDecoderConfig output;
+
+  // Deserialize should only pass for valid configs.
+  EXPECT_FALSE(
+      media::mojom::VideoDecoderConfig::Deserialize(std::move(data), &output));
+
+  // Next try an non-empty invalid config. Natural size must not be zero.
+  const gfx::Size kInvalidNaturalSize(0, 0);
+  input.Initialize(kCodecVP8, VP8PROFILE_ANY, PIXEL_FORMAT_YV12,
+                   COLOR_SPACE_UNSPECIFIED, kCodedSize, kVisibleRect,
+                   kInvalidNaturalSize, EmptyExtraData(), Unencrypted());
+  EXPECT_FALSE(input.IsValidConfig());
+
+  // Deserialize should again fail due to invalid config.
+  EXPECT_FALSE(
+      media::mojom::VideoDecoderConfig::Deserialize(std::move(data), &output));
+}
+
+}  // namespace media

media/mojo/services/mojo_audio_decoder_service.cc

@@ -32,17 +32,15 @@ void MojoAudioDecoderService::Construct(
   client_.Bind(std::move(client));
 }
 
-void MojoAudioDecoderService::Initialize(
-    mojom::AudioDecoderConfigPtr config,
-    int32_t cdm_id,
-    const InitializeCallback& callback) {
-  DVLOG(1) << __func__ << " "
-           << config.To<media::AudioDecoderConfig>().AsHumanReadableString();
+void MojoAudioDecoderService::Initialize(const AudioDecoderConfig& config,
+                                         int32_t cdm_id,
+                                         const InitializeCallback& callback) {
+  DVLOG(1) << __func__ << " " << config.AsHumanReadableString();
 
   // Get CdmContext from cdm_id if the stream is encrypted.
   CdmContext* cdm_context = nullptr;
   scoped_refptr<ContentDecryptionModule> cdm;
-  if (config.To<media::AudioDecoderConfig>().is_encrypted()) {
+  if (config.is_encrypted()) {
     if (!mojo_cdm_service_context_) {
       DVLOG(1) << "CDM service context not available.";
       callback.Run(false, false);
@@ -65,7 +63,7 @@ void MojoAudioDecoderService::Initialize(
   }
 
   decoder_->Initialize(
-      config.To<media::AudioDecoderConfig>(), cdm_context,
+      config, cdm_context,
       base::Bind(&MojoAudioDecoderService::OnInitialized, weak_this_, callback,
                  cdm),
       base::Bind(&MojoAudioDecoderService::OnAudioBufferReady, weak_this_));

media/mojo/services/mojo_audio_decoder_service.h

@@ -32,7 +32,7 @@ class MEDIA_MOJO_EXPORT MojoAudioDecoderService
 
   // mojom::AudioDecoder implementation
   void Construct(mojom::AudioDecoderClientAssociatedPtrInfo client) final;
-  void Initialize(mojom::AudioDecoderConfigPtr config,
+  void Initialize(const AudioDecoderConfig& config,
                   int32_t cdm_id,
                   const InitializeCallback& callback) final;
 

media/mojo/services/mojo_decryptor_service.cc

@@ -84,23 +84,21 @@ void MojoDecryptorService::CancelDecrypt(StreamType stream_type) {
 }
 
 void MojoDecryptorService::InitializeAudioDecoder(
-    mojom::AudioDecoderConfigPtr config,
+    const AudioDecoderConfig& config,
     const InitializeAudioDecoderCallback& callback) {
   DVLOG(1) << __func__;
   decryptor_->InitializeAudioDecoder(
-      config.To<AudioDecoderConfig>(),
-      base::Bind(&MojoDecryptorService::OnAudioDecoderInitialized, weak_this_,
-                 callback));
+      config, base::Bind(&MojoDecryptorService::OnAudioDecoderInitialized,
+                         weak_this_, callback));
 }
 
 void MojoDecryptorService::InitializeVideoDecoder(
-    mojom::VideoDecoderConfigPtr config,
+    const VideoDecoderConfig& config,
     const InitializeVideoDecoderCallback& callback) {
   DVLOG(1) << __func__;
   decryptor_->InitializeVideoDecoder(
-      config.To<VideoDecoderConfig>(),
-      base::Bind(&MojoDecryptorService::OnVideoDecoderInitialized, weak_this_,
-                 callback));
+      config, base::Bind(&MojoDecryptorService::OnVideoDecoderInitialized,
+                         weak_this_, callback));
 }
 
 void MojoDecryptorService::DecryptAndDecodeAudio(

media/mojo/services/mojo_decryptor_service.h

@@ -49,10 +49,10 @@ class MEDIA_MOJO_EXPORT MojoDecryptorService
                const DecryptCallback& callback) final;
   void CancelDecrypt(StreamType stream_type) final;
   void InitializeAudioDecoder(
-      mojom::AudioDecoderConfigPtr config,
+      const AudioDecoderConfig& config,
       const InitializeAudioDecoderCallback& callback) final;
   void InitializeVideoDecoder(
-      mojom::VideoDecoderConfigPtr config,
+      const VideoDecoderConfig& config,
       const InitializeVideoDecoderCallback& callback) final;
   void DecryptAndDecodeAudio(
       mojom::DecoderBufferPtr encrypted,

media/mojo/services/mojo_demuxer_stream_adapter.cc

@@ -74,8 +74,8 @@ VideoRotation MojoDemuxerStreamAdapter::video_rotation() {
 void MojoDemuxerStreamAdapter::OnStreamReady(
     Type type,
     mojo::ScopedDataPipeConsumerHandle consumer_handle,
-    mojom::AudioDecoderConfigPtr audio_config,
-    mojom::VideoDecoderConfigPtr video_config) {
+    const base::Optional<AudioDecoderConfig>& audio_config,
+    const base::Optional<VideoDecoderConfig>& video_config) {
   DVLOG(1) << __func__;
   DCHECK_EQ(UNKNOWN, type_);
   DCHECK(consumer_handle.is_valid());
@@ -93,8 +93,8 @@ void MojoDemuxerStreamAdapter::OnStreamReady(
 void MojoDemuxerStreamAdapter::OnBufferReady(
     Status status,
     mojom::DecoderBufferPtr buffer,
-    mojom::AudioDecoderConfigPtr audio_config,
-    mojom::VideoDecoderConfigPtr video_config) {
+    const base::Optional<AudioDecoderConfig>& audio_config,
+    const base::Optional<VideoDecoderConfig>& video_config) {
   DVLOG(3) << __func__;
   DCHECK(!read_cb_.is_null());
   DCHECK_NE(type_, UNKNOWN);
@@ -127,18 +127,18 @@ void MojoDemuxerStreamAdapter::OnBufferRead(
 }
 
 void MojoDemuxerStreamAdapter::UpdateConfig(
-    mojom::AudioDecoderConfigPtr audio_config,
-    mojom::VideoDecoderConfigPtr video_config) {
+    const base::Optional<AudioDecoderConfig>& audio_config,
+    const base::Optional<VideoDecoderConfig>& video_config) {
   DCHECK_NE(type_, UNKNOWN);
 
   switch(type_) {
     case AUDIO:
       DCHECK(audio_config && !video_config);
-      audio_config_ = audio_config.To<AudioDecoderConfig>();
+      audio_config_ = audio_config.value();
       break;
     case VIDEO:
       DCHECK(video_config && !audio_config);
-      video_config_ = video_config.To<VideoDecoderConfig>();
+      video_config_ = video_config.value();
       break;
     default:
       NOTREACHED();

media/mojo/services/mojo_demuxer_stream_adapter.h

@@ -10,6 +10,7 @@
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "base/optional.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/video_decoder_config.h"
@@ -48,20 +49,20 @@ class MojoDemuxerStreamAdapter : public DemuxerStream {
  private:
   void OnStreamReady(Type type,
                      mojo::ScopedDataPipeConsumerHandle consumer_handle,
-                     mojom::AudioDecoderConfigPtr audio_config,
-                     mojom::VideoDecoderConfigPtr video_config);
+                     const base::Optional<AudioDecoderConfig>& audio_config,
+                     const base::Optional<VideoDecoderConfig>& video_config);
 
   // The callback from |demuxer_stream_| that a read operation has completed.
   // |read_cb| is a callback from the client who invoked Read() on |this|.
   void OnBufferReady(Status status,
                      mojom::DecoderBufferPtr buffer,
-                     mojom::AudioDecoderConfigPtr audio_config,
-                     mojom::VideoDecoderConfigPtr video_config);
+                     const base::Optional<AudioDecoderConfig>& audio_config,
+                     const base::Optional<VideoDecoderConfig>& video_config);
 
   void OnBufferRead(scoped_refptr<DecoderBuffer> buffer);
 
-  void UpdateConfig(mojom::AudioDecoderConfigPtr audio_config,
-                    mojom::VideoDecoderConfigPtr video_config);
+  void UpdateConfig(const base::Optional<AudioDecoderConfig>& audio_config,
+                    const base::Optional<VideoDecoderConfig>& video_config);
 
   // See constructor for descriptions.
   mojom::DemuxerStreamPtr demuxer_stream_;

media/mojo/services/mojo_video_decoder_service.cc

@@ -58,7 +58,7 @@ void MojoVideoDecoderService::Construct(
       base::Bind(&MojoVideoDecoderService::OnDecoderOutput, weak_this_));
 }
 
-void MojoVideoDecoderService::Initialize(mojom::VideoDecoderConfigPtr config,
+void MojoVideoDecoderService::Initialize(const VideoDecoderConfig& config,
                                          bool low_delay,
                                          const InitializeCallback& callback) {
   DVLOG(1) << __func__;
@@ -69,7 +69,7 @@ void MojoVideoDecoderService::Initialize(mojom::VideoDecoderConfigPtr config,
   }
 
   decoder_->Initialize(
-      config.To<VideoDecoderConfig>(), low_delay, nullptr,
+      config, low_delay, nullptr,
       base::Bind(&MojoVideoDecoderService::OnDecoderInitialized, weak_this_,
                  callback),
       base::Bind(&MojoVideoDecoderService::OnDecoderOutput, weak_this_,

media/mojo/services/mojo_video_decoder_service.h

@@ -40,7 +40,7 @@ class MojoVideoDecoderService : public mojom::VideoDecoder {
                  mojom::MediaLogAssociatedPtrInfo media_log,
                  mojo::ScopedDataPipeConsumerHandle decoder_buffer_pipe,
                  mojom::CommandBufferIdPtr command_buffer_id) final;
-  void Initialize(mojom::VideoDecoderConfigPtr config,
+  void Initialize(const VideoDecoderConfig& config,
                   bool low_delay,
                   const InitializeCallback& callback) final;
   void Decode(mojom::DecoderBufferPtr buffer,