Revert of media config: expand is_encrypted to a struct.

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/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/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 {
 
@@ skipping 184 matching lines @@
 ASSERT_ENUM_EQ(VideoCodecProfile, , , H264PROFILE_MULTIVIEWHIGH);
 ASSERT_ENUM_EQ(VideoCodecProfile, , , H264PROFILE_MAX);
 ASSERT_ENUM_EQ(VideoCodecProfile, , , VP8PROFILE_MIN);
 ASSERT_ENUM_EQ(VideoCodecProfile, , , VP8PROFILE_ANY);
 ASSERT_ENUM_EQ(VideoCodecProfile, , , VP8PROFILE_MAX);
 ASSERT_ENUM_EQ(VideoCodecProfile, , , VP9PROFILE_MIN);
 ASSERT_ENUM_EQ(VideoCodecProfile, , , VP9PROFILE_ANY);
 ASSERT_ENUM_EQ(VideoCodecProfile, , , VP9PROFILE_MAX);
 ASSERT_ENUM_EQ(VideoCodecProfile, , , VIDEO_CODEC_PROFILE_MAX);
 
-// CipherMode
-ASSERT_ENUM_EQ_RAW(EncryptionScheme::CipherMode,
-                   EncryptionScheme::CipherMode::CIPHER_MODE_UNENCRYPTED,
-                   CipherMode::UNENCRYPTED);
-ASSERT_ENUM_EQ_RAW(EncryptionScheme::CipherMode,
-                   EncryptionScheme::CipherMode::CIPHER_MODE_AES_CTR,
-                   CipherMode::AES_CTR);
-ASSERT_ENUM_EQ_RAW(EncryptionScheme::CipherMode,
-                   EncryptionScheme::CipherMode::CIPHER_MODE_AES_CBC,
-                   CipherMode::AES_CBC);
-ASSERT_ENUM_EQ_RAW(EncryptionScheme::CipherMode,
-                   EncryptionScheme::CipherMode::CIPHER_MODE_MAX,
-                   CipherMode::MAX);
-
 // Decryptor Status
 ASSERT_ENUM_EQ_RAW(Decryptor::Status,
                    Decryptor::kSuccess,
                    Decryptor::Status::SUCCESS);
 ASSERT_ENUM_EQ_RAW(Decryptor::Status,
                    Decryptor::kNoKey,
                    Decryptor::Status::NO_KEY);
 ASSERT_ENUM_EQ_RAW(Decryptor::Status,
                    Decryptor::kNeedMoreData,
                    Decryptor::Status::NEED_MORE_DATA);
@@ skipping 54 matching lines @@
 // CDM Message Type
 #define ASSERT_CDM_MESSAGE_TYPE(value)                             \
   static_assert(media::MediaKeys::value ==                         \
                     static_cast<media::MediaKeys::MessageType>(    \
                         media::interfaces::CdmMessageType::value), \
                 "Mismatched CDM Message Type")
 ASSERT_CDM_MESSAGE_TYPE(LICENSE_REQUEST);
 ASSERT_CDM_MESSAGE_TYPE(LICENSE_RENEWAL);
 ASSERT_CDM_MESSAGE_TYPE(LICENSE_RELEASE);
 
-template <>
-struct TypeConverter<media::interfaces::PatternPtr,
-                     media::EncryptionScheme::Pattern> {
-  static media::interfaces::PatternPtr Convert(
-      const media::EncryptionScheme::Pattern& input);
-};
-template <>
-struct TypeConverter<media::EncryptionScheme::Pattern,
-                     media::interfaces::PatternPtr> {
-  static media::EncryptionScheme::Pattern Convert(
-      const media::interfaces::PatternPtr& input);
-};
-
-// static
-media::interfaces::PatternPtr
-TypeConverter<media::interfaces::PatternPtr, media::EncryptionScheme::Pattern>::
-    Convert(const media::EncryptionScheme::Pattern& input) {
-  media::interfaces::PatternPtr mojo_pattern(media::interfaces::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::interfaces::PatternPtr>::
-    Convert(const media::interfaces::PatternPtr& input) {
-  return media::EncryptionScheme::Pattern(input->encrypt_blocks,
-                                          input->skip_blocks);
-}
-
-// static
-media::interfaces::EncryptionSchemePtr TypeConverter<
-    media::interfaces::EncryptionSchemePtr,
-    media::EncryptionScheme>::Convert(const media::EncryptionScheme& input) {
-  media::interfaces::EncryptionSchemePtr mojo_encryption_scheme(
-      media::interfaces::EncryptionScheme::New());
-  mojo_encryption_scheme->mode =
-      static_cast<media::interfaces::CipherMode>(input.mode());
-  mojo_encryption_scheme->pattern =
-      media::interfaces::Pattern::From(input.pattern());
-  return mojo_encryption_scheme;
-}
-
-// static
-media::EncryptionScheme
-TypeConverter<media::EncryptionScheme, media::interfaces::EncryptionSchemePtr>::
-    Convert(const media::interfaces::EncryptionSchemePtr& input) {
-  return media::EncryptionScheme(
-      static_cast<media::EncryptionScheme::CipherMode>(input->mode),
-      input->pattern.To<media::EncryptionScheme::Pattern>());
-}
-
 // static
 media::interfaces::SubsampleEntryPtr TypeConverter<
     media::interfaces::SubsampleEntryPtr,
     media::SubsampleEntry>::Convert(const media::SubsampleEntry& input) {
   media::interfaces::SubsampleEntryPtr mojo_subsample_entry(
       media::interfaces::SubsampleEntry::New());
   mojo_subsample_entry->clear_bytes = input.clear_bytes;
   mojo_subsample_entry->cypher_bytes = input.cypher_bytes;
   return mojo_subsample_entry;
 }
@@ skipping 120 matching lines @@
   config->sample_format =
       static_cast<media::interfaces::SampleFormat>(input.sample_format());
   config->channel_layout =
       static_cast<media::interfaces::ChannelLayout>(input.channel_layout());
   config->samples_per_second = input.samples_per_second();
   if (!input.extra_data().empty()) {
     config->extra_data = mojo::Array<uint8_t>::From(input.extra_data());
   }
   config->seek_preroll_usec = input.seek_preroll().InMicroseconds();
   config->codec_delay = input.codec_delay();
-  config->encryption_scheme =
-      media::interfaces::EncryptionScheme::From(input.encryption_scheme());
+  config->is_encrypted = input.is_encrypted();
   return config;
 }
 
 // static
 media::AudioDecoderConfig
 TypeConverter<media::AudioDecoderConfig,
               media::interfaces::AudioDecoderConfigPtr>::
     Convert(const media::interfaces::AudioDecoderConfigPtr& input) {
   media::AudioDecoderConfig config;
   config.Initialize(static_cast<media::AudioCodec>(input->codec),
                     static_cast<media::SampleFormat>(input->sample_format),
                     static_cast<media::ChannelLayout>(input->channel_layout),
                     input->samples_per_second, input->extra_data.storage(),
-                    input->encryption_scheme.To<media::EncryptionScheme>(),
+                    input->is_encrypted,
                     base::TimeDelta::FromMicroseconds(input->seek_preroll_usec),
                     input->codec_delay);
   return config;
 }
 
 // static
 media::interfaces::VideoDecoderConfigPtr TypeConverter<
     media::interfaces::VideoDecoderConfigPtr,
     media::VideoDecoderConfig>::Convert(const media::VideoDecoderConfig&
                                             input) {
   media::interfaces::VideoDecoderConfigPtr config(
       media::interfaces::VideoDecoderConfig::New());
   config->codec = static_cast<media::interfaces::VideoCodec>(input.codec());
   config->profile =
       static_cast<media::interfaces::VideoCodecProfile>(input.profile());
   config->format = static_cast<media::interfaces::VideoFormat>(input.format());
   config->color_space =
       static_cast<media::interfaces::ColorSpace>(input.color_space());
   config->coded_size = Size::From(input.coded_size());
   config->visible_rect = Rect::From(input.visible_rect());
   config->natural_size = Size::From(input.natural_size());
   if (!input.extra_data().empty()) {
     config->extra_data = mojo::Array<uint8_t>::From(input.extra_data());
   }
-  config->encryption_scheme =
-      media::interfaces::EncryptionScheme::From(input.encryption_scheme());
+  config->is_encrypted = input.is_encrypted();
   return config;
 }
 
 // static
 media::VideoDecoderConfig
 TypeConverter<media::VideoDecoderConfig,
               media::interfaces::VideoDecoderConfigPtr>::
     Convert(const media::interfaces::VideoDecoderConfigPtr& input) {
   media::VideoDecoderConfig config;
-  config.Initialize(
-      static_cast<media::VideoCodec>(input->codec),
-      static_cast<media::VideoCodecProfile>(input->profile),
-      static_cast<media::VideoPixelFormat>(input->format),
-      static_cast<media::ColorSpace>(input->color_space),
-      input->coded_size.To<gfx::Size>(), input->visible_rect.To<gfx::Rect>(),
-      input->natural_size.To<gfx::Size>(), input->extra_data.storage(),
-      input->encryption_scheme.To<media::EncryptionScheme>());
+  config.Initialize(static_cast<media::VideoCodec>(input->codec),
+                    static_cast<media::VideoCodecProfile>(input->profile),
+                    static_cast<media::VideoPixelFormat>(input->format),
+                    static_cast<media::ColorSpace>(input->color_space),
+                    input->coded_size.To<gfx::Size>(),
+                    input->visible_rect.To<gfx::Rect>(),
+                    input->natural_size.To<gfx::Size>(),
+                    input->extra_data.storage(), input->is_encrypted);
   return config;
 }
 
 // static
 media::interfaces::CdmKeyInformationPtr TypeConverter<
     media::interfaces::CdmKeyInformationPtr,
     media::CdmKeyInformation>::Convert(const media::CdmKeyInformation& input) {
   media::interfaces::CdmKeyInformationPtr info(
       media::interfaces::CdmKeyInformation::New());
   std::vector<uint8_t> key_id_copy(input.key_id);
@@ skipping 140 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