blob: b1657e577670811998cff36a8590ba8913684223 [file] [log] [blame]
// Copyright 2013 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/base/key_systems.h"
#include <stddef.h>
#include <memory>
#include "base/containers/hash_tables.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/strings/string_util.h"
#include "base/threading/thread_checker.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "media/base/key_system_names.h"
#include "media/base/key_system_properties.h"
#include "media/base/media.h"
#include "media/base/media_client.h"
#include "media/base/media_switches.h"
#include "media/media_buildflags.h"
#include "third_party/widevine/cdm/widevine_cdm_common.h"
namespace media {
const char kClearKeyKeySystem[] = "org.w3.clearkey";
// These names are used by UMA. Do not change them!
const char kClearKeyKeySystemNameForUMA[] = "ClearKey";
const char kUnknownKeySystemNameForUMA[] = "Unknown";
struct MimeTypeToCodecs {
const char* mime_type;
SupportedCodecs codecs;
};
// Mapping between containers and their codecs.
// Only audio codecs can belong to a "audio/*" mime_type, and only video codecs
// can belong to a "video/*" mime_type.
static const MimeTypeToCodecs kMimeTypeToCodecsMap[] = {
{"audio/webm", EME_CODEC_WEBM_AUDIO_ALL},
{"video/webm", EME_CODEC_WEBM_VIDEO_ALL},
{"audio/mp4", EME_CODEC_MP4_AUDIO_ALL},
{"video/mp4", EME_CODEC_MP4_VIDEO_ALL},
#if BUILDFLAG(USE_PROPRIETARY_CODECS)
#if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
{"video/mp2t", EME_CODEC_MP2T_VIDEO_ALL},
#endif // BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
#endif // BUILDFLAG(USE_PROPRIETARY_CODECS)
}; // namespace media
struct NameToCodec {
const char* name;
EmeCodec codec;
};
// Mapping between codec names and enum values.
static const NameToCodec kCodecMap[] = {
{"opus", EME_CODEC_OPUS}, // Opus.
{"vorbis", EME_CODEC_VORBIS}, // Vorbis.
{"vp8", EME_CODEC_VP8}, // VP8.
{"vp8.0", EME_CODEC_VP8}, // VP8.
{"vp9", EME_CODEC_LEGACY_VP9}, // VP9.
{"vp9.0", EME_CODEC_LEGACY_VP9}, // VP9.
{"vp09", EME_CODEC_VP9}, // New multi-part VP9 for WebM and MP4.
{"flac", EME_CODEC_FLAC}, // FLAC.
#if BUILDFLAG(USE_PROPRIETARY_CODECS)
{"mp4a", EME_CODEC_AAC}, // AAC.
#if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
{"ac-3", EME_CODEC_AC3}, // AC3.
{"ec-3", EME_CODEC_EAC3}, // EAC3.
#endif
#if BUILDFLAG(ENABLE_MPEG_H_AUDIO_DEMUXING)
{"mhm1", EME_CODEC_MPEG_H_AUDIO}, // MPEG-H Audio.
#endif
{"avc1", EME_CODEC_AVC1}, // AVC1 for MP4 and MP2T
{"avc3", EME_CODEC_AVC1}, // AVC3 for MP4 and MP2T
#if BUILDFLAG(ENABLE_HEVC_DEMUXING)
{"hev1", EME_CODEC_HEVC}, // HEV1.
{"hvc1", EME_CODEC_HEVC}, // HVC1.
#endif
#if BUILDFLAG(ENABLE_DOLBY_VISION_DEMUXING)
{"dva1", EME_CODEC_DOLBY_VISION_AVC}, // DolbyVision AVC
{"dvav", EME_CODEC_DOLBY_VISION_AVC}, // DolbyVision AVC
#if BUILDFLAG(ENABLE_HEVC_DEMUXING)
{"dvh1", EME_CODEC_DOLBY_VISION_HEVC}, // DolbyVision HEVC
{"dvhe", EME_CODEC_DOLBY_VISION_HEVC}, // DolbyVision HEVC
#endif
#endif
#endif // BUILDFLAG(USE_PROPRIETARY_CODECS)
};
class ClearKeyProperties : public KeySystemProperties {
public:
std::string GetKeySystemName() const override { return kClearKeyKeySystem; }
bool IsSupportedInitDataType(EmeInitDataType init_data_type) const override {
return init_data_type == EmeInitDataType::CENC ||
init_data_type == EmeInitDataType::WEBM ||
init_data_type == EmeInitDataType::KEYIDS;
}
media::EmeConfigRule GetEncryptionSchemeConfigRule(
media::EncryptionMode encryption_scheme) const override {
switch (encryption_scheme) {
case media::EncryptionMode::kCenc:
case media::EncryptionMode::kCbcs:
return media::EmeConfigRule::SUPPORTED;
case media::EncryptionMode::kUnencrypted:
break;
}
NOTREACHED();
return media::EmeConfigRule::NOT_SUPPORTED;
}
SupportedCodecs GetSupportedCodecs() const override {
// On Android, Vorbis, VP8, AAC and AVC1 are supported in MediaCodec:
// http://developer.android.com/guide/appendix/media-formats.html
// VP9 support is device dependent.
return EME_CODEC_WEBM_ALL | EME_CODEC_MP4_ALL;
}
EmeConfigRule GetRobustnessConfigRule(
EmeMediaType media_type,
const std::string& requested_robustness) const override {
return requested_robustness.empty() ? EmeConfigRule::SUPPORTED
: EmeConfigRule::NOT_SUPPORTED;
}
EmeSessionTypeSupport GetPersistentLicenseSessionSupport() const override {
return EmeSessionTypeSupport::NOT_SUPPORTED;
}
EmeSessionTypeSupport GetPersistentUsageRecordSessionSupport()
const override {
return EmeSessionTypeSupport::NOT_SUPPORTED;
}
EmeFeatureSupport GetPersistentStateSupport() const override {
return EmeFeatureSupport::NOT_SUPPORTED;
}
EmeFeatureSupport GetDistinctiveIdentifierSupport() const override {
return EmeFeatureSupport::NOT_SUPPORTED;
}
bool UseAesDecryptor() const override { return true; }
};
// Returns whether the |key_system| is known to Chromium and is thus likely to
// be implemented in an interoperable way.
// True is always returned for a |key_system| that begins with "x-".
//
// As with other web platform features, advertising support for a key system
// implies that it adheres to a defined and interoperable specification.
//
// To ensure interoperability, implementations of a specific |key_system| string
// must conform to a specification for that identifier that defines
// key system-specific behaviors not fully defined by the EME specification.
// That specification should be provided by the owner of the domain that is the
// reverse of the |key_system| string.
// This involves more than calling a library, SDK, or platform API.
// KeySystemsImpl must be populated appropriately, and there will likely be glue
// code to adapt to the API of the library, SDK, or platform API.
//
// Chromium mainline contains this data and glue code for specific key systems,
// which should help ensure interoperability with other implementations using
// these key systems.
//
// If you need to add support for other key systems, ensure that you have
// obtained the specification for how to integrate it with EME, implemented the
// appropriate glue/adapter code, and added all the appropriate data to
// KeySystemsImpl. Only then should you change this function.
static bool IsPotentiallySupportedKeySystem(const std::string& key_system) {
// Known and supported key systems.
if (key_system == kWidevineKeySystem)
return true;
if (key_system == kClearKeyKeySystem)
return true;
// External Clear Key is known and supports suffixes for testing.
if (IsExternalClearKey(key_system))
return true;
// Chromecast defines behaviors for Cast clients within its reverse domain.
const char kChromecastRoot[] = "com.chromecast";
if (IsChildKeySystemOf(key_system, kChromecastRoot))
return true;
// Implementations that do not have a specification or appropriate glue code
// can use the "x-" prefix to avoid conflicting with and advertising support
// for real key system names. Use is discouraged.
const char kExcludedPrefix[] = "x-";
return base::StartsWith(key_system, kExcludedPrefix,
base::CompareCase::SENSITIVE);
}
class KeySystemsImpl : public KeySystems {
public:
static KeySystemsImpl* GetInstance();
void UpdateIfNeeded();
std::string GetKeySystemNameForUMA(const std::string& key_system) const;
// These two functions are for testing purpose only.
void AddCodecMask(EmeMediaType media_type,
const std::string& codec,
uint32_t mask);
void AddMimeTypeCodecMask(const std::string& mime_type, uint32_t mask);
// Implementation of KeySystems interface.
bool IsSupportedKeySystem(const std::string& key_system) const override;
bool CanUseAesDecryptor(const std::string& key_system) const override;
bool IsSupportedInitDataType(const std::string& key_system,
EmeInitDataType init_data_type) const override;
EmeConfigRule GetEncryptionSchemeConfigRule(
const std::string& key_system,
EncryptionMode encryption_scheme) const override;
EmeConfigRule GetContentTypeConfigRule(
const std::string& key_system,
EmeMediaType media_type,
const std::string& container_mime_type,
const std::vector<std::string>& codecs) const override;
EmeConfigRule GetRobustnessConfigRule(
const std::string& key_system,
EmeMediaType media_type,
const std::string& requested_robustness) const override;
EmeSessionTypeSupport GetPersistentLicenseSessionSupport(
const std::string& key_system) const override;
EmeSessionTypeSupport GetPersistentUsageRecordSessionSupport(
const std::string& key_system) const override;
EmeFeatureSupport GetPersistentStateSupport(
const std::string& key_system) const override;
EmeFeatureSupport GetDistinctiveIdentifierSupport(
const std::string& key_system) const override;
private:
KeySystemsImpl();
~KeySystemsImpl() override;
void InitializeUMAInfo();
void UpdateSupportedKeySystems();
void AddSupportedKeySystems(
std::vector<std::unique_ptr<KeySystemProperties>> key_systems);
void RegisterMimeType(const std::string& mime_type, SupportedCodecs codecs);
bool IsValidMimeTypeCodecsCombination(const std::string& mime_type,
SupportedCodecs codecs) const;
typedef base::hash_map<std::string, std::unique_ptr<KeySystemProperties>>
KeySystemPropertiesMap;
typedef base::hash_map<std::string, SupportedCodecs> MimeTypeToCodecsMap;
typedef base::hash_map<std::string, EmeCodec> CodecMap;
typedef base::hash_map<std::string, EmeInitDataType> InitDataTypesMap;
// TODO(sandersd): Separate container enum from codec mask value.
// http://crbug.com/417440
// Potentially pass EmeMediaType and a container enum.
SupportedCodecs GetCodecMaskForMimeType(
const std::string& container_mime_type) const;
EmeCodec GetCodecForString(const std::string& codec) const;
// Map from key system string to KeySystemProperties instance.
KeySystemPropertiesMap key_system_properties_map_;
// This member should only be modified by RegisterMimeType().
MimeTypeToCodecsMap mime_type_to_codecs_map_;
CodecMap codec_map_;
SupportedCodecs audio_codec_mask_;
SupportedCodecs video_codec_mask_;
// Makes sure all methods are called from the same thread.
base::ThreadChecker thread_checker_;
DISALLOW_COPY_AND_ASSIGN(KeySystemsImpl);
};
KeySystemsImpl* KeySystemsImpl::GetInstance() {
static KeySystemsImpl* key_systems = new KeySystemsImpl();
key_systems->UpdateIfNeeded();
return key_systems;
}
// Because we use a thread-safe static, the key systems info must be populated
// when the instance is constructed.
KeySystemsImpl::KeySystemsImpl()
: audio_codec_mask_(EME_CODEC_AUDIO_ALL),
video_codec_mask_(EME_CODEC_VIDEO_ALL) {
for (size_t i = 0; i < arraysize(kCodecMap); ++i) {
const std::string& name = kCodecMap[i].name;
DCHECK(!codec_map_.count(name));
codec_map_[name] = kCodecMap[i].codec;
}
for (size_t i = 0; i < arraysize(kMimeTypeToCodecsMap); ++i) {
RegisterMimeType(kMimeTypeToCodecsMap[i].mime_type,
kMimeTypeToCodecsMap[i].codecs);
}
// Always update supported key systems during construction.
UpdateSupportedKeySystems();
}
KeySystemsImpl::~KeySystemsImpl() = default;
SupportedCodecs KeySystemsImpl::GetCodecMaskForMimeType(
const std::string& container_mime_type) const {
auto iter = mime_type_to_codecs_map_.find(container_mime_type);
if (iter == mime_type_to_codecs_map_.end())
return EME_CODEC_NONE;
DCHECK(IsValidMimeTypeCodecsCombination(container_mime_type, iter->second));
return iter->second;
}
EmeCodec KeySystemsImpl::GetCodecForString(const std::string& codec) const {
auto iter = codec_map_.find(codec);
if (iter != codec_map_.end())
return iter->second;
return EME_CODEC_NONE;
}
void KeySystemsImpl::UpdateIfNeeded() {
if (GetMediaClient() && GetMediaClient()->IsKeySystemsUpdateNeeded())
UpdateSupportedKeySystems();
}
void KeySystemsImpl::UpdateSupportedKeySystems() {
DCHECK(thread_checker_.CalledOnValidThread());
key_system_properties_map_.clear();
std::vector<std::unique_ptr<KeySystemProperties>> key_systems_properties;
// Add key systems supported by the MediaClient implementation.
if (GetMediaClient()) {
GetMediaClient()->AddSupportedKeySystems(&key_systems_properties);
} else {
DVLOG(1) << __func__ << " No media client to provide key systems";
}
// Clear Key is always supported.
key_systems_properties.emplace_back(new ClearKeyProperties());
AddSupportedKeySystems(std::move(key_systems_properties));
}
// Returns whether distinctive identifiers and persistent state can be reliably
// blocked for |properties| (and therefore be safely configurable).
static bool CanBlock(const KeySystemProperties& properties) {
// When AesDecryptor is used, we are sure we can block.
if (properties.UseAesDecryptor())
return true;
// For External Clear Key, it is either implemented as a library CDM (Clear
// Key CDM), which is covered above, or by using AesDecryptor remotely, e.g.
// via MojoCdm. In both cases, we can block. This is only used for testing.
if (base::FeatureList::IsEnabled(media::kExternalClearKeyForTesting) &&
IsExternalClearKey(properties.GetKeySystemName()))
return true;
#if BUILDFLAG(ENABLE_LIBRARY_CDMS)
// When library CDMs are enabled, we are either using AesDecryptor, or using
// the library CDM hosted in a sandboxed process. In both cases distinctive
// identifiers and persistent state can be reliably blocked.
return true;
#else
// For other platforms assume the CDM can and will do anything. So we cannot
// block.
return false;
#endif
}
void KeySystemsImpl::AddSupportedKeySystems(
std::vector<std::unique_ptr<KeySystemProperties>> key_systems) {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(key_system_properties_map_.empty());
for (auto& properties : key_systems) {
DCHECK(!properties->GetKeySystemName().empty());
DCHECK(properties->GetPersistentLicenseSessionSupport() !=
EmeSessionTypeSupport::INVALID);
DCHECK(properties->GetPersistentUsageRecordSessionSupport() !=
EmeSessionTypeSupport::INVALID);
DCHECK(properties->GetPersistentStateSupport() !=
EmeFeatureSupport::INVALID);
DCHECK(properties->GetDistinctiveIdentifierSupport() !=
EmeFeatureSupport::INVALID);
if (!IsPotentiallySupportedKeySystem(properties->GetKeySystemName())) {
// If you encounter this path, see the comments for the function above.
DLOG(ERROR) << "Unsupported name '" << properties->GetKeySystemName()
<< "'. See code comments.";
continue;
}
// Supporting persistent state is a prerequisite for supporting persistent
// sessions.
if (properties->GetPersistentStateSupport() ==
EmeFeatureSupport::NOT_SUPPORTED) {
DCHECK(properties->GetPersistentLicenseSessionSupport() ==
EmeSessionTypeSupport::NOT_SUPPORTED);
DCHECK(properties->GetPersistentUsageRecordSessionSupport() ==
EmeSessionTypeSupport::NOT_SUPPORTED);
}
// If distinctive identifiers are not supported, then no other features can
// require them.
if (properties->GetDistinctiveIdentifierSupport() ==
EmeFeatureSupport::NOT_SUPPORTED) {
DCHECK(properties->GetPersistentLicenseSessionSupport() !=
EmeSessionTypeSupport::SUPPORTED_WITH_IDENTIFIER);
DCHECK(properties->GetPersistentUsageRecordSessionSupport() !=
EmeSessionTypeSupport::SUPPORTED_WITH_IDENTIFIER);
}
if (!CanBlock(*properties)) {
DCHECK(properties->GetDistinctiveIdentifierSupport() ==
EmeFeatureSupport::ALWAYS_ENABLED);
DCHECK(properties->GetPersistentStateSupport() ==
EmeFeatureSupport::ALWAYS_ENABLED);
}
DCHECK_EQ(key_system_properties_map_.count(properties->GetKeySystemName()),
0u)
<< "Key system '" << properties->GetKeySystemName()
<< "' already registered";
#if defined(OS_ANDROID)
// Ensure that the renderer can access the decoders necessary to use the
// key system.
if (!properties->UseAesDecryptor() && !HasPlatformDecoderSupport()) {
DLOG(WARNING) << properties->GetKeySystemName() << " not registered";
continue;
}
#endif // defined(OS_ANDROID)
DVLOG(1) << __func__
<< ": Adding key system:" << properties->GetKeySystemName();
key_system_properties_map_[properties->GetKeySystemName()] =
std::move(properties);
}
}
// Adds the MIME type with the codec mask after verifying the validity.
// Only this function should modify |mime_type_to_codecs_map_|.
void KeySystemsImpl::RegisterMimeType(const std::string& mime_type,
SupportedCodecs codecs) {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(!mime_type_to_codecs_map_.count(mime_type));
DCHECK(IsValidMimeTypeCodecsCombination(mime_type, codecs))
<< ": mime_type = " << mime_type << ", codecs = " << codecs;
mime_type_to_codecs_map_[mime_type] = codecs;
}
// Returns whether |mime_type| follows a valid format and the specified codecs
// are of the correct type based on |*_codec_mask_|.
// Only audio/ or video/ MIME types with their respective codecs are allowed.
bool KeySystemsImpl::IsValidMimeTypeCodecsCombination(
const std::string& mime_type,
SupportedCodecs codecs) const {
DCHECK(thread_checker_.CalledOnValidThread());
if (codecs == EME_CODEC_NONE)
return true;
if (base::StartsWith(mime_type, "audio/", base::CompareCase::SENSITIVE))
return !(codecs & ~audio_codec_mask_);
if (base::StartsWith(mime_type, "video/", base::CompareCase::SENSITIVE))
return !(codecs & ~video_codec_mask_);
return false;
}
bool KeySystemsImpl::IsSupportedInitDataType(
const std::string& key_system,
EmeInitDataType init_data_type) const {
DCHECK(thread_checker_.CalledOnValidThread());
auto key_system_iter = key_system_properties_map_.find(key_system);
if (key_system_iter == key_system_properties_map_.end()) {
NOTREACHED();
return false;
}
return key_system_iter->second->IsSupportedInitDataType(init_data_type);
}
EmeConfigRule KeySystemsImpl::GetEncryptionSchemeConfigRule(
const std::string& key_system,
EncryptionMode encryption_scheme) const {
DCHECK(thread_checker_.CalledOnValidThread());
auto key_system_iter = key_system_properties_map_.find(key_system);
if (key_system_iter == key_system_properties_map_.end()) {
NOTREACHED();
return EmeConfigRule::NOT_SUPPORTED;
}
return key_system_iter->second->GetEncryptionSchemeConfigRule(
encryption_scheme);
}
std::string KeySystemsImpl::GetKeySystemNameForUMA(
const std::string& key_system) const {
DCHECK(thread_checker_.CalledOnValidThread());
// Here we maintain a short list of known key systems to facilitate UMA
// reporting. Mentioned key systems are not necessarily supported by
// the current platform.
if (key_system == kWidevineKeySystem)
return kWidevineKeySystemNameForUMA;
if (key_system == kClearKeyKeySystem)
return kClearKeyKeySystemNameForUMA;
return kUnknownKeySystemNameForUMA;
}
void KeySystemsImpl::AddCodecMask(EmeMediaType media_type,
const std::string& codec,
uint32_t mask) {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(!codec_map_.count(codec));
codec_map_[codec] = static_cast<EmeCodec>(mask);
if (media_type == EmeMediaType::AUDIO) {
audio_codec_mask_ |= mask;
} else {
video_codec_mask_ |= mask;
}
}
void KeySystemsImpl::AddMimeTypeCodecMask(const std::string& mime_type,
uint32_t codecs_mask) {
RegisterMimeType(mime_type, static_cast<EmeCodec>(codecs_mask));
}
bool KeySystemsImpl::IsSupportedKeySystem(const std::string& key_system) const {
DCHECK(thread_checker_.CalledOnValidThread());
if (!key_system_properties_map_.count(key_system))
return false;
return true;
}
bool KeySystemsImpl::CanUseAesDecryptor(const std::string& key_system) const {
DCHECK(thread_checker_.CalledOnValidThread());
auto key_system_iter = key_system_properties_map_.find(key_system);
if (key_system_iter == key_system_properties_map_.end()) {
DLOG(ERROR) << key_system << " is not a known key system";
return false;
}
return key_system_iter->second->UseAesDecryptor();
}
EmeConfigRule KeySystemsImpl::GetContentTypeConfigRule(
const std::string& key_system,
EmeMediaType media_type,
const std::string& container_mime_type,
const std::vector<std::string>& codecs) const {
DCHECK(thread_checker_.CalledOnValidThread());
// Make sure the container MIME type matches |media_type|.
switch (media_type) {
case EmeMediaType::AUDIO:
if (!base::StartsWith(container_mime_type, "audio/",
base::CompareCase::SENSITIVE))
return EmeConfigRule::NOT_SUPPORTED;
break;
case EmeMediaType::VIDEO:
if (!base::StartsWith(container_mime_type, "video/",
base::CompareCase::SENSITIVE))
return EmeConfigRule::NOT_SUPPORTED;
break;
}
// Double check whether the key system is supported.
auto key_system_iter = key_system_properties_map_.find(key_system);
if (key_system_iter == key_system_properties_map_.end()) {
NOTREACHED()
<< "KeySystemConfigSelector should've checked key system support";
return EmeConfigRule::NOT_SUPPORTED;
}
// Look up the key system's supported codecs and secure codecs.
SupportedCodecs key_system_codec_mask =
key_system_iter->second->GetSupportedCodecs();
SupportedCodecs key_system_hw_secure_codec_mask =
key_system_iter->second->GetSupportedHwSecureCodecs();
// Check that the container is supported by the key system. (This check is
// necessary because |codecs| may be empty.)
SupportedCodecs mime_type_codec_mask =
GetCodecMaskForMimeType(container_mime_type);
if ((key_system_codec_mask & mime_type_codec_mask) == 0) {
DVLOG(2) << " Container " << container_mime_type << " not supported by "
<< key_system;
return EmeConfigRule::NOT_SUPPORTED;
}
// Check that the codecs are supported by the key system and container based
// on the following rule:
// SupportedCodecs | SupportedSecureCodecs | Result
// yes | yes | SUPPORTED
// yes | no | HW_SECURE_CODECS_NOT_ALLOWED
// no | any | NOT_SUPPORTED
EmeConfigRule support = EmeConfigRule::SUPPORTED;
for (size_t i = 0; i < codecs.size(); i++) {
SupportedCodecs codec = GetCodecForString(codecs[i]);
if ((codec & key_system_codec_mask & mime_type_codec_mask) == 0) {
DVLOG(2) << " Container/codec pair (" << container_mime_type << " / "
<< codecs[i] << ") not supported by " << key_system;
return EmeConfigRule::NOT_SUPPORTED;
}
// Check whether the codec supports a hardware-secure mode. The goal is to
// prevent mixing of non-hardware-secure codecs with hardware-secure codecs,
// since the mode is fixed at CDM creation.
//
// Because the check for regular codec support is early-exit, we don't have
// to consider codecs that are only supported in hardware-secure mode. We
// could do so, and make use of HW_SECURE_CODECS_REQUIRED, if it turns out
// that hardware-secure-only codecs actually exist and are useful.
if ((codec & key_system_hw_secure_codec_mask) == 0)
support = EmeConfigRule::HW_SECURE_CODECS_NOT_ALLOWED;
}
return support;
}
EmeConfigRule KeySystemsImpl::GetRobustnessConfigRule(
const std::string& key_system,
EmeMediaType media_type,
const std::string& requested_robustness) const {
DCHECK(thread_checker_.CalledOnValidThread());
auto key_system_iter = key_system_properties_map_.find(key_system);
if (key_system_iter == key_system_properties_map_.end()) {
NOTREACHED();
return EmeConfigRule::NOT_SUPPORTED;
}
return key_system_iter->second->GetRobustnessConfigRule(media_type,
requested_robustness);
}
EmeSessionTypeSupport KeySystemsImpl::GetPersistentLicenseSessionSupport(
const std::string& key_system) const {
DCHECK(thread_checker_.CalledOnValidThread());
auto key_system_iter = key_system_properties_map_.find(key_system);
if (key_system_iter == key_system_properties_map_.end()) {
NOTREACHED();
return EmeSessionTypeSupport::INVALID;
}
return key_system_iter->second->GetPersistentLicenseSessionSupport();
}
EmeSessionTypeSupport KeySystemsImpl::GetPersistentUsageRecordSessionSupport(
const std::string& key_system) const {
DCHECK(thread_checker_.CalledOnValidThread());
auto key_system_iter = key_system_properties_map_.find(key_system);
if (key_system_iter == key_system_properties_map_.end()) {
NOTREACHED();
return EmeSessionTypeSupport::INVALID;
}
return key_system_iter->second->GetPersistentUsageRecordSessionSupport();
}
EmeFeatureSupport KeySystemsImpl::GetPersistentStateSupport(
const std::string& key_system) const {
DCHECK(thread_checker_.CalledOnValidThread());
auto key_system_iter = key_system_properties_map_.find(key_system);
if (key_system_iter == key_system_properties_map_.end()) {
NOTREACHED();
return EmeFeatureSupport::INVALID;
}
return key_system_iter->second->GetPersistentStateSupport();
}
EmeFeatureSupport KeySystemsImpl::GetDistinctiveIdentifierSupport(
const std::string& key_system) const {
DCHECK(thread_checker_.CalledOnValidThread());
auto key_system_iter = key_system_properties_map_.find(key_system);
if (key_system_iter == key_system_properties_map_.end()) {
NOTREACHED();
return EmeFeatureSupport::INVALID;
}
return key_system_iter->second->GetDistinctiveIdentifierSupport();
}
KeySystems* KeySystems::GetInstance() {
return KeySystemsImpl::GetInstance();
}
//------------------------------------------------------------------------------
bool IsSupportedKeySystemWithInitDataType(const std::string& key_system,
EmeInitDataType init_data_type) {
return KeySystemsImpl::GetInstance()->IsSupportedInitDataType(key_system,
init_data_type);
}
std::string GetKeySystemNameForUMA(const std::string& key_system) {
return KeySystemsImpl::GetInstance()->GetKeySystemNameForUMA(key_system);
}
bool CanUseAesDecryptor(const std::string& key_system) {
return KeySystemsImpl::GetInstance()->CanUseAesDecryptor(key_system);
}
// These two functions are for testing purpose only. The declaration in the
// header file is guarded by "#if defined(UNIT_TEST)" so that they can be used
// by tests but not non-test code. However, this .cc file is compiled as part of
// "media" where "UNIT_TEST" is not defined. So we need to specify
// "MEDIA_EXPORT" here again so that they are visible to tests.
MEDIA_EXPORT void AddCodecMask(EmeMediaType media_type,
const std::string& codec,
uint32_t mask) {
KeySystemsImpl::GetInstance()->AddCodecMask(media_type, codec, mask);
}
MEDIA_EXPORT void AddMimeTypeCodecMask(const std::string& mime_type,
uint32_t mask) {
KeySystemsImpl::GetInstance()->AddMimeTypeCodecMask(mime_type, mask);
}
} // namespace media