diff --git a/android_webview/renderer/aw_content_renderer_client.cc b/android_webview/renderer/aw_content_renderer_client.cc index eaceec574351ae..d799c8479f6035 100644 --- a/android_webview/renderer/aw_content_renderer_client.cc +++ b/android_webview/renderer/aw_content_renderer_client.cc @@ -218,8 +218,8 @@ bool AwContentRendererClient::IsLinkVisited(unsigned long long link_hash) { return visited_link_slave_->IsVisited(link_hash); } -void AwContentRendererClient::AddSupportedKeySystems( - std::vector>* key_systems) { +void AwContentRendererClient::AddKeySystems( + std::vector* key_systems) { AwAddKeySystems(key_systems); } diff --git a/android_webview/renderer/aw_content_renderer_client.h b/android_webview/renderer/aw_content_renderer_client.h index 913824200d38f6..e3a963acdfcdae 100644 --- a/android_webview/renderer/aw_content_renderer_client.h +++ b/android_webview/renderer/aw_content_renderer_client.h @@ -36,9 +36,7 @@ class AwContentRendererClient : public content::ContentRendererClient { unsigned long long VisitedLinkHash(const char* canonical_url, size_t length) override; bool IsLinkVisited(unsigned long long link_hash) override; - void AddSupportedKeySystems( - std::vector>* key_systems) - override; + void AddKeySystems(std::vector* key_systems) override; bool HandleNavigation(content::RenderFrame* render_frame, bool is_content_initiated, diff --git a/android_webview/renderer/aw_key_systems.cc b/android_webview/renderer/aw_key_systems.cc index 6a81cb1512552a..cc3059e4a8b176 100644 --- a/android_webview/renderer/aw_key_systems.cc +++ b/android_webview/renderer/aw_key_systems.cc @@ -7,10 +7,10 @@ namespace android_webview { -void AwAddKeySystems(std::vector>* - key_systems_properties) { - cdm::AddAndroidWidevine(key_systems_properties); - cdm::AddAndroidPlatformKeySystems(key_systems_properties); +void AwAddKeySystems( + std::vector* key_systems_info) { + cdm::AddAndroidWidevine(key_systems_info); + cdm::AddAndroidPlatformKeySystems(key_systems_info); } } // namespace android_webview diff --git a/android_webview/renderer/aw_key_systems.h b/android_webview/renderer/aw_key_systems.h index ea15f325c481c4..4bed8b61a3e4ac 100644 --- a/android_webview/renderer/aw_key_systems.h +++ b/android_webview/renderer/aw_key_systems.h @@ -5,15 +5,13 @@ #ifndef ANDROID_WEBVIEW_RENDERER_AW_KEY_SYSTEMS_H_ #define ANDROID_WEBVIEW_RENDERER_AW_KEY_SYSTEMS_H_ -#include #include -#include "media/base/key_system_properties.h" +#include "media/base/key_system_info.h" namespace android_webview { -void AwAddKeySystems(std::vector>* - key_systems_properties); +void AwAddKeySystems(std::vector* key_systems_info); } // namespace android_webview diff --git a/chrome/renderer/chrome_content_renderer_client.cc b/chrome/renderer/chrome_content_renderer_client.cc index 23741dbf918b08..3be44db4e3ac99 100644 --- a/chrome/renderer/chrome_content_renderer_client.cc +++ b/chrome/renderer/chrome_content_renderer_client.cc @@ -1243,11 +1243,6 @@ bool ChromeContentRendererClient::AllowPepperMediaStreamAPI( void ChromeContentRendererClient::AddKeySystems( std::vector* key_systems) { - AddChromeKeySystemsInfo(key_systems); -} - -void ChromeContentRendererClient::AddSupportedKeySystems( - std::vector>* key_systems) { AddChromeKeySystems(key_systems); } diff --git a/chrome/renderer/chrome_content_renderer_client.h b/chrome/renderer/chrome_content_renderer_client.h index 4ab17cd54f2f1e..aa3c85932605f1 100644 --- a/chrome/renderer/chrome_content_renderer_client.h +++ b/chrome/renderer/chrome_content_renderer_client.h @@ -130,9 +130,6 @@ class ChromeContentRendererClient : public content::ContentRendererClient { blink::WebFrame* frame) override; bool AllowPepperMediaStreamAPI(const GURL& url) override; void AddKeySystems(std::vector* key_systems) override; - void AddSupportedKeySystems( - std::vector>* key_systems) - override; bool IsPluginAllowedToUseDevChannelAPIs() override; bool IsPluginAllowedToUseCameraDeviceAPI(const GURL& url) override; bool IsPluginAllowedToUseCompositorAPI(const GURL& url) override; diff --git a/chrome/renderer/media/chrome_key_systems.cc b/chrome/renderer/media/chrome_key_systems.cc index af169d26ddeb39..e05fe0dc8909d7 100644 --- a/chrome/renderer/media/chrome_key_systems.cc +++ b/chrome/renderer/media/chrome_key_systems.cc @@ -15,11 +15,9 @@ #include "base/strings/utf_string_conversions.h" #include "build/build_config.h" #include "chrome/common/render_messages.h" +#include "components/cdm/renderer/widevine_key_systems.h" #include "content/public/renderer/render_thread.h" #include "media/base/eme_constants.h" -#include "media/base/key_system_info.h" -#include "media/base/key_system_properties.h" - #include "media/media_features.h" #if defined(OS_ANDROID) @@ -36,7 +34,6 @@ #endif using media::KeySystemInfo; -using media::KeySystemProperties; using media::SupportedCodecs; #if defined(ENABLE_PEPPER_CDMS) @@ -153,7 +150,7 @@ void GetSupportedCodecsForPepperCdm( } static void AddPepperBasedWidevine( - std::vector>* concrete_key_systems) { + std::vector* concrete_key_systems) { #if defined(WIDEVINE_CDM_MIN_GLIBC_VERSION) Version glibc_version(gnu_get_libc_version()); DCHECK(glibc_version.IsValid()); @@ -201,7 +198,7 @@ static void AddPepperBasedWidevine( #endif // defined(USE_PROPRIETARY_CODECS) } - concrete_key_systems->emplace_back(new cdm::WidevineKeySystemProperties( + cdm::AddWidevineWithCodecs( supported_codecs, #if defined(OS_CHROMEOS) media::EmeRobustness::HW_SECURE_ALL, // Maximum audio robustness. @@ -209,37 +206,33 @@ static void AddPepperBasedWidevine( media::EmeSessionTypeSupport:: SUPPORTED_WITH_IDENTIFIER, // Persistent-license. media::EmeSessionTypeSupport:: - NOT_SUPPORTED, // Persistent-release-message. - media::EmeFeatureSupport::REQUESTABLE, // Persistent state. - media::EmeFeatureSupport::REQUESTABLE)); // Distinctive identifier. + NOT_SUPPORTED, // Persistent-release-message. + media::EmeFeatureSupport::REQUESTABLE, // Persistent state. + media::EmeFeatureSupport::REQUESTABLE, // Distinctive identifier. #else // (Desktop) media::EmeRobustness::SW_SECURE_CRYPTO, // Maximum audio robustness. media::EmeRobustness::SW_SECURE_DECODE, // Maximum video robustness. media::EmeSessionTypeSupport::NOT_SUPPORTED, // persistent-license. media::EmeSessionTypeSupport:: - NOT_SUPPORTED, // persistent-release-message. - media::EmeFeatureSupport::REQUESTABLE, // Persistent state. - media::EmeFeatureSupport::NOT_SUPPORTED)); // Distinctive identifier. + NOT_SUPPORTED, // persistent-release-message. + media::EmeFeatureSupport::REQUESTABLE, // Persistent state. + media::EmeFeatureSupport::NOT_SUPPORTED, // Distinctive identifier. #endif // defined(OS_CHROMEOS) + concrete_key_systems); } #endif // defined(WIDEVINE_CDM_AVAILABLE) #endif // defined(ENABLE_PEPPER_CDMS) -void AddChromeKeySystemsInfo(std::vector* key_systems_info) { +void AddChromeKeySystems(std::vector* key_systems_info) { #if defined(ENABLE_PEPPER_CDMS) AddExternalClearKey(key_systems_info); -#endif -} -void AddChromeKeySystems( - std::vector>* key_systems_properties) { -#if defined(ENABLE_PEPPER_CDMS) #if defined(WIDEVINE_CDM_AVAILABLE) - AddPepperBasedWidevine(key_systems_properties); + AddPepperBasedWidevine(key_systems_info); #endif // defined(WIDEVINE_CDM_AVAILABLE) #endif // defined(ENABLE_PEPPER_CDMS) #if defined(OS_ANDROID) - cdm::AddAndroidWidevine(key_systems_properties); + cdm::AddAndroidWidevine(key_systems_info); #endif // defined(OS_ANDROID) } diff --git a/chrome/renderer/media/chrome_key_systems.h b/chrome/renderer/media/chrome_key_systems.h index ab1be5041ced22..dfec84f3b39b2e 100644 --- a/chrome/renderer/media/chrome_key_systems.h +++ b/chrome/renderer/media/chrome_key_systems.h @@ -5,23 +5,10 @@ #ifndef CHROME_RENDERER_MEDIA_CHROME_KEY_SYSTEMS_H_ #define CHROME_RENDERER_MEDIA_CHROME_KEY_SYSTEMS_H_ -#include #include -namespace media { -struct KeySystemInfo; -class KeySystemProperties; -} +#include "media/base/key_system_info.h" -// DEPRECATED: Register the key systems supported by populating -// |key_systems_info|. TODO(halliwell): move all key systems to -// KeySystemProperties API. -void AddChromeKeySystemsInfo( - std::vector* key_systems_info); - -// Register the key systems supported by populating |key_systems_properties|. -void AddChromeKeySystems( - std::vector>* - key_systems_properties); +void AddChromeKeySystems(std::vector* key_systems_info); #endif // CHROME_RENDERER_MEDIA_CHROME_KEY_SYSTEMS_H_ diff --git a/chromecast/renderer/cast_content_renderer_client.cc b/chromecast/renderer/cast_content_renderer_client.cc index 3fb375a6d044ec..d02ffc33a333f1 100644 --- a/chromecast/renderer/cast_content_renderer_client.cc +++ b/chromecast/renderer/cast_content_renderer_client.cc @@ -101,14 +101,8 @@ void CastContentRendererClient::RenderViewCreated( } void CastContentRendererClient::AddKeySystems( - std::vector<::media::KeySystemInfo>* key_systems_info) { - AddChromecastKeySystemsInfo(key_systems_info); -} - -void CastContentRendererClient::AddSupportedKeySystems( - std::vector>* - key_systems_properties) { - AddChromecastKeySystems(key_systems_properties); + std::vector< ::media::KeySystemInfo>* key_systems) { + AddChromecastKeySystems(key_systems); } #if !defined(OS_ANDROID) diff --git a/chromecast/renderer/cast_content_renderer_client.h b/chromecast/renderer/cast_content_renderer_client.h index 245958e6f481bd..cb04ad6a882701 100644 --- a/chromecast/renderer/cast_content_renderer_client.h +++ b/chromecast/renderer/cast_content_renderer_client.h @@ -35,10 +35,7 @@ class CastContentRendererClient : public content::ContentRendererClient { void RenderThreadStarted() override; void RenderViewCreated(content::RenderView* render_view) override; void AddKeySystems( - std::vector<::media::KeySystemInfo>* key_systems_info) override; - void AddSupportedKeySystems( - std::vector>* - key_systems_properties) override; + std::vector< ::media::KeySystemInfo>* key_systems) override; #if !defined(OS_ANDROID) std::unique_ptr<::media::RendererFactory> CreateMediaRendererFactory( content::RenderFrame* render_frame, diff --git a/chromecast/renderer/key_systems_cast.cc b/chromecast/renderer/key_systems_cast.cc index 4acfd110c07026..c1257fdba8c3a0 100644 --- a/chromecast/renderer/key_systems_cast.cc +++ b/chromecast/renderer/key_systems_cast.cc @@ -10,7 +10,7 @@ #include "base/logging.h" #include "build/build_config.h" #include "chromecast/media/base/key_systems_common.h" -#include "components/cdm/renderer/widevine_key_system_properties.h" +#include "components/cdm/renderer/widevine_key_systems.h" #include "media/base/eme_constants.h" #include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR. @@ -21,9 +21,7 @@ using ::media::EmeSessionTypeSupport; namespace chromecast { namespace shell { -namespace { -#if defined(PLAYREADY_CDM_AVAILABLE) void AddKeySystemWithCodecs( const std::string& key_system_name, std::vector<::media::KeySystemInfo>* key_systems_info) { @@ -32,47 +30,44 @@ void AddKeySystemWithCodecs( info.supported_init_data_types = ::media::kInitDataTypeMaskCenc; info.supported_codecs = ::media::EME_CODEC_MP4_AAC | ::media::EME_CODEC_MP4_AVC1; - info.max_audio_robustness = EmeRobustness::EMPTY; - info.max_video_robustness = EmeRobustness::EMPTY; + info.max_audio_robustness = ::media::EmeRobustness::EMPTY; + info.max_video_robustness = ::media::EmeRobustness::EMPTY; #if defined(OS_ANDROID) - info.persistent_license_support = EmeSessionTypeSupport::NOT_SUPPORTED; + info.persistent_license_support = + ::media::EmeSessionTypeSupport::NOT_SUPPORTED; #else - info.persistent_license_support = EmeSessionTypeSupport::SUPPORTED; + info.persistent_license_support = + ::media::EmeSessionTypeSupport::SUPPORTED; #endif info.persistent_release_message_support = - EmeSessionTypeSupport::NOT_SUPPORTED; - info.persistent_state_support = EmeFeatureSupport::ALWAYS_ENABLED; - info.distinctive_identifier_support = EmeFeatureSupport::ALWAYS_ENABLED; + ::media::EmeSessionTypeSupport::NOT_SUPPORTED; + info.persistent_state_support = ::media::EmeFeatureSupport::ALWAYS_ENABLED; + info.distinctive_identifier_support = + ::media::EmeFeatureSupport::ALWAYS_ENABLED; key_systems_info->push_back(info); } -#endif // defined(PLAYREADY_CDM_AVAILABLE) - -} // namespace void AddChromecastKeySystems( - std::vector>* - key_systems_properties) { + std::vector<::media::KeySystemInfo>* key_systems_info) { #if defined(WIDEVINE_CDM_AVAILABLE) ::media::SupportedCodecs codecs = ::media::EME_CODEC_MP4_AAC | ::media::EME_CODEC_MP4_AVC1 | ::media::EME_CODEC_WEBM_VP8 | ::media::EME_CODEC_WEBM_VP9; - key_systems_properties->emplace_back(new cdm::WidevineKeySystemProperties( - codecs, // Regular codecs. + cdm::AddWidevineWithCodecs( + codecs, // Regular codecs. #if defined(OS_ANDROID) - codecs, // Hardware-secure codecs. -#endif + codecs, // Hardware-secure codecs. +#endif // defined(OS_ANDROID) EmeRobustness::HW_SECURE_ALL, // Max audio robustness. EmeRobustness::HW_SECURE_ALL, // Max video robustness. EmeSessionTypeSupport::NOT_SUPPORTED, // persistent-license. EmeSessionTypeSupport::NOT_SUPPORTED, // persistent-release-message. // Note: On Chromecast, all CDMs may have persistent state. - EmeFeatureSupport::ALWAYS_ENABLED, // Persistent state. - EmeFeatureSupport::ALWAYS_ENABLED)); // Distinctive identifier. + EmeFeatureSupport::ALWAYS_ENABLED, // Persistent state. + EmeFeatureSupport::ALWAYS_ENABLED, // Distinctive identifier. + key_systems_info); #endif // defined(WIDEVINE_CDM_AVAILABLE) -} -void AddChromecastKeySystemsInfo( - std::vector<::media::KeySystemInfo>* key_systems_info) { #if defined(PLAYREADY_CDM_AVAILABLE) AddKeySystemWithCodecs(media::kChromecastPlayreadyKeySystem, key_systems_info); diff --git a/chromecast/renderer/key_systems_cast.h b/chromecast/renderer/key_systems_cast.h index 158518f81b45c6..d59993f131d4cf 100644 --- a/chromecast/renderer/key_systems_cast.h +++ b/chromecast/renderer/key_systems_cast.h @@ -5,20 +5,21 @@ #ifndef CHROMECAST_RENDERER_KEY_SYSTEMS_CAST_H_ #define CHROMECAST_RENDERER_KEY_SYSTEMS_CAST_H_ -#include #include #include "media/base/key_system_info.h" -#include "media/base/key_system_properties.h" namespace chromecast { namespace shell { -void AddChromecastKeySystems( - std::vector>* - key_systems_properties); +// Adds a single key system by name. +// TODO(gunsch): modify this API to accept specifying different supported +// features, and/or APIs per key system type. +void AddKeySystemWithCodecs( + const std::string& key_system_name, + std::vector<::media::KeySystemInfo>* concrete_key_systems); -void AddChromecastKeySystemsInfo( +void AddChromecastKeySystems( std::vector<::media::KeySystemInfo>* key_systems_info); } // namespace shell diff --git a/components/cdm.gypi b/components/cdm.gypi index 3698f34bdae865..02ba08049cd48f 100644 --- a/components/cdm.gypi +++ b/components/cdm.gypi @@ -38,12 +38,12 @@ '../third_party/widevine/cdm/widevine_cdm.gyp:widevine_cdm_version_h', ], 'include_dirs': [ - # Needed by widevine_key_system_properties.cc. + # Needed by widevine_key_systems.cc. '<(SHARED_INTERMEDIATE_DIR)', ], 'sources': [ - 'cdm/renderer/widevine_key_system_properties.cc', - 'cdm/renderer/widevine_key_system_properties.h', + 'cdm/renderer/widevine_key_systems.cc', + 'cdm/renderer/widevine_key_systems.h', ], 'conditions': [ ['OS == "android"', { diff --git a/components/cdm/renderer/BUILD.gn b/components/cdm/renderer/BUILD.gn index f364f89c829cf9..ef4d03d018ee97 100644 --- a/components/cdm/renderer/BUILD.gn +++ b/components/cdm/renderer/BUILD.gn @@ -4,8 +4,8 @@ static_library("renderer") { sources = [ - "widevine_key_system_properties.cc", - "widevine_key_system_properties.h", + "widevine_key_systems.cc", + "widevine_key_systems.h", ] if (is_android) { diff --git a/components/cdm/renderer/android_key_systems.cc b/components/cdm/renderer/android_key_systems.cc index 8e4f7529fff012..56d2aec6172653 100644 --- a/components/cdm/renderer/android_key_systems.cc +++ b/components/cdm/renderer/android_key_systems.cc @@ -10,89 +10,21 @@ #include "base/command_line.h" #include "base/logging.h" #include "components/cdm/common/cdm_messages_android.h" -#include "components/cdm/renderer/widevine_key_system_properties.h" +#include "components/cdm/renderer/widevine_key_systems.h" #include "content/public/renderer/render_thread.h" #include "media/base/eme_constants.h" #include "media/base/media_switches.h" #include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR. -using media::EmeConfigRule; using media::EmeFeatureSupport; -using media::EmeInitDataType; using media::EmeRobustness; using media::EmeSessionTypeSupport; -using media::KeySystemProperties; +using media::KeySystemInfo; using media::SupportedCodecs; namespace cdm { -namespace { - -// Implementation of KeySystemProperties for platform-supported key systems. -// Assumes that platform key systems support no features but can and will -// make use of persistence and identifiers. -class AndroidPlatformKeySystemProperties : public KeySystemProperties { - public: - AndroidPlatformKeySystemProperties(const std::string& name, - SupportedCodecs supported_codecs) - : name_(name), supported_codecs_(supported_codecs) {} - - std::string GetKeySystemName() const override { return name_; } - - bool IsSupportedInitDataType(EmeInitDataType init_data_type) const override { - // Here we assume that support for a container implies support for the - // associated initialization data type. KeySystems handles validating - // |init_data_type| x |container| pairings. - switch (init_data_type) { - case EmeInitDataType::WEBM: - return (supported_codecs_ & media::EME_CODEC_WEBM_ALL) != 0; - case EmeInitDataType::CENC: -#if defined(USE_PROPRIETARY_CODECS) - return (supported_codecs_ & media::EME_CODEC_MP4_ALL) != 0; -#else - return false; -#endif // defined(USE_PROPRIETARY_CODECS) - case EmeInitDataType::KEYIDS: - case EmeInitDataType::UNKNOWN: - return false; - } - NOTREACHED(); - return false; - } - - SupportedCodecs GetSupportedCodecs() const override { - return supported_codecs_; - } - - EmeConfigRule GetRobustnessConfigRule( - media::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 GetPersistentReleaseMessageSessionSupport() - const override { - return EmeSessionTypeSupport::NOT_SUPPORTED; - } - EmeFeatureSupport GetPersistentStateSupport() const override { - return EmeFeatureSupport::ALWAYS_ENABLED; - } - EmeFeatureSupport GetDistinctiveIdentifierSupport() const override { - return EmeFeatureSupport::ALWAYS_ENABLED; - } - - private: - const std::string name_; - const SupportedCodecs supported_codecs_; -}; - -} // namespace - static SupportedKeySystemResponse QueryKeySystemSupport( const std::string& key_system) { SupportedKeySystemRequest request; @@ -109,8 +41,7 @@ static SupportedKeySystemResponse QueryKeySystemSupport( return response; } -void AddAndroidWidevine( - std::vector>* concrete_key_systems) { +void AddAndroidWidevine(std::vector* concrete_key_systems) { SupportedKeySystemResponse response = QueryKeySystemSupport( kWidevineKeySystem); @@ -119,7 +50,7 @@ void AddAndroidWidevine( // persistence-based features are supported. if (response.compositing_codecs != media::EME_CODEC_NONE) { - concrete_key_systems->emplace_back(new WidevineKeySystemProperties( + AddWidevineWithCodecs( response.compositing_codecs, // Regular codecs. response.non_compositing_codecs, // Hardware-secure codecs. EmeRobustness::HW_SECURE_CRYPTO, // Max audio robustness. @@ -127,7 +58,8 @@ void AddAndroidWidevine( EmeSessionTypeSupport::NOT_SUPPORTED, // persistent-license. EmeSessionTypeSupport::NOT_SUPPORTED, // persistent-release-message. EmeFeatureSupport::ALWAYS_ENABLED, // Persistent state. - EmeFeatureSupport::ALWAYS_ENABLED)); // Distinctive identifier. + EmeFeatureSupport::ALWAYS_ENABLED, // Distinctive identifier. + concrete_key_systems); } else { // It doesn't make sense to support secure codecs but not regular codecs. DCHECK(response.non_compositing_codecs == media::EME_CODEC_NONE); @@ -135,7 +67,7 @@ void AddAndroidWidevine( } void AddAndroidPlatformKeySystems( - std::vector>* concrete_key_systems) { + std::vector* concrete_key_systems) { std::vector key_system_names; content::RenderThread::Get()->Send( new ChromeViewHostMsg_GetPlatformKeySystemNames(&key_system_names)); @@ -144,8 +76,30 @@ void AddAndroidPlatformKeySystems( it != key_system_names.end(); ++it) { SupportedKeySystemResponse response = QueryKeySystemSupport(*it); if (response.compositing_codecs != media::EME_CODEC_NONE) { - concrete_key_systems->emplace_back(new AndroidPlatformKeySystemProperties( - *it, response.compositing_codecs)); + KeySystemInfo info; + info.key_system = *it; + info.supported_codecs = response.compositing_codecs; + // Here we assume that support for a container implies support for the + // associated initialization data type. KeySystems handles validating + // |init_data_type| x |container| pairings. + if (response.compositing_codecs & media::EME_CODEC_WEBM_ALL) + info.supported_init_data_types |= media::kInitDataTypeMaskWebM; +#if defined(USE_PROPRIETARY_CODECS) + if (response.compositing_codecs & media::EME_CODEC_MP4_ALL) + info.supported_init_data_types |= media::kInitDataTypeMaskCenc; +#endif // defined(USE_PROPRIETARY_CODECS) + info.max_audio_robustness = EmeRobustness::EMPTY; + info.max_video_robustness = EmeRobustness::EMPTY; + // Assume that platform key systems support no features but can and will + // make use of persistence and identifiers. + info.persistent_license_support = + media::EmeSessionTypeSupport::NOT_SUPPORTED; + info.persistent_release_message_support = + media::EmeSessionTypeSupport::NOT_SUPPORTED; + info.persistent_state_support = media::EmeFeatureSupport::ALWAYS_ENABLED; + info.distinctive_identifier_support = + media::EmeFeatureSupport::ALWAYS_ENABLED; + concrete_key_systems->push_back(info); } } } diff --git a/components/cdm/renderer/android_key_systems.h b/components/cdm/renderer/android_key_systems.h index f5111c7f35ee46..fb962b15624c6d 100644 --- a/components/cdm/renderer/android_key_systems.h +++ b/components/cdm/renderer/android_key_systems.h @@ -5,22 +5,19 @@ #ifndef COMPONENTS_CDM_RENDERER_ANDROID_KEY_SYSTEMS_H_ #define COMPONENTS_CDM_RENDERER_ANDROID_KEY_SYSTEMS_H_ -#include #include -#include "media/base/key_system_properties.h" +#include "media/base/key_system_info.h" namespace cdm { void AddAndroidWidevine( - std::vector>* - concrete_key_systems); + std::vector* concrete_key_systems); // Add platform-supported key systems which are not explicitly handled // by Chrome. void AddAndroidPlatformKeySystems( - std::vector>* - concrete_key_systems); + std::vector* concrete_key_systems); } // namespace cdm diff --git a/components/cdm/renderer/widevine_key_system_properties.cc b/components/cdm/renderer/widevine_key_system_properties.cc deleted file mode 100644 index 3a6eab49728ccc..00000000000000 --- a/components/cdm/renderer/widevine_key_system_properties.cc +++ /dev/null @@ -1,176 +0,0 @@ -// Copyright 2016 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 "components/cdm/renderer/widevine_key_system_properties.h" - -#include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR. - -#if defined(WIDEVINE_CDM_AVAILABLE) - -using media::EmeConfigRule; -using media::EmeFeatureSupport; -using media::EmeInitDataType; -using media::EmeMediaType; -using media::EmeRobustness; -using media::EmeSessionTypeSupport; -using media::SupportedCodecs; - -namespace cdm { -namespace { - -EmeRobustness ConvertRobustness(const std::string& robustness) { - if (robustness.empty()) - return EmeRobustness::EMPTY; - if (robustness == "SW_SECURE_CRYPTO") - return EmeRobustness::SW_SECURE_CRYPTO; - if (robustness == "SW_SECURE_DECODE") - return EmeRobustness::SW_SECURE_DECODE; - if (robustness == "HW_SECURE_CRYPTO") - return EmeRobustness::HW_SECURE_CRYPTO; - if (robustness == "HW_SECURE_DECODE") - return EmeRobustness::HW_SECURE_DECODE; - if (robustness == "HW_SECURE_ALL") - return EmeRobustness::HW_SECURE_ALL; - return EmeRobustness::INVALID; -} - -} // namespace - -WidevineKeySystemProperties::WidevineKeySystemProperties( - media::SupportedCodecs supported_codecs, -#if defined(OS_ANDROID) - media::SupportedCodecs supported_secure_codecs, -#endif // defined(OS_ANDROID) - media::EmeRobustness max_audio_robustness, - media::EmeRobustness max_video_robustness, - media::EmeSessionTypeSupport persistent_license_support, - media::EmeSessionTypeSupport persistent_release_message_support, - media::EmeFeatureSupport persistent_state_support, - media::EmeFeatureSupport distinctive_identifier_support) - : supported_codecs_(supported_codecs), -#if defined(OS_ANDROID) - supported_secure_codecs_(supported_secure_codecs), -#endif // defined(OS_ANDROID) - max_audio_robustness_(max_audio_robustness), - max_video_robustness_(max_video_robustness), - persistent_license_support_(persistent_license_support), - persistent_release_message_support_(persistent_release_message_support), - persistent_state_support_(persistent_state_support), - distinctive_identifier_support_(distinctive_identifier_support) { -} - -std::string WidevineKeySystemProperties::GetKeySystemName() const { - return kWidevineKeySystem; -} - -bool WidevineKeySystemProperties::IsSupportedInitDataType( - EmeInitDataType init_data_type) const { - // Here we assume that support for a container imples support for the - // associated initialization data type. KeySystems handles validating - // |init_data_type| x |container| pairings. - if (init_data_type == EmeInitDataType::WEBM) - return (supported_codecs_ & media::EME_CODEC_WEBM_ALL) != 0; -#if defined(USE_PROPRIETARY_CODECS) - if (init_data_type == EmeInitDataType::CENC) - return (supported_codecs_ & media::EME_CODEC_MP4_ALL) != 0; -#endif // defined(USE_PROPRIETARY_CODECS) - - return false; -} - -SupportedCodecs WidevineKeySystemProperties::GetSupportedCodecs() const { - return supported_codecs_; -} - -#if defined(OS_ANDROID) -SupportedCodecs WidevineKeySystemProperties::GetSupportedSecureCodecs() const { - return supported_secure_codecs_; -} -#endif - -EmeConfigRule WidevineKeySystemProperties::GetRobustnessConfigRule( - EmeMediaType media_type, - const std::string& requested_robustness) const { - EmeRobustness robustness = ConvertRobustness(requested_robustness); - if (robustness == EmeRobustness::INVALID) - return EmeConfigRule::NOT_SUPPORTED; - - EmeRobustness max_robustness = EmeRobustness::INVALID; - switch (media_type) { - case EmeMediaType::AUDIO: - max_robustness = max_audio_robustness_; - break; - case EmeMediaType::VIDEO: - max_robustness = max_video_robustness_; - break; - } - - // We can compare robustness levels whenever they are not HW_SECURE_CRYPTO - // and SW_SECURE_DECODE in some order. If they are exactly those two then the - // robustness requirement is not supported. - if ((max_robustness == EmeRobustness::HW_SECURE_CRYPTO && - robustness == EmeRobustness::SW_SECURE_DECODE) || - (max_robustness == EmeRobustness::SW_SECURE_DECODE && - robustness == EmeRobustness::HW_SECURE_CRYPTO) || - robustness > max_robustness) { - return EmeConfigRule::NOT_SUPPORTED; - } - -#if defined(OS_CHROMEOS) - // TODO(ddorwin): Remove this once we have confirmed it is not necessary. - // See https://crbug.com/482277 - if (robustness == EmeRobustness::EMPTY) - return EmeConfigRule::SUPPORTED; - - // Hardware security requires remote attestation. - if (robustness >= EmeRobustness::HW_SECURE_CRYPTO) - return EmeConfigRule::IDENTIFIER_REQUIRED; - - // For video, recommend remote attestation if HW_SECURE_ALL is available, - // because it enables hardware accelerated decoding. - // TODO(sandersd): Only do this when hardware accelerated decoding is - // available for the requested codecs. - if (media_type == EmeMediaType::VIDEO && - max_robustness == EmeRobustness::HW_SECURE_ALL) { - return EmeConfigRule::IDENTIFIER_RECOMMENDED; - } -#elif defined(OS_ANDROID) - // Require hardware secure codecs when SW_SECURE_DECODE or above is specified. - if (robustness >= EmeRobustness::SW_SECURE_DECODE) { - return EmeConfigRule::HW_SECURE_CODECS_REQUIRED; - } -#endif // defined(OS_CHROMEOS) - - return EmeConfigRule::SUPPORTED; -} - -EmeSessionTypeSupport -WidevineKeySystemProperties::GetPersistentLicenseSessionSupport() const { - return persistent_license_support_; -} - -EmeSessionTypeSupport -WidevineKeySystemProperties::GetPersistentReleaseMessageSessionSupport() const { - return persistent_release_message_support_; -} - -EmeFeatureSupport WidevineKeySystemProperties::GetPersistentStateSupport() - const { - return persistent_state_support_; -} - -EmeFeatureSupport WidevineKeySystemProperties::GetDistinctiveIdentifierSupport() - const { - return distinctive_identifier_support_; -} - -#if defined(ENABLE_PEPPER_CDMS) -std::string WidevineKeySystemProperties::GetPepperType() const { - return kWidevineCdmPluginMimeType; -} -#endif - -} // namespace cdm - -#endif // WIDEVINE_CDM_AVAILABLE diff --git a/components/cdm/renderer/widevine_key_system_properties.h b/components/cdm/renderer/widevine_key_system_properties.h deleted file mode 100644 index c936c62730d09f..00000000000000 --- a/components/cdm/renderer/widevine_key_system_properties.h +++ /dev/null @@ -1,66 +0,0 @@ -// Copyright 2016 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. - -#ifndef COMPONENTS_CDM_RENDERER_WIDEVINE_KEY_SYSTEM_PROPERTIES_H_ -#define COMPONENTS_CDM_RENDERER_WIDEVINE_KEY_SYSTEM_PROPERTIES_H_ - -#include "build/build_config.h" -#include "media/base/key_system_properties.h" - -namespace cdm { - -// Implementation of KeySystemProperties for Widevine key system. -class WidevineKeySystemProperties : public media::KeySystemProperties { - public: - WidevineKeySystemProperties( - media::SupportedCodecs supported_codecs, -#if defined(OS_ANDROID) - media::SupportedCodecs supported_secure_codecs, -#endif // defined(OS_ANDROID) - media::EmeRobustness max_audio_robustness, - media::EmeRobustness max_video_robustness, - media::EmeSessionTypeSupport persistent_license_support, - media::EmeSessionTypeSupport persistent_release_message_support, - media::EmeFeatureSupport persistent_state_support, - media::EmeFeatureSupport distinctive_identifier_support); - - std::string GetKeySystemName() const override; - bool IsSupportedInitDataType( - media::EmeInitDataType init_data_type) const override; - - media::SupportedCodecs GetSupportedCodecs() const override; -#if defined(OS_ANDROID) - media::SupportedCodecs GetSupportedSecureCodecs() const override; -#endif - - media::EmeConfigRule GetRobustnessConfigRule( - media::EmeMediaType media_type, - const std::string& requested_robustness) const override; - media::EmeSessionTypeSupport GetPersistentLicenseSessionSupport() - const override; - media::EmeSessionTypeSupport GetPersistentReleaseMessageSessionSupport() - const override; - media::EmeFeatureSupport GetPersistentStateSupport() const override; - media::EmeFeatureSupport GetDistinctiveIdentifierSupport() const override; - -#if defined(ENABLE_PEPPER_CDMS) - std::string GetPepperType() const override; -#endif - - private: - const media::SupportedCodecs supported_codecs_; -#if defined(OS_ANDROID) - const media::SupportedCodecs supported_secure_codecs_; -#endif // defined(OS_ANDROID) - const media::EmeRobustness max_audio_robustness_; - const media::EmeRobustness max_video_robustness_; - const media::EmeSessionTypeSupport persistent_license_support_; - const media::EmeSessionTypeSupport persistent_release_message_support_; - const media::EmeFeatureSupport persistent_state_support_; - const media::EmeFeatureSupport distinctive_identifier_support_; -}; - -} // namespace cdm - -#endif // COMPONENTS_CDM_RENDERER_WIDEVINE_KEY_SYSTEM_PROPERTIES_H_ diff --git a/components/cdm/renderer/widevine_key_systems.cc b/components/cdm/renderer/widevine_key_systems.cc new file mode 100644 index 00000000000000..5120d8bc2928cf --- /dev/null +++ b/components/cdm/renderer/widevine_key_systems.cc @@ -0,0 +1,74 @@ +// 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 "components/cdm/renderer/widevine_key_systems.h" + +#include + +#include +#include + +#include "base/logging.h" +#include "build/build_config.h" +#include "media/base/eme_constants.h" + +#include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR. + +#if defined(WIDEVINE_CDM_AVAILABLE) + +using media::KeySystemInfo; +using media::SupportedCodecs; + +namespace cdm { + +void AddWidevineWithCodecs( + SupportedCodecs supported_codecs, +#if defined(OS_ANDROID) + SupportedCodecs supported_secure_codecs, +#endif // defined(OS_ANDROID) + media::EmeRobustness max_audio_robustness, + media::EmeRobustness max_video_robustness, + media::EmeSessionTypeSupport persistent_license_support, + media::EmeSessionTypeSupport persistent_release_message_support, + media::EmeFeatureSupport persistent_state_support, + media::EmeFeatureSupport distinctive_identifier_support, + std::vector* concrete_key_systems) { + KeySystemInfo info; + info.key_system = kWidevineKeySystem; + + // TODO(xhwang): A container or an initDataType may be supported even though + // there are no codecs supported in that container. Fix this when we support + // initDataType. + info.supported_codecs = supported_codecs; +#if defined(OS_ANDROID) + info.supported_secure_codecs = supported_secure_codecs; +#endif // defined(OS_ANDROID) + + // Here we assume that support for a container imples support for the + // associated initialization data type. KeySystems handles validating + // |init_data_type| x |container| pairings. + if (supported_codecs & media::EME_CODEC_WEBM_ALL) + info.supported_init_data_types |= media::kInitDataTypeMaskWebM; +#if defined(USE_PROPRIETARY_CODECS) + if (supported_codecs & media::EME_CODEC_MP4_ALL) + info.supported_init_data_types |= media::kInitDataTypeMaskCenc; +#endif // defined(USE_PROPRIETARY_CODECS) + + info.max_audio_robustness = max_audio_robustness; + info.max_video_robustness = max_video_robustness; + info.persistent_license_support = persistent_license_support; + info.persistent_release_message_support = persistent_release_message_support; + info.persistent_state_support = persistent_state_support; + info.distinctive_identifier_support = distinctive_identifier_support; + +#if defined(ENABLE_PEPPER_CDMS) + info.pepper_type = kWidevineCdmPluginMimeType; +#endif // defined(ENABLE_PEPPER_CDMS) + + concrete_key_systems->push_back(info); +} + +} // namespace cdm + +#endif // defined(WIDEVINE_CDM_AVAILABLE) diff --git a/components/cdm/renderer/widevine_key_systems.h b/components/cdm/renderer/widevine_key_systems.h new file mode 100644 index 00000000000000..e50f7e6eb6c383 --- /dev/null +++ b/components/cdm/renderer/widevine_key_systems.h @@ -0,0 +1,30 @@ +// 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. + +#ifndef COMPONENTS_CDM_RENDERER_WIDEVINE_KEY_SYSTEMS_H_ +#define COMPONENTS_CDM_RENDERER_WIDEVINE_KEY_SYSTEMS_H_ + +#include + +#include "build/build_config.h" +#include "media/base/key_system_info.h" + +namespace cdm { + +void AddWidevineWithCodecs( + media::SupportedCodecs supported_codecs, +#if defined(OS_ANDROID) + media::SupportedCodecs supported_secure_codecs, +#endif // defined(OS_ANDROID) + media::EmeRobustness max_audio_robustness, + media::EmeRobustness max_video_robustness, + media::EmeSessionTypeSupport persistent_license_support, + media::EmeSessionTypeSupport persistent_release_message_support, + media::EmeFeatureSupport persistent_state_support, + media::EmeFeatureSupport distinctive_identifier_support, + std::vector* concrete_key_systems); + +} // namespace cdm + +#endif // COMPONENTS_CDM_RENDERER_WIDEVINE_KEY_SYSTEMS_H_ diff --git a/media/base/key_system_properties.h b/media/base/key_system_properties.h index 67cb4f806388ca..fd443a9bb42c41 100644 --- a/media/base/key_system_properties.h +++ b/media/base/key_system_properties.h @@ -7,7 +7,6 @@ #include -#include "build/build_config.h" #include "media/base/eme_constants.h" #include "media/base/key_system_info.h" #include "media/base/media_export.h"