| // 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 "webencryptedmediaclient_impl.h" |
| |
| #include "base/bind.h" |
| #include "base/logging.h" |
| #include "base/metrics/histogram.h" |
| #include "base/strings/string_util.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "media/base/key_systems.h" |
| #include "media/base/media_permission.h" |
| #include "media/blink/webcontentdecryptionmodule_impl.h" |
| #include "media/blink/webcontentdecryptionmoduleaccess_impl.h" |
| #include "net/base/mime_util.h" |
| #include "third_party/WebKit/public/platform/WebEncryptedMediaRequest.h" |
| #include "third_party/WebKit/public/platform/WebMediaKeySystemConfiguration.h" |
| #include "third_party/WebKit/public/platform/WebString.h" |
| #include "third_party/WebKit/public/platform/WebVector.h" |
| |
| namespace media { |
| |
| // These names are used by UMA. |
| const char kKeySystemSupportUMAPrefix[] = |
| "Media.EME.RequestMediaKeySystemAccess."; |
| |
| // TODO(jrummell): Convert to an enum. http://crbug.com/418239 |
| const char kTemporarySessionType[] = "temporary"; |
| const char kPersistentLicenseSessionType[] = "persistent-license"; |
| const char kPersistentReleaseMessageSessionType[] = |
| "persistent-release-message"; |
| |
| enum ConfigurationSupport { |
| CONFIGURATION_NOT_SUPPORTED, |
| CONFIGURATION_REQUIRES_PERMISSION, |
| CONFIGURATION_SUPPORTED, |
| }; |
| |
| static bool IsSupportedContentType(const std::string& key_system, |
| const std::string& mime_type, |
| const std::string& codecs) { |
| // TODO(sandersd): Move contentType parsing from Blink to here so that invalid |
| // parameters can be rejected. http://crbug.com/417561 |
| // TODO(sandersd): Pass in the media type (audio or video) and check that the |
| // container type matches. http://crbug.com/457384 |
| std::string container = base::StringToLowerASCII(mime_type); |
| |
| // Check that |codecs| are supported by the CDM. This check does not handle |
| // extended codecs, so extended codec information is stripped. |
| // TODO(sandersd): Reject codecs that do not match the media type. |
| // http://crbug.com/457386 |
| std::vector<std::string> codec_vector; |
| net::ParseCodecString(codecs, &codec_vector, true); |
| if (!IsSupportedKeySystemWithMediaMimeType(container, codec_vector, |
| key_system)) { |
| return false; |
| } |
| |
| // Check that |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 would be bad because it would require |
| // considering the accumulated configuration, and could affect whether secure |
| // decode is required). |
| // TODO(sandersd): Reject ambiguous codecs. http://crbug.com/374751 |
| codec_vector.clear(); |
| net::ParseCodecString(codecs, &codec_vector, false); |
| return net::AreSupportedMediaCodecs(codec_vector); |
| } |
| |
| static bool GetSupportedCapabilities( |
| const std::string& key_system, |
| const blink::WebVector<blink::WebMediaKeySystemMediaCapability>& |
| capabilities, |
| std::vector<blink::WebMediaKeySystemMediaCapability>* |
| media_type_capabilities) { |
| // From |
| // https://w3c.github.io/encrypted-media/#get-supported-capabilities-for-media-type |
| // 1. Let accumulated capabilities be partial configuration. |
| // (Skipped as there are no configuration-based codec restrictions.) |
| // 2. Let media type capabilities be empty. |
| DCHECK_EQ(media_type_capabilities->size(), 0ul); |
| // 3. For each value in capabilities: |
| for (size_t i = 0; i < 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 = capabilities[i]; |
| // 3.3. If contentType is the empty string, return null. |
| if (capability.mimeType.isEmpty()) |
| return false; |
| // 3.4-3.11. (Implemented by IsSupportedContentType().) |
| if (!base::IsStringASCII(capability.mimeType) || |
| !base::IsStringASCII(capability.codecs) || |
| !IsSupportedContentType(key_system, |
| base::UTF16ToASCII(capability.mimeType), |
| base::UTF16ToASCII(capability.codecs))) { |
| continue; |
| } |
| // 3.12. If robustness is not the empty string, run the following steps: |
| // (Robustness is not supported.) |
| // TODO(sandersd): Implement robustness. http://crbug.com/442586 |
| if (!capability.robustness.isEmpty()) { |
| LOG(WARNING) << "Configuration rejected because rubustness strings are " |
| << "not yet supported."; |
| continue; |
| } |
| // 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 accumulated capabilities, |
| // continue to the next iteration. |
| // (Skipped as there are no configuration-based codec restrictions.) |
| // 3.14. Add configuration to media type capabilities. |
| media_type_capabilities->push_back(capability); |
| // 3.15. Add configuration to accumulated capabilities. |
| // (Skipped as there are no configuration-based codec restrictions.) |
| } |
| // 4. If media type capabilities is empty, return null. |
| // 5. Return media type capabilities. |
| return !media_type_capabilities->empty(); |
| } |
| |
| static EmeFeatureRequirement ConvertRequirement( |
| blink::WebMediaKeySystemConfiguration::Requirement requirement) { |
| switch (requirement) { |
| case blink::WebMediaKeySystemConfiguration::Requirement::Required: |
| return EME_FEATURE_REQUIRED; |
| case blink::WebMediaKeySystemConfiguration::Requirement::Optional: |
| return EME_FEATURE_OPTIONAL; |
| case blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed: |
| return EME_FEATURE_NOT_ALLOWED; |
| } |
| |
| NOTREACHED(); |
| return EME_FEATURE_NOT_ALLOWED; |
| } |
| |
| static ConfigurationSupport GetSupportedConfiguration( |
| const std::string& key_system, |
| const blink::WebMediaKeySystemConfiguration& candidate, |
| blink::WebMediaKeySystemConfiguration* accumulated_configuration, |
| bool was_permission_requested, |
| bool is_permission_granted) { |
| DCHECK(was_permission_requested || !is_permission_granted); |
| |
| // It is possible to obtain user permission unless permission was already |
| // requested and denied. |
| bool is_permission_possible = |
| !was_permission_requested || is_permission_granted; |
| |
| // From https://w3c.github.io/encrypted-media/#get-supported-configuration |
| // 1. Let accumulated configuration be empty. (Done by caller.) |
| // 2. If candidate configuration's initDataTypes attribute is not empty, run |
| // the following steps: |
| if (!candidate.initDataTypes.isEmpty()) { |
| // 2.1. Let supported types be empty. |
| std::vector<blink::WebString> supported_types; |
| |
| // 2.2. For each value in candidate configuration's initDataTypes attribute: |
| for (size_t i = 0; i < candidate.initDataTypes.size(); i++) { |
| // 2.2.1. Let initDataType be the value. |
| const blink::WebString& init_data_type = candidate.initDataTypes[i]; |
| // 2.2.2. If initDataType is the empty string, return null. |
| if (init_data_type.isEmpty()) |
| return CONFIGURATION_NOT_SUPPORTED; |
| // 2.2.3. If the implementation supports generating requests based on |
| // initDataType, add initDataType to supported types. String |
| // comparison is case-sensitive. |
| if (base::IsStringASCII(init_data_type) && |
| IsSupportedKeySystemWithInitDataType( |
| key_system, base::UTF16ToASCII(init_data_type))) { |
| supported_types.push_back(init_data_type); |
| } |
| } |
| |
| // 2.3. If supported types is empty, return null. |
| if (supported_types.empty()) |
| return CONFIGURATION_NOT_SUPPORTED; |
| |
| // 2.4. Add supported types to accumulated configuration. |
| accumulated_configuration->initDataTypes = supported_types; |
| } |
| |
| // 3. Follow the steps for the value of candidate configuration's |
| // distinctiveIdentifier attribute from the following list: |
| // - "required": If the implementation does not support a persistent |
| // Distinctive Identifier in combination with accumulated configuration, |
| // return null. |
| // - "optional": Continue. |
| // - "not-allowed": If the implementation requires a Distinctive |
| // Identifier in combination with accumulated configuration, return |
| // null. |
| EmeFeatureRequirement di_requirement = |
| ConvertRequirement(candidate.distinctiveIdentifier); |
| if (!IsDistinctiveIdentifierRequirementSupported(key_system, di_requirement, |
| is_permission_possible)) { |
| return CONFIGURATION_NOT_SUPPORTED; |
| } |
| |
| // 4. Add the value of the candidate configuration's distinctiveIdentifier |
| // attribute to accumulated configuration. |
| accumulated_configuration->distinctiveIdentifier = |
| candidate.distinctiveIdentifier; |
| |
| // 5. Follow the steps for the value of candidate configuration's |
| // persistentState attribute from the following list: |
| // - "required": If the implementation does not support persisting state |
| // in combination with accumulated configuration, return null. |
| // - "optional": Continue. |
| // - "not-allowed": If the implementation requires persisting state in |
| // combination with accumulated configuration, return null. |
| EmeFeatureRequirement ps_requirement = |
| ConvertRequirement(candidate.persistentState); |
| if (!IsPersistentStateRequirementSupported(key_system, ps_requirement, |
| is_permission_possible)) { |
| return CONFIGURATION_NOT_SUPPORTED; |
| } |
| |
| // 6. Add the value of the candidate configuration's persistentState |
| // attribute to accumulated configuration. |
| accumulated_configuration->persistentState = candidate.persistentState; |
| |
| // 7. If candidate configuration's videoCapabilities attribute is not empty, |
| // run the following steps: |
| if (!candidate.videoCapabilities.isEmpty()) { |
| // 7.1. Let video capabilities be the result of executing the Get Supported |
| // Capabilities for Media Type algorithm on Video, candidate |
| // configuration's videoCapabilities attribute, and accumulated |
| // configuration. |
| // 7.2. If video capabilities is null, return null. |
| std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities; |
| if (!GetSupportedCapabilities(key_system, candidate.videoCapabilities, |
| &video_capabilities)) { |
| return CONFIGURATION_NOT_SUPPORTED; |
| } |
| |
| // 7.3. Add video capabilities to accumulated configuration. |
| accumulated_configuration->videoCapabilities = video_capabilities; |
| } |
| |
| // 8. If candidate configuration's audioCapabilities attribute is not empty, |
| // run the following steps: |
| if (!candidate.audioCapabilities.isEmpty()) { |
| // 8.1. Let audio capabilities be the result of executing the Get Supported |
| // Capabilities for Media Type algorithm on Audio, candidate |
| // configuration's audioCapabilities attribute, and accumulated |
| // configuration. |
| // 8.2. If audio capabilities is null, return null. |
| std::vector<blink::WebMediaKeySystemMediaCapability> audio_capabilities; |
| if (!GetSupportedCapabilities(key_system, candidate.audioCapabilities, |
| &audio_capabilities)) { |
| return CONFIGURATION_NOT_SUPPORTED; |
| } |
| |
| // 8.3. Add audio capabilities to accumulated configuration. |
| accumulated_configuration->audioCapabilities = audio_capabilities; |
| } |
| |
| // 9. If accumulated configuration's distinctiveIdentifier value is |
| // "optional", follow the steps for the first matching condition from the |
| // following list: |
| // - If the implementation requires a Distinctive Identifier 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". |
| // (Without robustness support, capabilities do not affect this.) |
| // TODO(sandersd): Implement robustness. http://crbug.com/442586 |
| if (accumulated_configuration->distinctiveIdentifier == |
| blink::WebMediaKeySystemConfiguration::Requirement::Optional) { |
| if (IsDistinctiveIdentifierRequirementSupported( |
| key_system, EME_FEATURE_NOT_ALLOWED, is_permission_possible)) { |
| accumulated_configuration->distinctiveIdentifier = |
| blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed; |
| } else { |
| accumulated_configuration->distinctiveIdentifier = |
| blink::WebMediaKeySystemConfiguration::Requirement::Required; |
| } |
| } |
| |
| // 10. 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 == |
| blink::WebMediaKeySystemConfiguration::Requirement::Optional) { |
| if (IsPersistentStateRequirementSupported( |
| key_system, EME_FEATURE_NOT_ALLOWED, is_permission_possible)) { |
| accumulated_configuration->persistentState = |
| blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed; |
| } else { |
| accumulated_configuration->persistentState = |
| blink::WebMediaKeySystemConfiguration::Requirement::Required; |
| } |
| } |
| |
| // 11. 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 null. |
| di_requirement = |
| ConvertRequirement(accumulated_configuration->distinctiveIdentifier); |
| if (!IsDistinctiveIdentifierRequirementSupported(key_system, di_requirement, |
| is_permission_granted)) { |
| if (was_permission_requested) { |
| // The optional permission was requested and denied. |
| // TODO(sandersd): Avoid the need for this logic - crbug.com/460616. |
| DCHECK(candidate.distinctiveIdentifier == |
| blink::WebMediaKeySystemConfiguration::Requirement::Optional); |
| DCHECK(di_requirement == EME_FEATURE_REQUIRED); |
| DCHECK(!is_permission_granted); |
| accumulated_configuration->distinctiveIdentifier = |
| blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed; |
| } else { |
| return CONFIGURATION_REQUIRES_PERMISSION; |
| } |
| } |
| |
| ps_requirement = |
| ConvertRequirement(accumulated_configuration->persistentState); |
| if (!IsPersistentStateRequirementSupported(key_system, ps_requirement, |
| is_permission_granted)) { |
| DCHECK(!was_permission_requested); // Should have failed at step 5. |
| return CONFIGURATION_REQUIRES_PERMISSION; |
| } |
| |
| // 12. Return accumulated configuration. |
| // (As an extra step, we record the available session types so that |
| // createSession() can be synchronous.) |
| std::vector<blink::WebString> session_types; |
| session_types.push_back(kTemporarySessionType); |
| if (accumulated_configuration->persistentState == |
| blink::WebMediaKeySystemConfiguration::Requirement::Required) { |
| if (IsPersistentLicenseSessionSupported(key_system, |
| is_permission_granted)) { |
| session_types.push_back(kPersistentLicenseSessionType); |
| } |
| if (IsPersistentReleaseMessageSessionSupported(key_system, |
| is_permission_granted)) { |
| session_types.push_back(kPersistentReleaseMessageSessionType); |
| } |
| } |
| accumulated_configuration->sessionTypes = session_types; |
| |
| return CONFIGURATION_SUPPORTED; |
| } |
| |
| // Report usage of key system to UMA. There are 2 different counts logged: |
| // 1. The key system is requested. |
| // 2. The requested key system and options are supported. |
| // Each stat is only reported once per renderer frame per key system. |
| // Note that WebEncryptedMediaClientImpl is only created once by each |
| // renderer frame. |
| class WebEncryptedMediaClientImpl::Reporter { |
| public: |
| enum KeySystemSupportStatus { |
| KEY_SYSTEM_REQUESTED = 0, |
| KEY_SYSTEM_SUPPORTED = 1, |
| KEY_SYSTEM_SUPPORT_STATUS_COUNT |
| }; |
| |
| explicit Reporter(const std::string& key_system_for_uma) |
| : uma_name_(kKeySystemSupportUMAPrefix + key_system_for_uma), |
| is_request_reported_(false), |
| is_support_reported_(false) {} |
| ~Reporter() {} |
| |
| void ReportRequested() { |
| if (is_request_reported_) |
| return; |
| Report(KEY_SYSTEM_REQUESTED); |
| is_request_reported_ = true; |
| } |
| |
| void ReportSupported() { |
| DCHECK(is_request_reported_); |
| if (is_support_reported_) |
| return; |
| Report(KEY_SYSTEM_SUPPORTED); |
| is_support_reported_ = true; |
| } |
| |
| private: |
| void Report(KeySystemSupportStatus status) { |
| // Not using UMA_HISTOGRAM_ENUMERATION directly because UMA_* macros |
| // require the names to be constant throughout the process' lifetime. |
| base::LinearHistogram::FactoryGet( |
| uma_name_, 1, KEY_SYSTEM_SUPPORT_STATUS_COUNT, |
| KEY_SYSTEM_SUPPORT_STATUS_COUNT + 1, |
| base::Histogram::kUmaTargetedHistogramFlag)->Add(status); |
| } |
| |
| const std::string uma_name_; |
| bool is_request_reported_; |
| bool is_support_reported_; |
| }; |
| |
| WebEncryptedMediaClientImpl::WebEncryptedMediaClientImpl( |
| scoped_ptr<CdmFactory> cdm_factory, |
| MediaPermission* media_permission) |
| : cdm_factory_(cdm_factory.Pass()), media_permission_(media_permission), |
| weak_factory_(this) { |
| DCHECK(media_permission); |
| } |
| |
| WebEncryptedMediaClientImpl::~WebEncryptedMediaClientImpl() { |
| } |
| |
| void WebEncryptedMediaClientImpl::requestMediaKeySystemAccess( |
| blink::WebEncryptedMediaRequest request) { |
| // TODO(jrummell): This should be asynchronous, ideally not on the main |
| // thread. |
| |
| // Continued from requestMediaKeySystemAccess(), step 7, from |
| // https://w3c.github.io/encrypted-media/#requestmediakeysystemaccess |
| // |
| // 7.1. If keySystem is not one of the Key Systems supported by the user |
| // agent, reject promise with with a new DOMException whose name is |
| // NotSupportedError. String comparison is case-sensitive. |
| if (!base::IsStringASCII(request.keySystem())) { |
| request.requestNotSupported("Only ASCII keySystems are supported"); |
| return; |
| } |
| |
| // Report this request to the UMA. |
| std::string key_system = base::UTF16ToASCII(request.keySystem()); |
| GetReporter(key_system)->ReportRequested(); |
| |
| if (!IsSupportedKeySystem(key_system)) { |
| request.requestNotSupported("Unsupported keySystem"); |
| return; |
| } |
| |
| // 7.2-7.4. Implemented by SelectSupportedConfiguration(). |
| SelectSupportedConfiguration(request, false, false); |
| } |
| |
| void WebEncryptedMediaClientImpl::SelectSupportedConfiguration( |
| blink::WebEncryptedMediaRequest request, |
| bool was_permission_requested, |
| bool is_permission_granted) { |
| // Continued from requestMediaKeySystemAccess(), step 7.1, from |
| // https://w3c.github.io/encrypted-media/#requestmediakeysystemaccess |
| // |
| // 7.2. Let implementation be the implementation of keySystem. |
| std::string key_system = base::UTF16ToASCII(request.keySystem()); |
| |
| // 7.3. For each value in supportedConfigurations: |
| const blink::WebVector<blink::WebMediaKeySystemConfiguration>& |
| configurations = request.supportedConfigurations(); |
| for (size_t i = 0; i < configurations.size(); i++) { |
| // 7.3.1. Let candidate configuration be the value. |
| const blink::WebMediaKeySystemConfiguration& candidate_configuration = |
| configurations[i]; |
| // 7.3.2. Let supported configuration be the result of executing the Get |
| // Supported Configuration algorithm on implementation, candidate |
| // configuration, and origin. |
| // 7.3.3. If supported configuration is not null, [initialize and return a |
| // new MediaKeySystemAccess object.] |
| blink::WebMediaKeySystemConfiguration accumulated_configuration; |
| ConfigurationSupport supported = GetSupportedConfiguration( |
| key_system, candidate_configuration, &accumulated_configuration, |
| was_permission_requested, is_permission_granted); |
| switch (supported) { |
| case CONFIGURATION_NOT_SUPPORTED: |
| continue; |
| case CONFIGURATION_REQUIRES_PERMISSION: |
| DCHECK(!was_permission_requested); |
| media_permission_->RequestPermission( |
| MediaPermission::PROTECTED_MEDIA_IDENTIFIER, |
| GURL(request.securityOrigin().toString()), |
| // Try again with |was_permission_requested| true and |
| // |is_permission_granted| the value of the permission. |
| base::Bind( |
| &WebEncryptedMediaClientImpl::SelectSupportedConfiguration, |
| weak_factory_.GetWeakPtr(), request, true)); |
| return; |
| case CONFIGURATION_SUPPORTED: |
| // Report that this request succeeded to the UMA. |
| GetReporter(key_system)->ReportSupported(); |
| request.requestSucceeded(WebContentDecryptionModuleAccessImpl::Create( |
| request.keySystem(), accumulated_configuration, |
| request.securityOrigin(), weak_factory_.GetWeakPtr())); |
| return; |
| } |
| } |
| |
| // 7.4. Reject promise with a new DOMException whose name is |
| // NotSupportedError. |
| request.requestNotSupported( |
| "None of the requested configurations were supported."); |
| } |
| |
| void WebEncryptedMediaClientImpl::CreateCdm( |
| const blink::WebString& key_system, |
| const blink::WebSecurityOrigin& security_origin, |
| blink::WebContentDecryptionModuleResult result) { |
| WebContentDecryptionModuleImpl::Create(cdm_factory_.get(), security_origin, |
| key_system, result); |
| } |
| |
| // Lazily create Reporters. |
| WebEncryptedMediaClientImpl::Reporter* WebEncryptedMediaClientImpl::GetReporter( |
| const std::string& key_system) { |
| std::string uma_name = GetKeySystemNameForUMA(key_system); |
| Reporter* reporter = reporters_.get(uma_name); |
| if (reporter != nullptr) |
| return reporter; |
| |
| // Reporter not found, so create one. |
| auto result = |
| reporters_.add(uma_name, make_scoped_ptr(new Reporter(uma_name))); |
| DCHECK(result.second); |
| return result.first->second; |
| } |
| |
| } // namespace media |
