media: Enable encrypted media content browsertests when MojoCdm is used

media/base/key_systems.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/base/key_systems.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "media/base/key_system_names.h"
 #include "media/base/key_system_properties.h"
 #include "media/base/media.h"
+#include "media/base/media_switches.h"
 #include "ppapi/features/features.h"
 #include "media/base/media_client.h"
 #include "third_party/widevine/cdm/widevine_cdm_common.h"
 
 namespace media {
 
 const char kClearKeyKeySystem[] = "org.w3.clearkey";
 
 // These names are used by UMA. Do not change them!
 const char kClearKeyKeySystemNameForUMA[] = "ClearKey";
@@ skipping 312 matching lines @@
   // Add key systems supported by the MediaClient implementation.
   if (GetMediaClient())
     GetMediaClient()->AddSupportedKeySystems(&key_systems_properties);
 
   // Clear Key is always supported.
   key_systems_properties.emplace_back(new ClearKeyProperties());
 
   AddSupportedKeySystems(&key_systems_properties);
 }
 
+// Returns whether distinctive identifiers and persistent state can be reliably
+// blocked for |properties| (and therefore be safely configurable).
+static bool CanBlock(const KeySystemProperties& properties) {
+#if BUILDFLAG(ENABLE_PEPPER_CDMS)
+  // Distinctive identifiers and persistent state can be reliably blocked for
+  // Pepper-hosted key systems.
+  DCHECK_EQ(properties.UseAesDecryptor(), properties.GetPepperType().empty());
+  if (!properties.GetPepperType().empty())
+    return true;
+#endif
+
+  // When AesDecryptor is used, we are sure we can block.
+  if (properties.UseAesDecryptor())
+    return true;
+
+  // For External Clear Key, it is either implemented as a pepper CDM (Clear Key
+  // CDM), which is covered above, or by using AesDecryptor remotely, e.g. via
+  // MojoCdm. In both cases, we can block. This is only used for testing.
+  if (base::FeatureList::IsEnabled(media::kExternalClearKeyForTesting) &&
+      IsExternalClearKey(properties.GetKeySystemName()))
+    return true;
+
+  // For other platforms assume the CDM can and will do anything. So we cannot
+  // block.
+  return false;
+}
+
 void KeySystemsImpl::AddSupportedKeySystems(
     std::vector<std::unique_ptr<KeySystemProperties>>* key_systems) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(key_system_properties_map_.empty());
 
   for (auto& properties : *key_systems) {
     DCHECK(!properties->GetKeySystemName().empty());
     DCHECK(properties->GetPersistentLicenseSessionSupport() !=
            EmeSessionTypeSupport::INVALID);
     DCHECK(properties->GetPersistentReleaseMessageSessionSupport() !=
@@ skipping 28 matching lines @@
     // If distinctive identifiers are not supported, then no other features can
     // require them.
     if (properties->GetDistinctiveIdentifierSupport() ==
         EmeFeatureSupport::NOT_SUPPORTED) {
       DCHECK(properties->GetPersistentLicenseSessionSupport() !=
              EmeSessionTypeSupport::SUPPORTED_WITH_IDENTIFIER);
       DCHECK(properties->GetPersistentReleaseMessageSessionSupport() !=
              EmeSessionTypeSupport::SUPPORTED_WITH_IDENTIFIER);
     }
 
-    // Distinctive identifiers and persistent state can only be reliably blocked
-    // (and therefore be safely configurable) for Pepper-hosted key systems. For
-    // other platforms assume the CDM can and will do anything, except for the
-    // following two cases:
-    // 1) AES decryptor, and
-    // 2) External Clear Key key system on Android, only enabled for testing.
-    bool can_block = properties->UseAesDecryptor();
-#if BUILDFLAG(ENABLE_PEPPER_CDMS)
-    DCHECK_EQ(properties->UseAesDecryptor(),
-              properties->GetPepperType().empty());
-    if (!properties->GetPepperType().empty())
-      can_block = true;
-#elif defined(OS_ANDROID)
-    if (IsExternalClearKey(properties->GetKeySystemName()))
-      can_block = true;
-#endif
-    if (!can_block) {
+    if (!CanBlock(*properties)) {
       DCHECK(properties->GetDistinctiveIdentifierSupport() ==
              EmeFeatureSupport::ALWAYS_ENABLED);
       DCHECK(properties->GetPersistentStateSupport() ==
              EmeFeatureSupport::ALWAYS_ENABLED);
     }
 
     DCHECK_EQ(key_system_properties_map_.count(properties->GetKeySystemName()),
               0u)
         << "Key system '" << properties->GetKeySystemName()
         << "' already registered";
@@ skipping 294 matching lines @@
                                uint32_t mask) {
   KeySystemsImpl::GetInstance()->AddCodecMask(media_type, codec, mask);
 }
 
 MEDIA_EXPORT void AddMimeTypeCodecMask(const std::string& mime_type,
                                        uint32_t mask) {
   KeySystemsImpl::GetInstance()->AddMimeTypeCodecMask(mime_type, mask);
 }
 
 }  // namespace media