Revert of media config: expand is_encrypted to a struct.

media/mojo/common/media_type_converters_unittest.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 <string.h>
 
 #include "base/macros.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/cdm_config.h"
 #include "media/base/decoder_buffer.h"
-#include "media/base/encryption_scheme.h"
 #include "media/base/media_util.h"
 #include "media/base/sample_format.h"
 #include "media/base/test_helpers.h"
 #include "media/base/video_frame.h"
 #include "media/mojo/common/mojo_shared_buffer_video_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 namespace {
@@ skipping 254 matching lines @@
 
 // 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);
+                    kExtraDataVector, false, base::TimeDelta(), 0);
   interfaces::AudioDecoderConfigPtr ptr(
       interfaces::AudioDecoderConfig::From(config));
   EXPECT_FALSE(ptr->extra_data.is_null());
   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);
+                    EmptyExtraData(), false, base::TimeDelta(), 0);
   interfaces::AudioDecoderConfigPtr ptr(
       interfaces::AudioDecoderConfig::From(config));
   EXPECT_TRUE(ptr->extra_data.is_null());
   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(),
+                    EmptyExtraData(),
+                    true,  // Is encrypted.
                     base::TimeDelta(), 0);
   interfaces::AudioDecoderConfigPtr ptr(
       interfaces::AudioDecoderConfig::From(config));
+  EXPECT_TRUE(ptr->is_encrypted);
   AudioDecoderConfig result(ptr.To<AudioDecoderConfig>());
+  EXPECT_TRUE(result.is_encrypted());
   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());
+                            kNaturalSize, kExtraDataVector, false);
   interfaces::VideoDecoderConfigPtr ptr(
       interfaces::VideoDecoderConfig::From(config));
   EXPECT_FALSE(ptr->extra_data.is_null());
   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());
+                            kNaturalSize, EmptyExtraData(), false);
   interfaces::VideoDecoderConfigPtr ptr(
       interfaces::VideoDecoderConfig::From(config));
   EXPECT_TRUE(ptr->extra_data.is_null());
   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());
+                            true /* is_encrypted */);
   interfaces::VideoDecoderConfigPtr ptr(
       interfaces::VideoDecoderConfig::From(config));
+  EXPECT_TRUE(ptr->is_encrypted);
   VideoDecoderConfig result(ptr.To<VideoDecoderConfig>());
+  EXPECT_TRUE(result.is_encrypted());
   EXPECT_TRUE(result.Matches(config));
 }
 
 TEST(MediaTypeConvertersTest, ConvertCdmConfig) {
   CdmConfig config;
   config.allow_distinctive_identifier = true;
   config.allow_persistent_state = false;
   config.use_hw_secure_codecs = true;
 
   interfaces::CdmConfigPtr ptr(interfaces::CdmConfig::From(config));
@@ skipping 82 matching lines @@
 
   // Convert to and back.
   interfaces::VideoFramePtr ptr(interfaces::VideoFrame::From(frame));
   scoped_refptr<VideoFrame> result(ptr.To<scoped_refptr<VideoFrame>>());
   EXPECT_NE(result.get(), nullptr);
 
   // Compare.
   CompareVideoFrames(frame, result);
 }
 
-TEST(MediaTypeConvertersTest, ConvertEncryptionSchemeAesCbcWithPattern) {
-  // Original.
-  EncryptionScheme scheme(EncryptionScheme::CIPHER_MODE_AES_CBC,
-                          EncryptionScheme::Pattern(1, 9));
-
-  // Convert to and back.
-  interfaces::EncryptionSchemePtr ptr(
-      interfaces::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