cdm_manifest_unittest.cc 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512
  1. // Copyright 2019 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/cdm/common/cdm_manifest.h"
  5. #include <stdint.h>
  6. #include <memory>
  7. #include <string>
  8. #include <vector>
  9. #include "base/containers/contains.h"
  10. #include "base/files/file_path.h"
  11. #include "base/files/file_util.h"
  12. #include "base/files/scoped_temp_dir.h"
  13. #include "base/json/json_file_value_serializer.h"
  14. #include "base/strings/string_number_conversions.h"
  15. #include "base/strings/string_util.h"
  16. #include "base/values.h"
  17. #include "base/version.h"
  18. #include "content/public/common/cdm_info.h"
  19. #include "media/cdm/api/content_decryption_module.h"
  20. #include "media/cdm/cdm_capability.h"
  21. #include "media/cdm/supported_cdm_versions.h"
  22. #include "testing/gtest/include/gtest/gtest.h"
  23. using media::CdmCapability;
  24. namespace {
  25. // These names must match what is used in cdm_manifest.cc.
  26. const char kCdmVersion[] = "version";
  27. const char kCdmModuleVersionsName[] = "x-cdm-module-versions";
  28. const char kCdmInterfaceVersionsName[] = "x-cdm-interface-versions";
  29. const char kCdmHostVersionsName[] = "x-cdm-host-versions";
  30. const char kCdmCodecsListName[] = "x-cdm-codecs";
  31. const char kCdmPersistentLicenseSupportName[] =
  32. "x-cdm-persistent-license-support";
  33. const char kCdmSupportedEncryptionSchemesName[] =
  34. "x-cdm-supported-encryption-schemes";
  35. // Version checking does change over time. Deriving these values from constants
  36. // in the code to ensure they change when the CDM interface changes.
  37. // |kSupportedCdmInterfaceVersion| and |kSupportedCdmHostVersion| are the
  38. // minimum versions supported. There may be versions after them that are also
  39. // supported.
  40. constexpr int kSupportedCdmModuleVersion = CDM_MODULE_VERSION;
  41. constexpr int kSupportedCdmInterfaceVersion =
  42. media::kSupportedCdmInterfaceVersions[0].version;
  43. static_assert(media::kSupportedCdmInterfaceVersions[0].enabled,
  44. "kSupportedCdmInterfaceVersion is not enabled by default.");
  45. constexpr int kSupportedCdmHostVersion = media::kMinSupportedCdmHostVersion;
  46. // Make a string of the values from 0 up to and including |item|.
  47. std::string MakeStringList(int item) {
  48. DCHECK_GT(item, 0);
  49. std::vector<std::string> parts;
  50. for (int i = 0; i <= item; ++i) {
  51. parts.push_back(base::NumberToString(i));
  52. }
  53. return base::JoinString(parts, ",");
  54. }
  55. base::Value MakeListValue(const std::string& item) {
  56. base::Value list(base::Value::Type::LIST);
  57. list.Append(item);
  58. return list;
  59. }
  60. base::Value MakeListValue(const std::string& item1, const std::string& item2) {
  61. base::Value list(base::Value::Type::LIST);
  62. list.Append(item1);
  63. list.Append(item2);
  64. return list;
  65. }
  66. // Create a default manifest with valid values for all entries.
  67. base::Value DefaultManifest() {
  68. base::Value dict(base::Value::Type::DICTIONARY);
  69. dict.SetStringKey(kCdmCodecsListName, "vp8,vp09,av01");
  70. dict.SetBoolKey(kCdmPersistentLicenseSupportName, true);
  71. dict.SetKey(kCdmSupportedEncryptionSchemesName,
  72. MakeListValue("cenc", "cbcs"));
  73. // The following are dependent on what the current code supports.
  74. EXPECT_TRUE(media::IsSupportedCdmModuleVersion(kSupportedCdmModuleVersion));
  75. EXPECT_TRUE(media::IsSupportedAndEnabledCdmInterfaceVersion(
  76. kSupportedCdmInterfaceVersion));
  77. EXPECT_TRUE(media::IsSupportedCdmHostVersion(kSupportedCdmHostVersion));
  78. dict.SetStringKey(kCdmModuleVersionsName,
  79. base::NumberToString(kSupportedCdmModuleVersion));
  80. dict.SetStringKey(kCdmInterfaceVersionsName,
  81. base::NumberToString(kSupportedCdmInterfaceVersion));
  82. dict.SetStringKey(kCdmHostVersionsName,
  83. base::NumberToString(kSupportedCdmHostVersion));
  84. return dict;
  85. }
  86. void CheckVideoCodecs(const media::CdmCapability::VideoCodecMap& actual,
  87. const std::vector<media::VideoCodec>& expected) {
  88. EXPECT_EQ(expected.size(), actual.size());
  89. for (const auto& [video_codec, video_codec_info] : actual) {
  90. EXPECT_TRUE(base::Contains(expected, video_codec));
  91. // As the manifest only specifies codecs and not profiles, the list of
  92. // profiles should be empty to indicate that all profiles are supported.
  93. EXPECT_TRUE(video_codec_info.supported_profiles.empty());
  94. }
  95. }
  96. void CheckAudioCodecs(const base::flat_set<media::AudioCodec>& actual,
  97. const std::vector<media::AudioCodec>& expected) {
  98. EXPECT_EQ(actual, expected);
  99. }
  100. void CheckEncryptionSchemes(
  101. const base::flat_set<media::EncryptionScheme>& actual,
  102. const std::vector<media::EncryptionScheme>& expected) {
  103. EXPECT_EQ(actual, expected);
  104. }
  105. void CheckSessionTypes(const base::flat_set<media::CdmSessionType>& actual,
  106. const std::vector<media::CdmSessionType>& expected) {
  107. EXPECT_EQ(actual, expected);
  108. }
  109. void WriteManifestToFile(const base::Value& manifest,
  110. const base::FilePath& file_path) {
  111. EXPECT_FALSE(base::PathExists(file_path));
  112. JSONFileValueSerializer serializer(file_path);
  113. EXPECT_TRUE(serializer.Serialize(manifest));
  114. EXPECT_TRUE(base::PathExists(file_path));
  115. }
  116. } // namespace
  117. TEST(CdmManifestTest, IsCompatibleWithChrome) {
  118. base::Value manifest(DefaultManifest());
  119. EXPECT_TRUE(IsCdmManifestCompatibleWithChrome(manifest));
  120. }
  121. TEST(CdmManifestTest, InCompatibleModuleVersion) {
  122. const int kUnsupportedModuleVersion = 0;
  123. EXPECT_FALSE(media::IsSupportedCdmModuleVersion(kUnsupportedModuleVersion));
  124. auto manifest = DefaultManifest();
  125. manifest.SetStringKey(kCdmModuleVersionsName,
  126. base::NumberToString(kUnsupportedModuleVersion));
  127. EXPECT_FALSE(IsCdmManifestCompatibleWithChrome(std::move(manifest)));
  128. }
  129. TEST(CdmManifestTest, InCompatibleInterfaceVersion) {
  130. const int kUnsupportedInterfaceVersion = kSupportedCdmInterfaceVersion - 1;
  131. EXPECT_FALSE(media::IsSupportedAndEnabledCdmInterfaceVersion(
  132. kUnsupportedInterfaceVersion));
  133. auto manifest = DefaultManifest();
  134. manifest.SetStringKey(kCdmInterfaceVersionsName,
  135. base::NumberToString(kUnsupportedInterfaceVersion));
  136. EXPECT_FALSE(IsCdmManifestCompatibleWithChrome(std::move(manifest)));
  137. }
  138. TEST(CdmManifestTest, InCompatibleHostVersion) {
  139. const int kUnsupportedHostVersion = kSupportedCdmHostVersion - 1;
  140. EXPECT_FALSE(media::IsSupportedCdmHostVersion(kUnsupportedHostVersion));
  141. auto manifest = DefaultManifest();
  142. manifest.SetStringKey(kCdmHostVersionsName,
  143. base::NumberToString(kUnsupportedHostVersion));
  144. EXPECT_FALSE(IsCdmManifestCompatibleWithChrome(std::move(manifest)));
  145. }
  146. TEST(CdmManifestTest, IsCompatibleWithMultipleValues) {
  147. auto manifest = DefaultManifest();
  148. manifest.SetStringKey(kCdmModuleVersionsName,
  149. MakeStringList(kSupportedCdmModuleVersion));
  150. manifest.SetStringKey(kCdmInterfaceVersionsName,
  151. MakeStringList(kSupportedCdmInterfaceVersion));
  152. manifest.SetStringKey(kCdmHostVersionsName,
  153. MakeStringList(kSupportedCdmHostVersion));
  154. EXPECT_TRUE(IsCdmManifestCompatibleWithChrome(std::move(manifest)));
  155. }
  156. TEST(CdmManifestTest, ValidManifest) {
  157. auto manifest = DefaultManifest();
  158. CdmCapability capability;
  159. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  160. CheckVideoCodecs(capability.video_codecs,
  161. {media::VideoCodec::kVP8, media::VideoCodec::kVP9,
  162. media::VideoCodec::kAV1});
  163. CheckAudioCodecs(capability.audio_codecs, {
  164. media::AudioCodec::kOpus, media::AudioCodec::kVorbis,
  165. media::AudioCodec::kFLAC,
  166. #if BUILDFLAG(USE_PROPRIETARY_CODECS)
  167. media::AudioCodec::kAAC,
  168. #endif // BUILDFLAG(USE_PROPRIETARY_CODECS)
  169. });
  170. CheckEncryptionSchemes(
  171. capability.encryption_schemes,
  172. {media::EncryptionScheme::kCenc, media::EncryptionScheme::kCbcs});
  173. CheckSessionTypes(capability.session_types,
  174. {media::CdmSessionType::kTemporary,
  175. media::CdmSessionType::kPersistentLicense});
  176. }
  177. TEST(CdmManifestTest, EmptyManifest) {
  178. base::Value manifest(base::Value::Type::DICTIONARY);
  179. CdmCapability capability;
  180. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  181. CheckVideoCodecs(capability.video_codecs, {});
  182. CheckAudioCodecs(capability.audio_codecs, {
  183. media::AudioCodec::kOpus, media::AudioCodec::kVorbis,
  184. media::AudioCodec::kFLAC,
  185. #if BUILDFLAG(USE_PROPRIETARY_CODECS)
  186. media::AudioCodec::kAAC,
  187. #endif // BUILDFLAG(USE_PROPRIETARY_CODECS)
  188. });
  189. CheckEncryptionSchemes(capability.encryption_schemes,
  190. {media::EncryptionScheme::kCenc});
  191. CheckSessionTypes(capability.session_types,
  192. {media::CdmSessionType::kTemporary});
  193. }
  194. TEST(CdmManifestTest, ManifestCodecs) {
  195. auto manifest = DefaultManifest();
  196. // Try each valid value individually.
  197. {
  198. CdmCapability capability;
  199. manifest.SetStringKey(kCdmCodecsListName, "vp8");
  200. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  201. CheckVideoCodecs(capability.video_codecs, {media::VideoCodec::kVP8});
  202. }
  203. {
  204. CdmCapability capability;
  205. manifest.SetStringKey(kCdmCodecsListName, "vp09");
  206. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  207. CheckVideoCodecs(capability.video_codecs, {media::VideoCodec::kVP9});
  208. }
  209. {
  210. CdmCapability capability;
  211. manifest.SetStringKey(kCdmCodecsListName, "av01");
  212. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  213. CheckVideoCodecs(capability.video_codecs, {media::VideoCodec::kAV1});
  214. }
  215. #if BUILDFLAG(USE_PROPRIETARY_CODECS)
  216. {
  217. CdmCapability capability;
  218. manifest.SetStringKey(kCdmCodecsListName, "avc1");
  219. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  220. CheckVideoCodecs(capability.video_codecs, {media::VideoCodec::kH264});
  221. }
  222. #endif
  223. {
  224. // Try list of everything (except proprietary codecs).
  225. CdmCapability capability;
  226. manifest.SetStringKey(kCdmCodecsListName, "vp8,vp09,av01");
  227. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  228. CheckVideoCodecs(capability.video_codecs,
  229. {media::VideoCodec::kVP8, media::VideoCodec::kVP9,
  230. media::VideoCodec::kAV1});
  231. }
  232. {
  233. // Empty codecs list result in empty list.
  234. CdmCapability capability;
  235. manifest.SetStringKey(kCdmCodecsListName, "");
  236. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  237. CheckVideoCodecs(capability.video_codecs, {});
  238. }
  239. {
  240. // Note that invalid codec values are simply skipped.
  241. CdmCapability capability;
  242. manifest.SetStringKey(kCdmCodecsListName, "invalid,av01");
  243. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  244. CheckVideoCodecs(capability.video_codecs, {media::VideoCodec::kAV1});
  245. }
  246. {
  247. // Legacy: "vp9.0" was used to support VP9 profile 0 (no profile 2 support).
  248. // Now this has been deprecated and "vp9.0" becomes an invalid codec value.
  249. CdmCapability capability;
  250. manifest.SetStringKey(kCdmCodecsListName, "vp9.0");
  251. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  252. CheckVideoCodecs(capability.video_codecs, {});
  253. }
  254. {
  255. // Wrong types are an error.
  256. CdmCapability capability;
  257. manifest.SetBoolKey(kCdmCodecsListName, true);
  258. EXPECT_FALSE(ParseCdmManifest(manifest, &capability));
  259. }
  260. {
  261. // Missing entry is OK, but list is empty.
  262. CdmCapability capability;
  263. EXPECT_TRUE(manifest.RemoveKey(kCdmCodecsListName));
  264. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  265. CheckVideoCodecs(capability.video_codecs, {});
  266. }
  267. }
  268. TEST(CdmManifestTest, ManifestEncryptionSchemes) {
  269. auto manifest = DefaultManifest();
  270. // Try each valid value individually.
  271. {
  272. CdmCapability capability;
  273. manifest.SetKey(kCdmSupportedEncryptionSchemesName, MakeListValue("cenc"));
  274. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  275. CheckEncryptionSchemes(capability.encryption_schemes,
  276. {media::EncryptionScheme::kCenc});
  277. }
  278. {
  279. CdmCapability capability;
  280. manifest.SetKey(kCdmSupportedEncryptionSchemesName, MakeListValue("cbcs"));
  281. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  282. CheckEncryptionSchemes(capability.encryption_schemes,
  283. {media::EncryptionScheme::kCbcs});
  284. }
  285. {
  286. // Try multiple valid entries.
  287. CdmCapability capability;
  288. manifest.SetKey(kCdmSupportedEncryptionSchemesName,
  289. MakeListValue("cenc", "cbcs"));
  290. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  291. CheckEncryptionSchemes(
  292. capability.encryption_schemes,
  293. {media::EncryptionScheme::kCenc, media::EncryptionScheme::kCbcs});
  294. }
  295. {
  296. // Invalid encryption schemes are ignored. However, if value specified then
  297. // there must be at least 1 valid value.
  298. CdmCapability capability;
  299. manifest.SetKey(kCdmSupportedEncryptionSchemesName,
  300. MakeListValue("invalid"));
  301. EXPECT_FALSE(ParseCdmManifest(manifest, &capability));
  302. }
  303. {
  304. CdmCapability capability;
  305. manifest.SetKey(kCdmSupportedEncryptionSchemesName,
  306. MakeListValue("invalid", "cenc"));
  307. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  308. CheckEncryptionSchemes(capability.encryption_schemes,
  309. {media::EncryptionScheme::kCenc});
  310. }
  311. {
  312. // Wrong types are an error.
  313. CdmCapability capability;
  314. manifest.SetBoolKey(kCdmSupportedEncryptionSchemesName, true);
  315. EXPECT_FALSE(ParseCdmManifest(manifest, &capability));
  316. }
  317. {
  318. // Missing values default to "cenc".
  319. CdmCapability capability;
  320. EXPECT_TRUE(manifest.RemoveKey(kCdmSupportedEncryptionSchemesName));
  321. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  322. CheckEncryptionSchemes(capability.encryption_schemes,
  323. {media::EncryptionScheme::kCenc});
  324. }
  325. }
  326. TEST(CdmManifestTest, ManifestSessionTypes) {
  327. auto manifest = DefaultManifest();
  328. {
  329. // Try false (persistent license not supported).
  330. CdmCapability capability;
  331. manifest.SetBoolKey(kCdmPersistentLicenseSupportName, false);
  332. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  333. CheckSessionTypes(capability.session_types,
  334. {media::CdmSessionType::kTemporary});
  335. }
  336. {
  337. // Try true (persistent license is supported).
  338. CdmCapability capability;
  339. manifest.SetBoolKey(kCdmPersistentLicenseSupportName, true);
  340. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  341. CheckSessionTypes(capability.session_types,
  342. {media::CdmSessionType::kTemporary,
  343. media::CdmSessionType::kPersistentLicense});
  344. }
  345. {
  346. // Wrong types are an error.
  347. CdmCapability capability;
  348. manifest.SetStringKey(kCdmPersistentLicenseSupportName, "true");
  349. EXPECT_FALSE(ParseCdmManifest(manifest, &capability));
  350. }
  351. {
  352. // Missing values default to "temporary".
  353. CdmCapability capability;
  354. EXPECT_TRUE(manifest.RemoveKey(kCdmPersistentLicenseSupportName));
  355. EXPECT_TRUE(ParseCdmManifest(manifest, &capability));
  356. CheckSessionTypes(capability.session_types,
  357. {media::CdmSessionType::kTemporary});
  358. }
  359. }
  360. TEST(CdmManifestTest, FileManifest) {
  361. const char kVersion[] = "1.2.3.4";
  362. base::ScopedTempDir temp_dir;
  363. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  364. auto manifest_path = temp_dir.GetPath().AppendASCII("manifest.json");
  365. // Manifests read from a file also need a version.
  366. auto manifest = DefaultManifest();
  367. manifest.SetStringKey(kCdmVersion, kVersion);
  368. WriteManifestToFile(manifest, manifest_path);
  369. base::Version version;
  370. CdmCapability capability;
  371. EXPECT_TRUE(ParseCdmManifestFromPath(manifest_path, &version, &capability));
  372. EXPECT_TRUE(version.IsValid());
  373. EXPECT_EQ(version.GetString(), kVersion);
  374. CheckVideoCodecs(capability.video_codecs,
  375. {media::VideoCodec::kVP8, media::VideoCodec::kVP9,
  376. media::VideoCodec::kAV1});
  377. CheckEncryptionSchemes(
  378. capability.encryption_schemes,
  379. {media::EncryptionScheme::kCenc, media::EncryptionScheme::kCbcs});
  380. CheckSessionTypes(capability.session_types,
  381. {media::CdmSessionType::kTemporary,
  382. media::CdmSessionType::kPersistentLicense});
  383. }
  384. TEST(CdmManifestTest, FileManifestNoVersion) {
  385. base::ScopedTempDir temp_dir;
  386. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  387. auto manifest_path = temp_dir.GetPath().AppendASCII("manifest.json");
  388. auto manifest = DefaultManifest();
  389. WriteManifestToFile(manifest, manifest_path);
  390. base::Version version;
  391. CdmCapability capability;
  392. EXPECT_FALSE(ParseCdmManifestFromPath(manifest_path, &version, &capability));
  393. }
  394. TEST(CdmManifestTest, FileManifestBadVersion) {
  395. base::ScopedTempDir temp_dir;
  396. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  397. auto manifest_path = temp_dir.GetPath().AppendASCII("manifest.json");
  398. auto manifest = DefaultManifest();
  399. manifest.SetStringKey(kCdmVersion, "bad version");
  400. WriteManifestToFile(manifest, manifest_path);
  401. base::Version version;
  402. CdmCapability capability;
  403. EXPECT_FALSE(ParseCdmManifestFromPath(manifest_path, &version, &capability));
  404. }
  405. TEST(CdmManifestTest, FileManifestDoesNotExist) {
  406. base::ScopedTempDir temp_dir;
  407. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  408. auto manifest_path = temp_dir.GetPath().AppendASCII("manifest.json");
  409. base::Version version;
  410. CdmCapability capability;
  411. EXPECT_FALSE(ParseCdmManifestFromPath(manifest_path, &version, &capability));
  412. }
  413. TEST(CdmManifestTest, FileManifestEmpty) {
  414. base::ScopedTempDir temp_dir;
  415. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  416. auto manifest_path = temp_dir.GetPath().AppendASCII("manifest.json");
  417. base::Value manifest(base::Value::Type::DICTIONARY);
  418. WriteManifestToFile(manifest, manifest_path);
  419. base::Version version;
  420. CdmCapability capability;
  421. EXPECT_FALSE(ParseCdmManifestFromPath(manifest_path, &version, &capability));
  422. }
  423. TEST(CdmManifestTest, FileManifestLite) {
  424. base::ScopedTempDir temp_dir;
  425. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  426. auto manifest_path = temp_dir.GetPath().AppendASCII("manifest.json");
  427. // Only a version plus fields to satisfy compatibility are required in the
  428. // manifest to parse correctly.
  429. base::Value manifest(base::Value::Type::DICTIONARY);
  430. manifest.SetStringKey(kCdmVersion, "1.2.3.4");
  431. manifest.SetStringKey(kCdmModuleVersionsName,
  432. base::NumberToString(kSupportedCdmModuleVersion));
  433. manifest.SetStringKey(kCdmInterfaceVersionsName,
  434. base::NumberToString(kSupportedCdmInterfaceVersion));
  435. manifest.SetStringKey(kCdmHostVersionsName,
  436. base::NumberToString(kSupportedCdmHostVersion));
  437. WriteManifestToFile(manifest, manifest_path);
  438. base::Version version;
  439. CdmCapability capability;
  440. EXPECT_TRUE(ParseCdmManifestFromPath(manifest_path, &version, &capability));
  441. CheckVideoCodecs(capability.video_codecs, {});
  442. CheckEncryptionSchemes(capability.encryption_schemes,
  443. {media::EncryptionScheme::kCenc});
  444. CheckSessionTypes(capability.session_types,
  445. {media::CdmSessionType::kTemporary});
  446. }
  447. TEST(CdmManifestTest, FileManifestNotDictionary) {
  448. base::ScopedTempDir temp_dir;
  449. ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  450. auto manifest_path = temp_dir.GetPath().AppendASCII("manifest.json");
  451. base::Value manifest("not a dictionary");
  452. WriteManifestToFile(manifest, manifest_path);
  453. base::Version version;
  454. CdmCapability capability;
  455. EXPECT_FALSE(ParseCdmManifestFromPath(manifest_path, &version, &capability));
  456. }