media: Add supported CdmProxy::Protocol to CdmCapability

Also parse supported CdmProxy::Protocol from CDM manifest. For CDMs
supporting hardware secure decryption, the supported CdmProxy protocol
should be specified in CDM manifest, e.g. for kIntel protocol:

"x-cdm-supported-cdm-proxy-protocols": ["intel"],

In the next CL, we'll check whether the supported CdmProxy protocol
is also supported by the system.

Bug: 848532
Test: Updated unit tests.
Change-Id: I59567943620e672d72f72fdadd80cb3ce6c5bcfd
Reviewed-on: https://chromium-review.googlesource.com/1111109
Commit-Queue: Xiaohan Wang <xhwang@chromium.org>
Reviewed-by: Joshua Pawlicki <waffles@chromium.org>
Reviewed-by: John Rummell <jrummell@chromium.org>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Reviewed-by: Alex Moshchuk <alexmos@chromium.org>
Cr-Commit-Position: refs/heads/master@{#569889}

chrome/browser/component_updater/DEPS

 include_rules = [
+  "+media/cdm/cdm_proxy.h",
   "+media/cdm/supported_cdm_versions.h",
   "+ppapi/thunk",
   "+third_party/widevine"

chrome/browser/component_updater/widevine_cdm_component_installer.cc

@@ -40,6 +40,7 @@
 // rename it to EncryptionScheme.
 #include "media/base/decrypt_config.h"
 #include "media/base/video_codecs.h"
+#include "media/cdm/cdm_proxy.h"
 #include "media/cdm/supported_cdm_versions.h"
 #include "third_party/widevine/cdm/widevine_cdm_common.h"
 
@@ -106,6 +107,8 @@ const char kCdmPersistentLicenseSupportName[] =
     "x-cdm-persistent-license-support";
 const char kCdmSupportedEncryptionSchemesName[] =
     "x-cdm-supported-encryption-schemes";
+const char kCdmSupportedCdmProxyProtocolsName[] =
+    "x-cdm-supported-cdm-proxy-protocols";
 
 // The following strings are used to specify supported codecs in the
 // parameter |kCdmCodecsListName|.
@@ -120,6 +123,10 @@ const char kCdmSupportedCodecAvc1[] = "avc1";
 const char kCdmSupportedEncryptionSchemeCenc[] = "cenc";
 const char kCdmSupportedEncryptionSchemeCbcs[] = "cbcs";
 
+// The following string(s) are used to specify supported CdmProxy protocols in
+// the parameter |kCdmSupportedCdmProxyProtocolsName|.
+const char kCdmSupportedCdmProxyProtocolIntel[] = "intel";
+
 // Widevine CDM is packaged as a multi-CRX. Widevine CDM binaries are located in
 // _platform_specific/<platform_arch> folder in the package. This function
 // returns the platform-specific subdirectory that is part of that multi-CRX.
@@ -294,6 +301,47 @@ bool GetEncryptionSchemes(
   return true;
 }
 
+// Returns true and updates |cdm_proxy_protocols| if the appropriate manifest
+// entry is valid. Returns false and does not modify |cdm_proxy_protocols| if
+// the manifest entry is incorrectly formatted. Incorrect types in the manifest
+// entry will log the error and fail. Unrecognized values will be reported but
+// otherwise ignored.
+bool GetCdmProxyProtocols(
+    const base::DictionaryValue& manifest,
+    base::flat_set<media::CdmProxy::Protocol>* cdm_proxy_protocols) {
+  const auto* value = manifest.FindKey(kCdmSupportedCdmProxyProtocolsName);
+  if (!value)
+    return true;
+
+  if (!value->is_list()) {
+    DLOG(ERROR) << "Manifest entry " << kCdmSupportedCdmProxyProtocolsName
+                << " is not a list.";
+    return false;
+  }
+
+  const base::Value::ListStorage& list = value->GetList();
+  base::flat_set<media::CdmProxy::Protocol> result;
+  for (const auto& item : list) {
+    if (!item.is_string()) {
+      DLOG(ERROR) << "Unrecognized item type in manifest entry "
+                  << kCdmSupportedCdmProxyProtocolsName;
+      return false;
+    }
+
+    const std::string& protocol = item.GetString();
+    if (protocol == kCdmSupportedCdmProxyProtocolIntel) {
+      result.insert(media::CdmProxy::Protocol::kIntel);
+    } else {
+      DLOG(WARNING) << "Unrecognized CdmProxy protocol" << protocol
+                    << " in manifest entry "
+                    << kCdmSupportedCdmProxyProtocolsName;
+    }
+  }
+
+  cdm_proxy_protocols->swap(result);
+  return true;
+}
+
 // Returns true if the entries in the manifest can be parsed correctly,
 // false otherwise. Updates |capability|, with the values obtained from the
 // manifest, if they are provided. If this method returns false, |capability|
@@ -302,7 +350,8 @@ bool ParseManifest(const base::DictionaryValue& manifest,
                    content::CdmCapability* capability) {
   return GetCodecs(manifest, &capability->video_codecs) &&
          GetEncryptionSchemes(manifest, &capability->encryption_schemes) &&
-         GetSessionTypes(manifest, &capability->session_types);
+         GetSessionTypes(manifest, &capability->session_types) &&
+         GetCdmProxyProtocols(manifest, &capability->cdm_proxy_protocols);
 }
 
 void RegisterWidevineCdmWithChrome(

chrome/common/chrome_content_client.cc

@@ -561,7 +561,8 @@ void ChromeContentClient::AddContentDecryptionModules(
       content::CdmCapability capability(
           {}, {media::EncryptionMode::kCenc, media::EncryptionMode::kCbcs},
           {media::CdmSessionType::TEMPORARY_SESSION,
-           media::CdmSessionType::PERSISTENT_LICENSE_SESSION});
+           media::CdmSessionType::PERSISTENT_LICENSE_SESSION},
+          {});
 
       // Register kExternalClearKeyDifferentGuidTestKeySystem first separately.
       // Otherwise, it'll be treated as a sub-key-system of normal

content/browser/media/cdm_registry_impl_unittest.cc

@@ -26,6 +26,7 @@ namespace {
 using VideoCodec = media::VideoCodec;
 using EncryptionMode = media::EncryptionMode;
 using CdmSessionType = media::CdmSessionType;
+using CdmProxy = media::CdmProxy;
 
 const char kTestCdmName[] = "Test CDM";
 const char kAlternateCdmName[] = "Alternate CDM";
@@ -56,6 +57,9 @@ bool StlEquals(const Container a, std::initializer_list<T> b) {
 #define EXPECT_SESSION_TYPES(...) \
   EXPECT_STL_EQ(cdm.capability.session_types, __VA_ARGS__)
 
+#define EXPECT_CDM_PROXY_PROTOCOLS(...) \
+  EXPECT_STL_EQ(cdm.capability.cdm_proxy_protocols, __VA_ARGS__)
+
 }  // namespace
 
 // For simplicity and to make failures easier to diagnose, this test uses
@@ -66,19 +70,19 @@ class CdmRegistryImplTest : public testing::Test {
   ~CdmRegistryImplTest() override {}
 
  protected:
-  void Register(const std::string& name,
-                const std::string& version,
-                const std::string& path,
-                const std::vector<VideoCodec>& video_codecs,
-                const base::flat_set<CdmSessionType>& session_types,
-                const base::flat_set<EncryptionMode>& encryption_schemes,
-                std::string supported_key_system,
-                bool supports_sub_key_systems = false) {
-    cdm_registry_.RegisterCdm(
-        CdmInfo(name, kTestCdmGuid, base::Version(version),
-                base::FilePath::FromUTF8Unsafe(path), kTestFileSystemId,
-                CdmCapability(video_codecs, encryption_schemes, session_types),
-                supported_key_system, supports_sub_key_systems));
+  CdmInfo GetTestCdmInfo() {
+    return CdmInfo(kTestCdmName, kTestCdmGuid, base::Version(kVersion1),
+                   base::FilePath::FromUTF8Unsafe(kTestPath), kTestFileSystemId,
+                   CdmCapability({media::kCodecVP8, media::kCodecVP9},
+                                 {EncryptionMode::kCenc},
+                                 {CdmSessionType::TEMPORARY_SESSION,
+                                  CdmSessionType::PERSISTENT_LICENSE_SESSION},
+                                 {CdmProxy::Protocol::kIntel}),
+                   kTestKeySystem, /*supports_sub_key_systems=*/true);
+  }
+
+  void Register(CdmInfo cdm_info) {
+    cdm_registry_.RegisterCdm(std::move(cdm_info));
   }
 
   bool IsRegistered(const std::string& name, const std::string& version) {
@@ -103,12 +107,9 @@ class CdmRegistryImplTest : public testing::Test {
 };
 
 TEST_F(CdmRegistryImplTest, Register) {
-  Register(kTestCdmName, kVersion1, kTestPath,
-           {media::kCodecVP8, media::kCodecVP9},
-           {CdmSessionType::TEMPORARY_SESSION,
-            CdmSessionType::PERSISTENT_LICENSE_SESSION},
-           {EncryptionMode::kCenc}, kTestKeySystem, true);
-  std::vector<CdmInfo> cdms = cdm_registry_.GetAllRegisteredCdms();
+  Register(GetTestCdmInfo());
+
+  auto cdms = cdm_registry_.GetAllRegisteredCdms();
   ASSERT_EQ(1u, cdms.size());
   CdmInfo cdm = cdms[0];
   EXPECT_EQ(kTestCdmName, cdm.name);
@@ -116,44 +117,41 @@ TEST_F(CdmRegistryImplTest, Register) {
   EXPECT_EQ(kTestPath, cdm.path.MaybeAsASCII());
   EXPECT_EQ(kTestFileSystemId, cdm.file_system_id);
   EXPECT_VIDEO_CODECS(VideoCodec::kCodecVP8, VideoCodec::kCodecVP9);
+  EXPECT_ENCRYPTION_SCHEMES(EncryptionMode::kCenc);
   EXPECT_SESSION_TYPES(CdmSessionType::TEMPORARY_SESSION,
                        CdmSessionType::PERSISTENT_LICENSE_SESSION);
-  EXPECT_ENCRYPTION_SCHEMES(EncryptionMode::kCenc);
+  EXPECT_CDM_PROXY_PROTOCOLS(CdmProxy::Protocol::kIntel);
   EXPECT_EQ(kTestKeySystem, cdm.supported_key_system);
   EXPECT_TRUE(cdm.supports_sub_key_systems);
 }
 
 TEST_F(CdmRegistryImplTest, ReRegister) {
-  Register(kTestCdmName, kVersion1, "/bb/cc", {},
-           {CdmSessionType::TEMPORARY_SESSION}, {EncryptionMode::kCenc},
-           kTestKeySystem);
+  auto cdm_info = GetTestCdmInfo();
+  Register(cdm_info);
   EXPECT_TRUE(IsRegistered(kTestCdmName, kVersion1));
 
   // Now register same key system with different values.
-  Register(kTestCdmName, kVersion1, kTestPath, {},
-           {CdmSessionType::TEMPORARY_SESSION}, {EncryptionMode::kCenc},
-           kTestKeySystem);
+  cdm_info.supports_sub_key_systems = false;
+  Register(cdm_info);
+
   EXPECT_TRUE(IsRegistered(kTestCdmName, kVersion1));
 }
 
 TEST_F(CdmRegistryImplTest, MultipleVersions) {
-  Register(kTestCdmName, kVersion1, kTestPath, {},
-           {CdmSessionType::TEMPORARY_SESSION}, {EncryptionMode::kCenc},
-           kTestKeySystem);
-  Register(kTestCdmName, kVersion2, "/bb/cc", {},
-           {CdmSessionType::TEMPORARY_SESSION}, {EncryptionMode::kCenc},
-           kTestKeySystem);
+  auto cdm_info = GetTestCdmInfo();
+  Register(cdm_info);
+  cdm_info.version = base::Version(kVersion2);
+  Register(cdm_info);
+
   EXPECT_TRUE(IsRegistered(kTestCdmName, kVersion1));
   EXPECT_TRUE(IsRegistered(kTestCdmName, kVersion2));
 }
 
 TEST_F(CdmRegistryImplTest, NewVersionInsertedLast) {
-  Register(kTestCdmName, kVersion1, kTestPath, {},
-           {CdmSessionType::TEMPORARY_SESSION}, {EncryptionMode::kCenc},
-           kTestKeySystem);
-  Register(kTestCdmName, kVersion2, "/bb/cc", {},
-           {CdmSessionType::TEMPORARY_SESSION}, {EncryptionMode::kCenc},
-           kTestKeySystem);
+  auto cdm_info = GetTestCdmInfo();
+  Register(cdm_info);
+  cdm_info.version = base::Version(kVersion2);
+  Register(cdm_info);
 
   const std::vector<std::string> versions = GetVersions(kTestCdmGuid);
   EXPECT_EQ(2u, versions.size());
@@ -162,20 +160,20 @@ TEST_F(CdmRegistryImplTest, NewVersionInsertedLast) {
 }
 
 TEST_F(CdmRegistryImplTest, DifferentNames) {
-  Register(kTestCdmName, kVersion1, kTestPath, {},
-           {CdmSessionType::TEMPORARY_SESSION}, {EncryptionMode::kCenc},
-           kTestKeySystem);
-  Register(kAlternateCdmName, kVersion1, kTestPath, {},
-           {CdmSessionType::TEMPORARY_SESSION}, {EncryptionMode::kCbcs},
-           kTestKeySystem);
+  auto cdm_info = GetTestCdmInfo();
+  Register(cdm_info);
+  cdm_info.name = kAlternateCdmName;
+  Register(cdm_info);
+
   EXPECT_TRUE(IsRegistered(kTestCdmName, kVersion1));
   EXPECT_TRUE(IsRegistered(kAlternateCdmName, kVersion1));
 }
 
 TEST_F(CdmRegistryImplTest, SupportedEncryptionSchemes) {
-  Register(kTestCdmName, kVersion1, kTestPath, {},
-           {CdmSessionType::TEMPORARY_SESSION},
-           {EncryptionMode::kCenc, EncryptionMode::kCbcs}, kTestKeySystem);
+  auto cdm_info = GetTestCdmInfo();
+  cdm_info.capability.encryption_schemes = {EncryptionMode::kCenc,
+                                            EncryptionMode::kCbcs};
+  Register(cdm_info);
 
   std::vector<CdmInfo> cdms = cdm_registry_.GetAllRegisteredCdms();
   ASSERT_EQ(1u, cdms.size());

content/browser/media/key_system_support_impl.cc

@@ -117,6 +117,7 @@ void KeySystemSupportImpl::IsKeySystemSupported(
 
     // TODO(xhwang): Call into GetContentClient()->browser() to get key system
     // specific hardware secure decryption capability on Windows.
+    // TODO(xhwang): Also check cdm_info->capability.cdm_proxy_protocols.
     NOTIMPLEMENTED();
   }
 

content/browser/media/key_system_support_impl_unittest.cc

@@ -60,20 +60,25 @@ class KeySystemSupportTest : public testing::Test {
     KeySystemSupportImpl::Create(mojo::MakeRequest(&key_system_support_));
   }
 
-  // Registers |key_system| with supported capabilities. All other values for
-  // CdmInfo have some default value as they're not returned by
-  // IsKeySystemSupported().
-  void Register(const std::string& key_system,
-                const std::vector<VideoCodec>& video_codecs,
-                const base::flat_set<CdmSessionType>& session_types,
-                const base::flat_set<EncryptionMode>& encryption_schemes) {
+  // TODO(xhwang): Add tests for hardware secure video codecs and encryption
+  // schemes.
+  CdmCapability GetTestCdmCapability() {
+    return CdmCapability({VideoCodec::kCodecVP8, VideoCodec::kCodecVP9},
+                         {EncryptionMode::kCenc, EncryptionMode::kCbcs},
+                         {CdmSessionType::TEMPORARY_SESSION,
+                          CdmSessionType::PERSISTENT_LICENSE_SESSION},
+                         {});
+  }
+
+  // Registers |key_system| with |capability|. All other values for CdmInfo have
+  // some default value as they're not returned by IsKeySystemSupported().
+  void Register(const std::string& key_system, CdmCapability capability) {
     DVLOG(1) << __func__;
 
     CdmRegistry::GetInstance()->RegisterCdm(
         CdmInfo(key_system, kTestCdmGuid, base::Version(kVersion),
                 base::FilePath::FromUTF8Unsafe(kTestPath), kTestFileSystemId,
-                CdmCapability(video_codecs, encryption_schemes, session_types),
-                key_system, false));
+                std::move(capability), key_system, false));
   }
 
   // Determines if |key_system| is registered. If it is, updates |codecs_|
@@ -103,43 +108,25 @@ TEST_F(KeySystemSupportTest, NoKeySystems) {
 }
 
 TEST_F(KeySystemSupportTest, OneKeySystem) {
-  Register("KeySystem2", {VideoCodec::kCodecVP8},
-           {CdmSessionType::TEMPORARY_SESSION,
-            CdmSessionType::PERSISTENT_LICENSE_SESSION},
-           {EncryptionMode::kCenc, EncryptionMode::kCbcs});
+  Register("KeySystem2", GetTestCdmCapability());
 
   EXPECT_TRUE(IsSupported("KeySystem2"));
-  EXPECT_VIDEO_CODECS(VideoCodec::kCodecVP8);
+  EXPECT_VIDEO_CODECS(VideoCodec::kCodecVP8, VideoCodec::kCodecVP9);
   EXPECT_ENCRYPTION_SCHEMES(EncryptionMode::kCenc, EncryptionMode::kCbcs);
   EXPECT_SESSION_TYPES(CdmSessionType::TEMPORARY_SESSION,
                        CdmSessionType::PERSISTENT_LICENSE_SESSION);
 }
 
 TEST_F(KeySystemSupportTest, MultipleKeySystems) {
-  Register("KeySystem3", {VideoCodec::kCodecVP8, VideoCodec::kCodecVP9},
-           {CdmSessionType::TEMPORARY_SESSION,
-            CdmSessionType::PERSISTENT_LICENSE_SESSION},
-           {EncryptionMode::kCenc});
-  Register("KeySystem4", {VideoCodec::kCodecVP9},
-           {CdmSessionType::TEMPORARY_SESSION}, {EncryptionMode::kCbcs});
+  Register("KeySystem3", GetTestCdmCapability());
+  Register("KeySystem4", GetTestCdmCapability());
 
   EXPECT_TRUE(IsSupported("KeySystem3"));
-  EXPECT_VIDEO_CODECS(VideoCodec::kCodecVP8, VideoCodec::kCodecVP9);
-  EXPECT_ENCRYPTION_SCHEMES(EncryptionMode::kCenc);
-  EXPECT_SESSION_TYPES(CdmSessionType::TEMPORARY_SESSION,
-                       CdmSessionType::PERSISTENT_LICENSE_SESSION);
-
   EXPECT_TRUE(IsSupported("KeySystem4"));
-  EXPECT_VIDEO_CODECS(VideoCodec::kCodecVP9);
-  EXPECT_ENCRYPTION_SCHEMES(EncryptionMode::kCbcs);
-  EXPECT_SESSION_TYPES(CdmSessionType::TEMPORARY_SESSION);
 }
 
 TEST_F(KeySystemSupportTest, MissingKeySystem) {
-  Register("KeySystem5", {VideoCodec::kCodecVP8},
-           {CdmSessionType::TEMPORARY_SESSION,
-            CdmSessionType::PERSISTENT_LICENSE_SESSION},
-           {EncryptionMode::kCenc});
+  Register("KeySystem5", GetTestCdmCapability());
 
   EXPECT_FALSE(IsSupported("KeySystem6"));
   EXPECT_FALSE(capability_);

content/common/media/cdm_info.cc

@@ -14,10 +14,12 @@ CdmCapability::CdmCapability() = default;
 CdmCapability::CdmCapability(
     std::vector<media::VideoCodec> video_codecs,
     base::flat_set<media::EncryptionMode> encryption_schemes,
-    base::flat_set<media::CdmSessionType> session_types)
+    base::flat_set<media::CdmSessionType> session_types,
+    base::flat_set<media::CdmProxy::Protocol> cdm_proxy_protocols)
     : video_codecs(std::move(video_codecs)),
       encryption_schemes(std::move(encryption_schemes)),
-      session_types(std::move(session_types)) {}
+      session_types(std::move(session_types)),
+      cdm_proxy_protocols(std::move(cdm_proxy_protocols)) {}
 
 CdmCapability::CdmCapability(const CdmCapability& other) = default;
 

content/public/common/cdm_info.h

@@ -17,6 +17,7 @@
 // rename it to EncryptionScheme.
 #include "media/base/decrypt_config.h"
 #include "media/base/video_codecs.h"
+#include "media/cdm/cdm_proxy.h"
 
 namespace content {
 
@@ -25,7 +26,8 @@ struct CONTENT_EXPORT CdmCapability {
   CdmCapability();
   CdmCapability(std::vector<media::VideoCodec> video_codecs,
                 base::flat_set<media::EncryptionMode> encryption_schemes,
-                base::flat_set<media::CdmSessionType> session_types);
+                base::flat_set<media::CdmSessionType> session_types,
+                base::flat_set<media::CdmProxy::Protocol> cdm_proxy_protocols);
   CdmCapability(const CdmCapability& other);
   ~CdmCapability();
 
@@ -41,6 +43,10 @@ struct CONTENT_EXPORT CdmCapability {
 
   // List of session types supported by the CDM.
   base::flat_set<media::CdmSessionType> session_types;
+
+  // List of CdmProxy protocols supported by the CDM. These protocols should
+  // also be supported by the system to support hardware secure decryption.
+  base::flat_set<media::CdmProxy::Protocol> cdm_proxy_protocols;
 };
 
 // Represents a Content Decryption Module implementation and its capabilities.