blob: 18edcfc791666ca96106c26e0ea7da64d8b27472 [file] [log] [blame]
// 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 "cobalt/media/blink/key_system_config_selector.h"
#include <utility>
#include "base/bind.h"
#include "base/logging.h"
#include "base/string_util.h"
#include "base/utf_string_conversions.h"
#include "cobalt/media/base/cdm_config.h"
#include "cobalt/media/base/key_systems.h"
#include "cobalt/media/base/media_permission.h"
#include "cobalt/media/base/mime_util.h"
#include "cobalt/media/blink/webmediaplayer_util.h"
#include "googleurl/src/gurl.h"
#include "starboard/types.h"
#include "third_party/WebKit/public/platform/URLConversion.h"
#include "third_party/WebKit/public/platform/WebMediaKeySystemConfiguration.h"
#include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
#include "third_party/WebKit/public/platform/WebString.h"
#include "third_party/WebKit/public/platform/WebVector.h"
namespace cobalt {
namespace media {
using EmeFeatureRequirement =
blink::WebMediaKeySystemConfiguration::Requirement;
namespace {
static EmeConfigRule GetSessionTypeConfigRule(EmeSessionTypeSupport support) {
switch (support) {
case EmeSessionTypeSupport::INVALID:
NOTREACHED();
return EmeConfigRule::NOT_SUPPORTED;
case EmeSessionTypeSupport::NOT_SUPPORTED:
return EmeConfigRule::NOT_SUPPORTED;
case EmeSessionTypeSupport::SUPPORTED_WITH_IDENTIFIER:
return EmeConfigRule::IDENTIFIER_AND_PERSISTENCE_REQUIRED;
case EmeSessionTypeSupport::SUPPORTED:
return EmeConfigRule::PERSISTENCE_REQUIRED;
}
NOTREACHED();
return EmeConfigRule::NOT_SUPPORTED;
}
static EmeConfigRule GetDistinctiveIdentifierConfigRule(
EmeFeatureSupport support, EmeFeatureRequirement requirement) {
if (support == EmeFeatureSupport::INVALID) {
NOTREACHED();
return EmeConfigRule::NOT_SUPPORTED;
}
// For NOT_ALLOWED and REQUIRED, the result is as expected. For OPTIONAL, we
// return the most restrictive rule that is not more restrictive than for
// NOT_ALLOWED or REQUIRED. Those values will be checked individually when
// the option is resolved.
//
// NOT_ALLOWED OPTIONAL REQUIRED
// NOT_SUPPORTED I_NOT_ALLOWED I_NOT_ALLOWED NOT_SUPPORTED
// REQUESTABLE I_NOT_ALLOWED SUPPORTED I_REQUIRED
// ALWAYS_ENABLED NOT_SUPPORTED I_REQUIRED I_REQUIRED
DCHECK(support == EmeFeatureSupport::NOT_SUPPORTED ||
support == EmeFeatureSupport::REQUESTABLE ||
support == EmeFeatureSupport::ALWAYS_ENABLED);
DCHECK(requirement == EmeFeatureRequirement::NotAllowed ||
requirement == EmeFeatureRequirement::Optional ||
requirement == EmeFeatureRequirement::Required);
if ((support == EmeFeatureSupport::NOT_SUPPORTED &&
requirement == EmeFeatureRequirement::Required) ||
(support == EmeFeatureSupport::ALWAYS_ENABLED &&
requirement == EmeFeatureRequirement::NotAllowed)) {
return EmeConfigRule::NOT_SUPPORTED;
}
if (support == EmeFeatureSupport::REQUESTABLE &&
requirement == EmeFeatureRequirement::Optional) {
return EmeConfigRule::SUPPORTED;
}
if (support == EmeFeatureSupport::NOT_SUPPORTED ||
requirement == EmeFeatureRequirement::NotAllowed) {
return EmeConfigRule::IDENTIFIER_NOT_ALLOWED;
}
return EmeConfigRule::IDENTIFIER_REQUIRED;
}
static EmeConfigRule GetPersistentStateConfigRule(
EmeFeatureSupport support, EmeFeatureRequirement requirement) {
if (support == EmeFeatureSupport::INVALID) {
NOTREACHED();
return EmeConfigRule::NOT_SUPPORTED;
}
// For NOT_ALLOWED and REQUIRED, the result is as expected. For OPTIONAL, we
// return the most restrictive rule that is not more restrictive than for
// NOT_ALLOWED or REQUIRED. Those values will be checked individually when
// the option is resolved.
//
// Note that even though a distinctive identifier can not be required for
// persistent state, it may still be required for persistent sessions.
//
// NOT_ALLOWED OPTIONAL REQUIRED
// NOT_SUPPORTED P_NOT_ALLOWED P_NOT_ALLOWED NOT_SUPPORTED
// REQUESTABLE P_NOT_ALLOWED SUPPORTED P_REQUIRED
// ALWAYS_ENABLED NOT_SUPPORTED P_REQUIRED P_REQUIRED
DCHECK(support == EmeFeatureSupport::NOT_SUPPORTED ||
support == EmeFeatureSupport::REQUESTABLE ||
support == EmeFeatureSupport::ALWAYS_ENABLED);
DCHECK(requirement == EmeFeatureRequirement::NotAllowed ||
requirement == EmeFeatureRequirement::Optional ||
requirement == EmeFeatureRequirement::Required);
if ((support == EmeFeatureSupport::NOT_SUPPORTED &&
requirement == EmeFeatureRequirement::Required) ||
(support == EmeFeatureSupport::ALWAYS_ENABLED &&
requirement == EmeFeatureRequirement::NotAllowed)) {
return EmeConfigRule::NOT_SUPPORTED;
}
if (support == EmeFeatureSupport::REQUESTABLE &&
requirement == EmeFeatureRequirement::Optional) {
return EmeConfigRule::SUPPORTED;
}
if (support == EmeFeatureSupport::NOT_SUPPORTED ||
requirement == EmeFeatureRequirement::NotAllowed) {
return EmeConfigRule::PERSISTENCE_NOT_ALLOWED;
}
return EmeConfigRule::PERSISTENCE_REQUIRED;
}
static bool IsPersistentSessionType(
blink::WebEncryptedMediaSessionType sessionType) {
switch (sessionType) {
case blink::WebEncryptedMediaSessionType::Temporary:
return false;
case blink::WebEncryptedMediaSessionType::PersistentLicense:
return true;
case blink::WebEncryptedMediaSessionType::PersistentReleaseMessage:
return true;
case blink::WebEncryptedMediaSessionType::Unknown:
break;
}
NOTREACHED();
return false;
}
} // namespace
struct KeySystemConfigSelector::SelectionRequest {
std::string key_system;
blink::WebVector<blink::WebMediaKeySystemConfiguration>
candidate_configurations;
blink::WebSecurityOrigin security_origin;
base::Callback<void(const blink::WebMediaKeySystemConfiguration&,
const CdmConfig&)> succeeded_cb;
base::Callback<void(const blink::WebString&)> not_supported_cb;
bool was_permission_requested = false;
bool is_permission_granted = false;
bool are_secure_codecs_supported = false;
};
// Accumulates configuration rules to determine if a feature (additional
// configuration rule) can be added to an accumulated configuration.
class KeySystemConfigSelector::ConfigState {
public:
ConfigState(bool was_permission_requested, bool is_permission_granted)
: was_permission_requested_(was_permission_requested),
is_permission_granted_(is_permission_granted) {}
bool IsPermissionGranted() const { return is_permission_granted_; }
// Permission is possible if it has not been denied.
bool IsPermissionPossible() const {
return is_permission_granted_ || !was_permission_requested_;
}
bool IsIdentifierRequired() const { return is_identifier_required_; }
bool IsIdentifierRecommended() const { return is_identifier_recommended_; }
bool AreHwSecureCodecsRequired() const {
return are_hw_secure_codecs_required_;
}
// Checks whether a rule is compatible with all previously added rules.
bool IsRuleSupported(EmeConfigRule rule) const {
switch (rule) {
case EmeConfigRule::NOT_SUPPORTED:
return false;
case EmeConfigRule::IDENTIFIER_NOT_ALLOWED:
return !is_identifier_required_;
case EmeConfigRule::IDENTIFIER_REQUIRED:
// TODO(sandersd): Confirm if we should be refusing these rules when
// permission has been denied (as the spec currently says).
return !is_identifier_not_allowed_ && IsPermissionPossible();
case EmeConfigRule::IDENTIFIER_RECOMMENDED:
return true;
case EmeConfigRule::PERSISTENCE_NOT_ALLOWED:
return !is_persistence_required_;
case EmeConfigRule::PERSISTENCE_REQUIRED:
return !is_persistence_not_allowed_;
case EmeConfigRule::IDENTIFIER_AND_PERSISTENCE_REQUIRED:
return (!is_identifier_not_allowed_ && IsPermissionPossible() &&
!is_persistence_not_allowed_);
case EmeConfigRule::HW_SECURE_CODECS_NOT_ALLOWED:
return !are_hw_secure_codecs_required_;
case EmeConfigRule::HW_SECURE_CODECS_REQUIRED:
return !are_hw_secure_codecs_not_allowed_;
case EmeConfigRule::SUPPORTED:
return true;
}
NOTREACHED();
return false;
}
// Add a rule to the accumulated configuration state.
void AddRule(EmeConfigRule rule) {
DCHECK(IsRuleSupported(rule));
switch (rule) {
case EmeConfigRule::NOT_SUPPORTED:
NOTREACHED();
return;
case EmeConfigRule::IDENTIFIER_NOT_ALLOWED:
is_identifier_not_allowed_ = true;
return;
case EmeConfigRule::IDENTIFIER_REQUIRED:
is_identifier_required_ = true;
return;
case EmeConfigRule::IDENTIFIER_RECOMMENDED:
is_identifier_recommended_ = true;
return;
case EmeConfigRule::PERSISTENCE_NOT_ALLOWED:
is_persistence_not_allowed_ = true;
return;
case EmeConfigRule::PERSISTENCE_REQUIRED:
is_persistence_required_ = true;
return;
case EmeConfigRule::IDENTIFIER_AND_PERSISTENCE_REQUIRED:
is_identifier_required_ = true;
is_persistence_required_ = true;
return;
case EmeConfigRule::HW_SECURE_CODECS_NOT_ALLOWED:
are_hw_secure_codecs_not_allowed_ = true;
return;
case EmeConfigRule::HW_SECURE_CODECS_REQUIRED:
are_hw_secure_codecs_required_ = true;
return;
case EmeConfigRule::SUPPORTED:
return;
}
NOTREACHED();
}
private:
// Whether permission to use a distinctive identifier was requested. If set,
// |is_permission_granted_| represents the final decision.
// (Not changed by adding rules.)
bool was_permission_requested_;
// Whether permission to use a distinctive identifier has been granted.
// (Not changed by adding rules.)
bool is_permission_granted_;
// Whether a rule has been added that requires or blocks a distinctive
// identifier.
bool is_identifier_required_ = false;
bool is_identifier_not_allowed_ = false;
// Whether a rule has been added that recommends a distinctive identifier.
bool is_identifier_recommended_ = false;
// Whether a rule has been added that requires or blocks persistent state.
bool is_persistence_required_ = false;
bool is_persistence_not_allowed_ = false;
// Whether a rule has been added that requires or blocks hardware-secure
// codecs.
bool are_hw_secure_codecs_required_ = false;
bool are_hw_secure_codecs_not_allowed_ = false;
};
KeySystemConfigSelector::KeySystemConfigSelector(
const KeySystems* key_systems, MediaPermission* media_permission)
: key_systems_(key_systems),
media_permission_(media_permission),
weak_factory_(this) {
DCHECK(key_systems_);
DCHECK(media_permission_);
}
KeySystemConfigSelector::~KeySystemConfigSelector() {}
bool IsSupportedMediaFormat(const std::string& container_mime_type,
const std::string& codecs, bool use_aes_decryptor) {
std::vector<std::string> codec_vector;
ParseCodecString(codecs, &codec_vector, false);
// AesDecryptor decrypts the stream in the demuxer before it reaches the
// decoder so check whether the media format is supported when clear.
SupportsType support_result =
use_aes_decryptor
? IsSupportedMediaFormat(container_mime_type, codec_vector)
: IsSupportedEncryptedMediaFormat(container_mime_type, codec_vector);
switch (support_result) {
case IsSupported:
return true;
case MayBeSupported:
// If no codecs were specified, the best possible result is
// MayBeSupported, indicating support for the container.
return codec_vector.empty();
case IsNotSupported:
return false;
}
NOTREACHED();
return false;
}
// TODO(sandersd): Move contentType parsing from Blink to here so that invalid
// parameters can be rejected. http://crbug.com/417561
bool KeySystemConfigSelector::IsSupportedContentType(
const std::string& key_system, EmeMediaType media_type,
const std::string& container_mime_type, const std::string& codecs,
KeySystemConfigSelector::ConfigState* config_state) {
// From RFC6838: "Both top-level type and subtype names are case-insensitive."
std::string container_lower = base::ToLowerASCII(container_mime_type);
// contentTypes must provide a codec string unless the container implies a
// particular codec. For EME, none of the currently supported containers
// imply a codec, so |codecs| must be provided.
if (codecs.empty()) {
// Since the spec didn't initially require this, add an exemption for
// some existing containers to give clients time to adapt.
// TODO(jrummell): Remove this exemption once the number of contentTypes
// without codecs drops low enough (UMA added in the blink code).
// http://crbug.com/605661.
if (container_lower != "audio/webm" && container_lower != "video/webm" &&
container_lower != "audio/mp4" && container_lower != "video/mp4") {
return false;
}
}
// Check that |container_mime_type| and |codecs| are supported by Chrome. This
// is done primarily to validate extended codecs, but it also ensures that the
// CDM cannot support codecs that Chrome does not (which could complicate the
// robustness algorithm).
if (!IsSupportedMediaFormat(container_lower, codecs,
CanUseAesDecryptor(key_system))) {
return false;
}
// Check that |container_mime_type| and |codecs| are supported by the CDM.
// This check does not handle extended codecs, so extended codec information
// is stripped (extended codec information was checked above).
std::vector<std::string> stripped_codec_vector;
ParseCodecString(codecs, &stripped_codec_vector, true);
EmeConfigRule codecs_rule = key_systems_->GetContentTypeConfigRule(
key_system, media_type, container_lower, stripped_codec_vector);
if (!config_state->IsRuleSupported(codecs_rule)) return false;
config_state->AddRule(codecs_rule);
return true;
}
bool KeySystemConfigSelector::GetSupportedCapabilities(
const std::string& key_system, EmeMediaType media_type,
const blink::WebVector<blink::WebMediaKeySystemMediaCapability>&
requested_media_capabilities,
KeySystemConfigSelector::ConfigState* config_state,
std::vector<blink::WebMediaKeySystemMediaCapability>*
supported_media_capabilities) {
// From
// https://w3c.github.io/encrypted-media/#get-supported-capabilities-for-media-type
// 1. Let local accumulated capabilities be a local copy of partial
// configuration.
// (Skipped as we directly update |config_state|. This is safe because we
// only do so when at least one requested media capability is supported.)
// 2. Let supported media capabilities be empty.
DCHECK_EQ(supported_media_capabilities->size(), 0ul);
// 3. For each value in requested media capabilities:
for (size_t i = 0; i < requested_media_capabilities.size(); i++) {
// 3.1. Let contentType be the value's contentType member.
// 3.2. Let robustness be the value's robustness member.
const blink::WebMediaKeySystemMediaCapability& capability =
requested_media_capabilities[i];
// 3.3. If contentType is the empty string, return null.
if (capability.mimeType.isEmpty()) {
DVLOG(2) << "Rejecting requested configuration because "
<< "a capability contentType was empty.";
return false;
}
// 3.4-3.11. (Implemented by IsSupportedContentType().)
ConfigState proposed_config_state = *config_state;
if (!base::IsStringASCII(capability.mimeType) ||
!base::IsStringASCII(capability.codecs) ||
!IsSupportedContentType(
key_system, media_type,
base::UTF16ToASCII(base::StringPiece16(capability.mimeType)),
base::UTF16ToASCII(base::StringPiece16(capability.codecs)),
&proposed_config_state)) {
continue;
}
// 3.12. If robustness is not the empty string, run the following steps:
if (!capability.robustness.isEmpty()) {
// 3.12.1. If robustness is an unrecognized value or not supported by
// implementation, continue to the next iteration. String
// comparison is case-sensitive.
if (!base::IsStringASCII(capability.robustness)) continue;
EmeConfigRule robustness_rule = key_systems_->GetRobustnessConfigRule(
key_system, media_type,
base::UTF16ToASCII(base::StringPiece16(capability.robustness)));
if (!proposed_config_state.IsRuleSupported(robustness_rule)) continue;
proposed_config_state.AddRule(robustness_rule);
// 3.12.2. Add robustness to configuration.
// (It's already added, we use capability as configuration.)
}
// 3.13. If the user agent and implementation do not support playback of
// encrypted media data as specified by configuration, including all
// media types, in combination with local accumulated capabilities,
// continue to the next iteration.
// (This is handled when adding rules to |proposed_config_state|.)
// 3.14. Add configuration to supported media capabilities.
supported_media_capabilities->push_back(capability);
// 3.15. Add configuration to local accumulated capabilities.
*config_state = proposed_config_state;
}
// 4. If supported media capabilities is empty, return null.
if (supported_media_capabilities->empty()) {
DVLOG(2) << "Rejecting requested configuration because "
<< "no capabilities were supported.";
return false;
}
// 5. Return media type capabilities.
return true;
}
KeySystemConfigSelector::ConfigurationSupport
KeySystemConfigSelector::GetSupportedConfiguration(
const std::string& key_system,
const blink::WebMediaKeySystemConfiguration& candidate,
ConfigState* config_state,
blink::WebMediaKeySystemConfiguration* accumulated_configuration) {
// From
// http://w3c.github.io/encrypted-media/#get-supported-configuration-and-consent
// 1. Let accumulated configuration be a new MediaKeySystemConfiguration
// dictionary. (Done by caller.)
// 2. Set the label member of accumulated configuration to equal the label
// member of candidate configuration.
accumulated_configuration->label = candidate.label;
// 3. If the initDataTypes member of candidate configuration is non-empty,
// run the following steps:
if (!candidate.initDataTypes.isEmpty()) {
// 3.1. Let supported types be an empty sequence of DOMStrings.
std::vector<blink::WebEncryptedMediaInitDataType> supported_types;
// 3.2. For each value in candidate configuration's initDataTypes member:
for (size_t i = 0; i < candidate.initDataTypes.size(); i++) {
// 3.2.1. Let initDataType be the value.
blink::WebEncryptedMediaInitDataType init_data_type =
candidate.initDataTypes[i];
// 3.2.2. If the implementation supports generating requests based on
// initDataType, add initDataType to supported types. String
// comparison is case-sensitive. The empty string is never
// supported.
if (key_systems_->IsSupportedInitDataType(
key_system, ConvertToEmeInitDataType(init_data_type))) {
supported_types.push_back(init_data_type);
}
}
// 3.3. If supported types is empty, return null.
if (supported_types.empty()) {
DVLOG(2) << "Rejecting requested configuration because "
<< "no initDataType values were supported.";
return CONFIGURATION_NOT_SUPPORTED;
}
// 3.4. Set the initDataTypes member of accumulated configuration to
// supported types.
accumulated_configuration->initDataTypes = supported_types;
}
// 4. Let distinctive identifier requirement be the value of candidate
// configuration's distinctiveIdentifier member.
EmeFeatureRequirement distinctive_identifier =
candidate.distinctiveIdentifier;
// 5. If distinctive identifier requirement is "optional" and Distinctive
// Identifiers are not allowed according to restrictions, set distinctive
// identifier requirement to "not-allowed".
EmeFeatureSupport distinctive_identifier_support =
key_systems_->GetDistinctiveIdentifierSupport(key_system);
if (distinctive_identifier == EmeFeatureRequirement::Optional) {
if (distinctive_identifier_support == EmeFeatureSupport::INVALID ||
distinctive_identifier_support == EmeFeatureSupport::NOT_SUPPORTED) {
distinctive_identifier = EmeFeatureRequirement::NotAllowed;
}
}
// 6. Follow the steps for distinctive identifier requirement from the
// following list:
// - "required": If the implementation does not support use of
// Distinctive Identifier(s) in combination with accumulated
// configuration and restrictions, return NotSupported.
// - "optional": Continue with the following steps.
// - "not-allowed": If the implementation requires use Distinctive
// Identifier(s) or Distinctive Permanent Identifier(s) in
// combination with accumulated configuration and restrictions,
// return NotSupported.
// We also reject OPTIONAL when distinctive identifiers are ALWAYS_ENABLED and
// permission has already been denied. This would happen anyway later.
EmeConfigRule di_rule = GetDistinctiveIdentifierConfigRule(
distinctive_identifier_support, distinctive_identifier);
if (!config_state->IsRuleSupported(di_rule)) {
DVLOG(2) << "Rejecting requested configuration because "
<< "the distinctiveIdentifier requirement was not supported.";
return CONFIGURATION_NOT_SUPPORTED;
}
config_state->AddRule(di_rule);
// 7. Set the distinctiveIdentifier member of accumulated configuration to
// equal distinctive identifier requirement.
accumulated_configuration->distinctiveIdentifier = distinctive_identifier;
// 8. Let persistent state requirement be equal to the value of candidate
// configuration's persistentState member.
EmeFeatureRequirement persistent_state = candidate.persistentState;
// 9. If persistent state requirement is "optional" and persisting state is
// not allowed according to restrictions, set persistent state requirement
// to "not-allowed".
EmeFeatureSupport persistent_state_support =
key_systems_->GetPersistentStateSupport(key_system);
if (persistent_state == EmeFeatureRequirement::Optional) {
if (persistent_state_support == EmeFeatureSupport::INVALID ||
persistent_state_support == EmeFeatureSupport::NOT_SUPPORTED) {
persistent_state = EmeFeatureRequirement::NotAllowed;
}
}
// 10. Follow the steps for persistent state requirement from the following
// list:
// - "required": If the implementation does not support persisting
// state in combination with accumulated configuration and
// restrictions, return NotSupported.
// - "optional": Continue with the following steps.
// - "not-allowed": If the implementation requires persisting state in
// combination with accumulated configuration and restrictions,
// return NotSupported.
EmeConfigRule ps_rule =
GetPersistentStateConfigRule(persistent_state_support, persistent_state);
if (!config_state->IsRuleSupported(ps_rule)) {
DVLOG(2) << "Rejecting requested configuration because "
<< "the persistentState requirement was not supported.";
return CONFIGURATION_NOT_SUPPORTED;
}
config_state->AddRule(ps_rule);
// 11. Set the persistentState member of accumulated configuration to equal
// the value of persistent state requirement.
accumulated_configuration->persistentState = persistent_state;
// 12. Follow the steps for the first matching condition from the following
// list:
// - If the sessionTypes member is present in candidate configuration,
// let session types be candidate configuration's sessionTypes member.
// - Otherwise, let session types be [ "temporary" ].
// (Done in MediaKeySystemAccessInitializer.)
blink::WebVector<blink::WebEncryptedMediaSessionType> session_types =
candidate.sessionTypes;
// 13. For each value in session types:
for (size_t i = 0; i < session_types.size(); i++) {
// 13.1. Let session type be the value.
blink::WebEncryptedMediaSessionType session_type = session_types[i];
// 13.2. If accumulated configuration's persistentState value is
// "not-allowed" and the Is persistent session type? algorithm
// returns true for session type return NotSupported.
if (accumulated_configuration->persistentState ==
EmeFeatureRequirement::NotAllowed &&
IsPersistentSessionType(session_type)) {
DVLOG(2) << "Rejecting requested configuration because persistent "
"sessions are not allowed.";
return CONFIGURATION_NOT_SUPPORTED;
}
// 13.3. If the implementation does not support session type in combination
// with accumulated configuration and restrictions for other reasons,
// return NotSupported.
EmeConfigRule session_type_rule = EmeConfigRule::NOT_SUPPORTED;
switch (session_type) {
case blink::WebEncryptedMediaSessionType::Unknown:
DVLOG(2) << "Rejecting requested configuration because "
<< "a required session type was not recognized.";
return CONFIGURATION_NOT_SUPPORTED;
case blink::WebEncryptedMediaSessionType::Temporary:
session_type_rule = EmeConfigRule::SUPPORTED;
break;
case blink::WebEncryptedMediaSessionType::PersistentLicense:
session_type_rule = GetSessionTypeConfigRule(
key_systems_->GetPersistentLicenseSessionSupport(key_system));
break;
case blink::WebEncryptedMediaSessionType::PersistentReleaseMessage:
session_type_rule = GetSessionTypeConfigRule(
key_systems_->GetPersistentReleaseMessageSessionSupport(
key_system));
break;
}
if (!config_state->IsRuleSupported(session_type_rule)) {
DVLOG(2) << "Rejecting requested configuration because "
<< "a required session type was not supported.";
return CONFIGURATION_NOT_SUPPORTED;
}
config_state->AddRule(session_type_rule);
// 13.4. If accumulated configuration's persistentState value is "optional"
// and the result of running the Is persistent session type?
// algorithm on session type is true, change accumulated
// configuration's persistentState value to "required".
if (accumulated_configuration->persistentState ==
EmeFeatureRequirement::Optional &&
IsPersistentSessionType(session_type)) {
accumulated_configuration->persistentState =
EmeFeatureRequirement::Required;
}
}
// 14. Set the sessionTypes member of accumulated configuration to
// session types.
accumulated_configuration->sessionTypes = session_types;
// 15. If the videoCapabilities and audioCapabilities members in candidate
// configuration are both empty, return NotSupported.
// TODO(jrummell): Enforce this once the deprecation warning is removed.
// See http://crbug.com/616233.
// 16. If the videoCapabilities member in candidate configuration is
// non-empty:
std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities;
if (!candidate.videoCapabilities.isEmpty()) {
// 16.1. Let video capabilities be the result of executing the Get
// Supported Capabilities for Audio/Video Type algorithm on Video,
// candidate configuration's videoCapabilities member, accumulated
// configuration, and restrictions.
// 16.2. If video capabilities is null, return NotSupported.
if (!GetSupportedCapabilities(key_system, EmeMediaType::VIDEO,
candidate.videoCapabilities, config_state,
&video_capabilities)) {
return CONFIGURATION_NOT_SUPPORTED;
}
// 16.3. Set the videoCapabilities member of accumulated configuration
// to video capabilities.
accumulated_configuration->videoCapabilities = video_capabilities;
} else {
// Otherwise set the videoCapabilities member of accumulated configuration
// to an empty sequence.
accumulated_configuration->videoCapabilities = video_capabilities;
}
// 17. If the audioCapabilities member in candidate configuration is
// non-empty:
std::vector<blink::WebMediaKeySystemMediaCapability> audio_capabilities;
if (!candidate.audioCapabilities.isEmpty()) {
// 17.1. Let audio capabilities be the result of executing the Get
// Supported Capabilities for Audio/Video Type algorithm on Audio,
// candidate configuration's audioCapabilities member, accumulated
// configuration, and restrictions.
// 17.2. If audio capabilities is null, return NotSupported.
if (!GetSupportedCapabilities(key_system, EmeMediaType::AUDIO,
candidate.audioCapabilities, config_state,
&audio_capabilities)) {
return CONFIGURATION_NOT_SUPPORTED;
}
// 17.3. Set the audioCapabilities member of accumulated configuration
// to audio capabilities.
accumulated_configuration->audioCapabilities = audio_capabilities;
} else {
// Otherwise set the audioCapabilities member of accumulated configuration
// to an empty sequence.
accumulated_configuration->audioCapabilities = audio_capabilities;
}
// 18. If accumulated configuration's distinctiveIdentifier value is
// "optional", follow the steps for the first matching condition
// from the following list:
// - If the implementation requires use Distinctive Identifier(s) or
// Distinctive Permanent Identifier(s) for any of the combinations
// in accumulated configuration, change accumulated configuration's
// distinctiveIdentifier value to "required".
// - Otherwise, change accumulated configuration's
// distinctiveIdentifier value to "not-allowed".
if (accumulated_configuration->distinctiveIdentifier ==
EmeFeatureRequirement::Optional) {
EmeConfigRule not_allowed_rule = GetDistinctiveIdentifierConfigRule(
key_systems_->GetDistinctiveIdentifierSupport(key_system),
EmeFeatureRequirement::NotAllowed);
EmeConfigRule required_rule = GetDistinctiveIdentifierConfigRule(
key_systems_->GetDistinctiveIdentifierSupport(key_system),
EmeFeatureRequirement::Required);
bool not_allowed_supported =
config_state->IsRuleSupported(not_allowed_rule);
bool required_supported = config_state->IsRuleSupported(required_rule);
// If a distinctive identifier is recommend and that is a possible outcome,
// prefer that.
if (required_supported && config_state->IsIdentifierRecommended() &&
config_state->IsPermissionPossible()) {
not_allowed_supported = false;
}
if (not_allowed_supported) {
accumulated_configuration->distinctiveIdentifier =
EmeFeatureRequirement::NotAllowed;
config_state->AddRule(not_allowed_rule);
} else if (required_supported) {
accumulated_configuration->distinctiveIdentifier =
EmeFeatureRequirement::Required;
config_state->AddRule(required_rule);
} else {
// We should not have passed step 6.
NOTREACHED();
return CONFIGURATION_NOT_SUPPORTED;
}
}
// 19. If accumulated configuration's persistentState value is "optional",
// follow the steps for the first matching condition from the following
// list:
// - If the implementation requires persisting state for any of the
// combinations in accumulated configuration, change accumulated
// configuration's persistentState value to "required".
// - Otherwise, change accumulated configuration's persistentState
// value to "not-allowed".
if (accumulated_configuration->persistentState ==
EmeFeatureRequirement::Optional) {
EmeConfigRule not_allowed_rule = GetPersistentStateConfigRule(
key_systems_->GetPersistentStateSupport(key_system),
EmeFeatureRequirement::NotAllowed);
EmeConfigRule required_rule = GetPersistentStateConfigRule(
key_systems_->GetPersistentStateSupport(key_system),
EmeFeatureRequirement::Required);
// |distinctiveIdentifier| should not be affected after it is decided.
DCHECK(not_allowed_rule == EmeConfigRule::NOT_SUPPORTED ||
not_allowed_rule == EmeConfigRule::PERSISTENCE_NOT_ALLOWED);
DCHECK(required_rule == EmeConfigRule::NOT_SUPPORTED ||
required_rule == EmeConfigRule::PERSISTENCE_REQUIRED);
bool not_allowed_supported =
config_state->IsRuleSupported(not_allowed_rule);
bool required_supported = config_state->IsRuleSupported(required_rule);
if (not_allowed_supported) {
accumulated_configuration->persistentState =
EmeFeatureRequirement::NotAllowed;
config_state->AddRule(not_allowed_rule);
} else if (required_supported) {
accumulated_configuration->persistentState =
EmeFeatureRequirement::Required;
config_state->AddRule(required_rule);
} else {
// We should not have passed step 5.
NOTREACHED();
return CONFIGURATION_NOT_SUPPORTED;
}
}
// 20. If implementation in the configuration specified by the combination of
// the values in accumulated configuration is not supported or not allowed
// in the origin, return NotSupported.
// TODO(jrummell): can we check that the CDM can't be loaded by the origin?
// 21. If accumulated configuration's distinctiveIdentifier value is
// "required" and the Distinctive Identifier(s) associated with
// accumulated configuration are not unique per origin and profile
// and clearable:
// 21.1. Update restrictions to reflect that all configurations described
// by accumulated configuration do not have user consent.
// 21.2. Return ConsentDenied and restrictions.
// (Not required as data is unique per origin and clearable.)
// 22. Let consent status and updated restrictions be the result of running
// the Get Consent Status algorithm on accumulated configuration,
// restrictions and origin and follow the steps for the value of consent
// status from the following list:
// - "ConsentDenied": Return ConsentDenied and updated restrictions.
// - "InformUser": Inform the user that accumulated configuration is
// in use in the origin including, specifically, the information
// that Distinctive Identifier(s) and/or Distinctive Permanent
// Identifier(s) as appropriate will be used if the
// distinctiveIdentifier member of accumulated configuration is
// "required". Continue to the next step.
// - "Allowed": Continue to the next step.
// Accumulated configuration's distinctiveIdentifier should be "required" or
// "notallowed"" due to step 18. If it is "required", prompt the user for
// consent unless it has already been granted.
if (accumulated_configuration->distinctiveIdentifier ==
EmeFeatureRequirement::Required) {
// The caller is responsible for resolving what to do if permission is
// required but has been denied (it should treat it as NOT_SUPPORTED).
if (!config_state->IsPermissionGranted())
return CONFIGURATION_REQUIRES_PERMISSION;
}
// 23. Return accumulated configuration.
return CONFIGURATION_SUPPORTED;
}
void KeySystemConfigSelector::SelectConfig(
const blink::WebString& key_system,
const blink::WebVector<blink::WebMediaKeySystemConfiguration>&
candidate_configurations,
const blink::WebSecurityOrigin& security_origin,
bool are_secure_codecs_supported,
base::Callback<void(const blink::WebMediaKeySystemConfiguration&,
const CdmConfig&)> succeeded_cb,
base::Callback<void(const blink::WebString&)> not_supported_cb) {
// Continued from requestMediaKeySystemAccess(), step 6, from
// https://w3c.github.io/encrypted-media/#requestmediakeysystemaccess
//
// 6.1 If keySystem is not one of the Key Systems supported by the user
// agent, reject promise with a NotSupportedError. String comparison
// is case-sensitive.
if (!base::IsStringASCII(key_system)) {
not_supported_cb.Run("Only ASCII keySystems are supported");
return;
}
std::string key_system_ascii =
base::UTF16ToASCII(base::StringPiece16(key_system));
if (!key_systems_->IsSupportedKeySystem(key_system_ascii)) {
not_supported_cb.Run("Unsupported keySystem");
return;
}
// 6.2-6.4. Implemented by OnSelectConfig().
// TODO(sandersd): This should be async, ideally not on the main thread.
std::unique_ptr<SelectionRequest> request(new SelectionRequest());
request->key_system = key_system_ascii;
request->candidate_configurations = candidate_configurations;
request->security_origin = security_origin;
request->are_secure_codecs_supported = are_secure_codecs_supported;
request->succeeded_cb = succeeded_cb;
request->not_supported_cb = not_supported_cb;
SelectConfigInternal(std::move(request));
}
void KeySystemConfigSelector::SelectConfigInternal(
std::unique_ptr<SelectionRequest> request) {
// Continued from requestMediaKeySystemAccess(), step 6, from
// https://w3c.github.io/encrypted-media/#requestmediakeysystemaccess
//
// 6.2. Let implementation be the implementation of keySystem.
// (|key_systems_| fills this role.)
// 6.3. For each value in supportedConfigurations:
for (size_t i = 0; i < request->candidate_configurations.size(); i++) {
// 6.3.1. Let candidate configuration be the value.
// 6.3.2. Let supported configuration be the result of executing the Get
// Supported Configuration algorithm on implementation, candidate
// configuration, and origin.
// 6.3.3. If supported configuration is not NotSupported, [initialize
// and return a new MediaKeySystemAccess object.]
ConfigState config_state(request->was_permission_requested,
request->is_permission_granted);
DCHECK(config_state.IsRuleSupported(
EmeConfigRule::HW_SECURE_CODECS_NOT_ALLOWED));
if (!request->are_secure_codecs_supported)
config_state.AddRule(EmeConfigRule::HW_SECURE_CODECS_NOT_ALLOWED);
blink::WebMediaKeySystemConfiguration accumulated_configuration;
CdmConfig cdm_config;
ConfigurationSupport support = GetSupportedConfiguration(
request->key_system, request->candidate_configurations[i],
&config_state, &accumulated_configuration);
switch (support) {
case CONFIGURATION_NOT_SUPPORTED:
continue;
case CONFIGURATION_REQUIRES_PERMISSION:
if (request->was_permission_requested) {
DVLOG(2) << "Rejecting requested configuration because "
<< "permission was denied.";
continue;
}
{
// Note: the GURL must not be constructed inline because
// base::Passed(&request) sets |request| to null.
GURL security_origin(
blink::WebStringToGURL(request->security_origin.toString()));
media_permission_->RequestPermission(
MediaPermission::PROTECTED_MEDIA_IDENTIFIER, security_origin,
base::Bind(&KeySystemConfigSelector::OnPermissionResult,
weak_factory_.GetWeakPtr(), base::Passed(&request)));
}
return;
case CONFIGURATION_SUPPORTED:
cdm_config.allow_distinctive_identifier =
(accumulated_configuration.distinctiveIdentifier ==
EmeFeatureRequirement::Required);
cdm_config.allow_persistent_state =
(accumulated_configuration.persistentState ==
EmeFeatureRequirement::Required);
cdm_config.use_hw_secure_codecs =
config_state.AreHwSecureCodecsRequired();
request->succeeded_cb.Run(accumulated_configuration, cdm_config);
return;
}
}
// 6.4. Reject promise with a NotSupportedError.
request->not_supported_cb.Run(
"None of the requested configurations were supported.");
}
void KeySystemConfigSelector::OnPermissionResult(
std::unique_ptr<SelectionRequest> request, bool is_permission_granted) {
request->was_permission_requested = true;
request->is_permission_granted = is_permission_granted;
SelectConfigInternal(std::move(request));
}
} // namespace media
} // namespace cobalt