Implement checks for distinctiveIdentifier and persistentState in requestMediaKeySystemAccess().

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 <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
@@ skipping 56 matching lines @@
     {"vp9", EME_CODEC_WEBM_VP9},
     {"vp9.0", EME_CODEC_WEBM_VP9},
 #if defined(USE_PROPRIETARY_CODECS)
     {"mp4a", EME_CODEC_MP4_AAC},
     {"avc1", EME_CODEC_MP4_AVC1},
     {"avc3", EME_CODEC_MP4_AVC1}
 #endif  // defined(USE_PROPRIETARY_CODECS)
 };
 
 static void AddClearKey(std::vector<KeySystemInfo>* concrete_key_systems) {
-  KeySystemInfo info(kClearKeyKeySystem);
+  KeySystemInfo info;
+  info.key_system = kClearKeyKeySystem;
 
   // On Android, Vorbis, VP8, AAC and AVC1 are supported in MediaCodec:
   // http://developer.android.com/guide/appendix/media-formats.html
   // VP9 support is device dependent.
 
   info.supported_init_data_types = EME_INIT_DATA_TYPE_WEBM;
   info.supported_codecs = EME_CODEC_WEBM_ALL;
 
 #if defined(OS_ANDROID)
   // Temporarily disable VP9 support for Android.
   // TODO(xhwang): Use mime_util.h to query VP9 support on Android.
   info.supported_codecs &= ~EME_CODEC_WEBM_VP9;
 
   // Opus is not supported on Android yet. http://crbug.com/318436.
   // TODO(sandersd): Check for platform support to set this bit.
   info.supported_codecs &= ~EME_CODEC_WEBM_OPUS;
 #endif  // defined(OS_ANDROID)
 
 #if defined(USE_PROPRIETARY_CODECS)
   info.supported_init_data_types |= EME_INIT_DATA_TYPE_CENC;
   info.supported_codecs |= EME_CODEC_MP4_ALL;
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
+  info.persistent_license_support = EME_SESSION_TYPE_NOT_SUPPORTED;
+  info.persistent_release_message_support = EME_SESSION_TYPE_NOT_SUPPORTED;
+  info.persistent_state_support = EME_FEATURE_NOT_SUPPORTED;
+  info.distinctive_identifier_support = EME_FEATURE_NOT_SUPPORTED;
+
   info.use_aes_decryptor = true;
 
   concrete_key_systems->push_back(info);
 }
 
 class KeySystems {
  public:
   static KeySystems& GetInstance();
 
   void UpdateIfNeeded();
@@ skipping 13 matching lines @@
       bool is_prefixed);
 
   std::string GetKeySystemNameForUMA(const std::string& key_system) const;
 
   bool UseAesDecryptor(const std::string& concrete_key_system);
 
 #if defined(ENABLE_PEPPER_CDMS)
   std::string GetPepperType(const std::string& concrete_key_system);
 #endif
 
+  bool IsPersistentLicenseSessionSupported(
+      const std::string& key_system,
+      bool is_permission_granted);
+
+  bool IsPersistentReleaseMessageSessionSupported(
+      const std::string& key_system,
+      bool is_permission_granted);
+
+  bool IsPersistentStateRequirementSupported(
+      const std::string& key_system,
+      EmeFeatureRequirement requirement,
+      bool is_permission_granted);
+
+  bool IsDistinctiveIdentifierRequirementSupported(
+      const std::string& key_system,
+      EmeFeatureRequirement requirement,
+      bool is_permission_granted);
+
   void AddContainerMask(const std::string& container, uint32 mask);
   void AddCodecMask(const std::string& codec, uint32 mask);
 
  private:
   void InitializeUMAInfo();
 
   void UpdateSupportedKeySystems();
 
   void AddConcreteSupportedKeySystems(
       const std::vector<KeySystemInfo>& concrete_key_systems);
 
-  void AddConcreteSupportedKeySystem(
-      const std::string& key_system,
-      bool use_aes_decryptor,
-#if defined(ENABLE_PEPPER_CDMS)
-      const std::string& pepper_type,
-#endif
-      SupportedInitDataTypes supported_init_data_types,
-      SupportedCodecs supported_codecs,
-      const std::string& parent_key_system);
-
   friend struct base::DefaultLazyInstanceTraits<KeySystems>;
 
-  struct KeySystemProperties {
-    KeySystemProperties()
-        : use_aes_decryptor(false), supported_codecs(EME_CODEC_NONE) {}
-
-    bool use_aes_decryptor;
-#if defined(ENABLE_PEPPER_CDMS)
-    std::string pepper_type;
-#endif
-    SupportedInitDataTypes supported_init_data_types;
-    SupportedCodecs supported_codecs;
-  };
-
-  typedef base::hash_map<std::string, KeySystemProperties>
-      KeySystemPropertiesMap;
+  typedef base::hash_map<std::string, KeySystemInfo> KeySystemInfoMap;
   typedef base::hash_map<std::string, std::string> ParentKeySystemMap;
   typedef base::hash_map<std::string, SupportedCodecs> ContainerCodecsMap;
   typedef base::hash_map<std::string, EmeCodec> CodecsMap;
   typedef base::hash_map<std::string, EmeInitDataType> InitDataTypesMap;
   typedef base::hash_map<std::string, std::string> KeySystemNameForUMAMap;
 
   KeySystems();
   ~KeySystems() {}
 
   EmeInitDataType GetInitDataTypeForName(
@@ skipping 14 matching lines @@
                             SupportedCodecs key_system_supported_codecs) const;
 
   // Returns true if all |codecs| are supported in |container| by checking
   // |key_system_supported_codecs|.
   bool IsSupportedContainerAndCodecs(
       const std::string& container,
       const std::vector<std::string>& codecs,
       SupportedCodecs key_system_supported_codecs) const;
 
   // Map from key system string to capabilities.
-  KeySystemPropertiesMap concrete_key_system_map_;
+  KeySystemInfoMap concrete_key_system_map_;
 
   // Map from parent key system to the concrete key system that should be used
   // to represent its capabilities.
   ParentKeySystemMap parent_key_system_map_;
 
   KeySystemsSupportUMA key_systems_support_uma_;
 
   InitDataTypesMap init_data_type_name_map_;
   ContainerCodecsMap container_to_codec_mask_map_;
   CodecsMap codec_string_map_;
@@ skipping 114 matching lines @@
 
   AddConcreteSupportedKeySystems(key_systems_info);
 }
 
 void KeySystems::AddConcreteSupportedKeySystems(
     const std::vector<KeySystemInfo>& concrete_key_systems) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(concrete_key_system_map_.empty());
   DCHECK(parent_key_system_map_.empty());
 
-  for (size_t i = 0; i < concrete_key_systems.size(); ++i) {
-    const KeySystemInfo& key_system_info = concrete_key_systems[i];
-    AddConcreteSupportedKeySystem(key_system_info.key_system,
-                                  key_system_info.use_aes_decryptor,
+  for (const KeySystemInfo& info : concrete_key_systems) {
+    DCHECK(!info.key_system.empty());
+    DCHECK_NE(info.persistent_license_support, EME_SESSION_TYPE_INVALID);
+    DCHECK_NE(info.persistent_release_message_support,
+              EME_SESSION_TYPE_INVALID);
+    DCHECK_NE(info.persistent_state_support, EME_FEATURE_INVALID);
+    // TODO(sandersd): Assert that distinctive_identifier_support is
+    // NOT_SUPPORTED or REQUESTABLE_WITH_PERMISSION once blocking is working and
+    // there are no longer any CDMs declaring ALWAYS_ENABLED.

[ddorwin, 2015/02/20 00:49:08]

As discussed, ALWAYS_ENABLED is correct for Android, etc. We will prevent these
from being used if there is no permission.

The REQUESTABLE values simply mean that it can work either way (and we should
enforce it - see below).

[sandersd (OOO until July 31), 2015/02/20 01:25:35]

Done.

+    // http://crbug.com/457482

[ddorwin, 2015/02/20 00:49:08]

As discussed, we currently assume all CDMs are either NOT_SUPPORTED or
ALWAYS_ENABLED. We should assert this.

Perhaps a better way to implement these checks is to do NOT_SUPPORTED ||
ALWAYS_ENABLED. Later, we will add || REQUESTABLE_WITH_PERMISSION

[sandersd (OOO until July 31), 2015/02/20 01:25:35]

Done.

+    DCHECK_NE(info.distinctive_identifier_support, EME_FEATURE_INVALID);
+    DCHECK_NE(info.distinctive_identifier_support,
+              EME_FEATURE_REQUESTABLE) << "Use REQUESTABLE_WITH_PERMISSION";
+    if (info.persistent_state_support == EME_FEATURE_NOT_SUPPORTED) {
+      DCHECK_EQ(info.persistent_license_support,
+                EME_SESSION_TYPE_NOT_SUPPORTED);
+      DCHECK_EQ(info.persistent_release_message_support,
+                EME_SESSION_TYPE_NOT_SUPPORTED);
+    }
+    DCHECK(!IsSupportedKeySystem(info.key_system))
+        << "Key system '" << info.key_system << "' already registered";
+    DCHECK(!parent_key_system_map_.count(info.key_system))
+        <<  "'" << info.key_system << "' is already registered as a parent";
 #if defined(ENABLE_PEPPER_CDMS)
-                                  key_system_info.pepper_type,
+    DCHECK_EQ(info.use_aes_decryptor, info.pepper_type.empty());
 #endif
-                                  key_system_info.supported_init_data_types,
-                                  key_system_info.supported_codecs,
-                                  key_system_info.parent_key_system);
+
+    concrete_key_system_map_[info.key_system] = info;
+
+    if (!info.parent_key_system.empty()) {
+      DCHECK(!IsConcreteSupportedKeySystem(info.parent_key_system))
+          << "Parent '" << info.parent_key_system << "' "
+          << "already registered concrete";
+      DCHECK(!parent_key_system_map_.count(info.parent_key_system))
+          << "Parent '" << info.parent_key_system << "' already registered";
+      parent_key_system_map_[info.parent_key_system] = info.key_system;
+    }
   }
 }
 
-void KeySystems::AddConcreteSupportedKeySystem(
-    const std::string& concrete_key_system,
-    bool use_aes_decryptor,
-#if defined(ENABLE_PEPPER_CDMS)
-    const std::string& pepper_type,
-#endif
-    SupportedInitDataTypes supported_init_data_types,
-    SupportedCodecs supported_codecs,
-    const std::string& parent_key_system) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!IsConcreteSupportedKeySystem(concrete_key_system))
-      << "Key system '" << concrete_key_system << "' already registered";
-  DCHECK(!parent_key_system_map_.count(concrete_key_system))
-      <<  "'" << concrete_key_system << " is already registered as a parent";
-
-  KeySystemProperties properties;
-  properties.use_aes_decryptor = use_aes_decryptor;
-#if defined(ENABLE_PEPPER_CDMS)
-  DCHECK_EQ(use_aes_decryptor, pepper_type.empty());
-  properties.pepper_type = pepper_type;
-#endif
-
-  properties.supported_init_data_types = supported_init_data_types;
-  properties.supported_codecs = supported_codecs;
-
-  concrete_key_system_map_[concrete_key_system] = properties;
-
-  if (!parent_key_system.empty()) {
-    DCHECK(!IsConcreteSupportedKeySystem(parent_key_system))
-        << "Parent '" << parent_key_system << "' already registered concrete";
-    DCHECK(!parent_key_system_map_.count(parent_key_system))
-        << "Parent '" << parent_key_system << "' already registered";
-    parent_key_system_map_[parent_key_system] = concrete_key_system;
-  }
-}
-
 bool KeySystems::IsConcreteSupportedKeySystem(const std::string& key_system) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return concrete_key_system_map_.count(key_system) != 0;
 }
 
 bool KeySystems::IsSupportedContainer(
     const std::string& container,
     SupportedCodecs key_system_supported_codecs) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!container.empty());
@@ skipping 50 matching lines @@
   // Unprefixed EME only supports concrete key systems.
   return concrete_key_system_map_.count(key_system) != 0;
 }
 
 bool KeySystems::IsSupportedKeySystemWithInitDataType(
     const std::string& key_system,
     const std::string& init_data_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Locate |key_system|. Only concrete key systems are supported in unprefixed.
-  KeySystemPropertiesMap::const_iterator key_system_iter =
+  KeySystemInfoMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(key_system);
   if (key_system_iter == concrete_key_system_map_.end())
     return false;
 
   // Check |init_data_type| and |key_system| x |init_data_type|.
-  const KeySystemProperties& properties = key_system_iter->second;
+  const KeySystemInfo& info = key_system_iter->second;
   EmeInitDataType eme_init_data_type = GetInitDataTypeForName(init_data_type);
-  return (properties.supported_init_data_types & eme_init_data_type) != 0;
+  return (info.supported_init_data_types & eme_init_data_type) != 0;
 }
 
 // TODO(sandersd): Reorganize to be more similar to
 // IsKeySystemSupportedWithInitDataType(). Note that a fork may still be
 // required; http://crbug.com/417461.
 bool KeySystems::IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system,
     bool is_prefixed) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const bool report_to_uma = is_prefixed;
 
   // If |is_prefixed| and |key_system| is a parent key system, use its concrete
   // child.
   const std::string& concrete_key_system = is_prefixed ?
       PrefixedGetConcreteKeySystemNameFor(key_system) :
       key_system;
 
   bool has_type = !mime_type.empty();
 
   if (report_to_uma)
     key_systems_support_uma_.ReportKeySystemQuery(key_system, has_type);
 
   // Check key system support.
-  KeySystemPropertiesMap::const_iterator key_system_iter =
+  KeySystemInfoMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(concrete_key_system);
   if (key_system_iter == concrete_key_system_map_.end())
     return false;
 
   if (report_to_uma)
     key_systems_support_uma_.ReportKeySystemSupport(key_system, false);
 
   if (!has_type) {
     DCHECK(codecs.empty());
     return true;
@@ skipping 24 matching lines @@
       key_system_name_for_uma_map_.find(key_system);
   if (iter == key_system_name_for_uma_map_.end())
     return kUnknownKeySystemNameForUMA;
 
   return iter->second;
 }
 
 bool KeySystems::UseAesDecryptor(const std::string& concrete_key_system) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  KeySystemPropertiesMap::const_iterator key_system_iter =
+  KeySystemInfoMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(concrete_key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
       DLOG(FATAL) << concrete_key_system << " is not a known concrete system";
       return false;
   }
 
   return key_system_iter->second.use_aes_decryptor;
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
 std::string KeySystems::GetPepperType(const std::string& concrete_key_system) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  KeySystemPropertiesMap::const_iterator key_system_iter =
+  KeySystemInfoMap::const_iterator key_system_iter =
       concrete_key_system_map_.find(concrete_key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
       DLOG(FATAL) << concrete_key_system << " is not a known concrete system";
       return std::string();
   }
 
   const std::string& type = key_system_iter->second.pepper_type;
   DLOG_IF(FATAL, type.empty()) << concrete_key_system << " is not Pepper-based";
   return type;
 }
 #endif
 
+bool KeySystems::IsPersistentLicenseSessionSupported(
+    const std::string& key_system,
+    bool is_permission_granted) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  KeySystemInfoMap::const_iterator key_system_iter =
+      concrete_key_system_map_.find(key_system);
+  if (key_system_iter == concrete_key_system_map_.end()) {
+    NOTREACHED();
+    return false;
+  }
+
+  switch (key_system_iter->second.persistent_license_support) {
+    case EME_SESSION_TYPE_INVALID:
+      NOTREACHED();
+      return false;
+    case EME_SESSION_TYPE_NOT_SUPPORTED:
+      return false;
+    case EME_SESSION_TYPE_SUPPORTED_WITH_PERMISSION:
+      return is_permission_granted;
+    case EME_SESSION_TYPE_SUPPORTED:
+      return true;
+  }
+
+  NOTREACHED();
+  return false;
+}
+
+bool KeySystems::IsPersistentReleaseMessageSessionSupported(
+    const std::string& key_system,
+    bool is_permission_granted) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  KeySystemInfoMap::const_iterator key_system_iter =
+      concrete_key_system_map_.find(key_system);
+  if (key_system_iter == concrete_key_system_map_.end()) {
+    NOTREACHED();
+    return false;
+  }
+
+  switch (key_system_iter->second.persistent_release_message_support) {
+    case EME_SESSION_TYPE_INVALID:
+      NOTREACHED();
+      return false;
+    case EME_SESSION_TYPE_NOT_SUPPORTED:
+      return false;
+    case EME_SESSION_TYPE_SUPPORTED_WITH_PERMISSION:
+      return is_permission_granted;
+    case EME_SESSION_TYPE_SUPPORTED:
+      return true;
+  }
+
+  NOTREACHED();
+  return false;
+}
+
+bool KeySystems::IsPersistentStateRequirementSupported(
+    const std::string& key_system,
+    EmeFeatureRequirement requirement,
+    bool is_permission_granted) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  KeySystemInfoMap::const_iterator key_system_iter =
+      concrete_key_system_map_.find(key_system);
+  if (key_system_iter == concrete_key_system_map_.end()) {
+    NOTREACHED();
+    return false;
+  }
+
+  switch (key_system_iter->second.persistent_state_support) {
+    case EME_FEATURE_INVALID:
+      NOTREACHED();
+      return false;
+    case EME_FEATURE_NOT_SUPPORTED:
+      return requirement != EME_FEATURE_REQUIRED;
+    case EME_FEATURE_REQUESTABLE_WITH_PERMISSION:
+      return (requirement != EME_FEATURE_REQUIRED) || is_permission_granted;

[ddorwin, 2015/02/20 00:49:08]

That's true for the ID, but desktop/CrOS (chrome_key_systems.cc) use
REQUESTABLE. Thus, we need a check or to change those to use ALWAYS and enforce
this in the registration like we are going to for the ID.

[sandersd (OOO until July 31), 2015/02/20 01:25:35]

Done.

+    case EME_FEATURE_REQUESTABLE:
+      return true;
+    case EME_FEATURE_ALWAYS_ENABLED:
+      return requirement != EME_FEATURE_NOT_ALLOWED;
+  }
+
+  NOTREACHED();
+  return false;
+}
+
+bool KeySystems::IsDistinctiveIdentifierRequirementSupported(
+    const std::string& key_system,
+    EmeFeatureRequirement requirement,
+    bool is_permission_granted) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  KeySystemInfoMap::const_iterator key_system_iter =
+      concrete_key_system_map_.find(key_system);
+  if (key_system_iter == concrete_key_system_map_.end()) {
+    NOTREACHED();
+    return false;
+  }
+
+  switch (key_system_iter->second.distinctive_identifier_support) {
+    case EME_FEATURE_INVALID:
+      NOTREACHED();
+      return false;
+    case EME_FEATURE_NOT_SUPPORTED:
+      return requirement != EME_FEATURE_REQUIRED;
+    case EME_FEATURE_REQUESTABLE_WITH_PERMISSION:
+      return (requirement != EME_FEATURE_REQUIRED) || is_permission_granted;

[ddorwin, 2015/02/20 00:49:08]

This one is okay I guess if we make the registration DCHECK.

[sandersd (OOO until July 31), 2015/02/20 01:25:35]

Done.

+    case EME_FEATURE_REQUESTABLE:
+      NOTREACHED();
+      return true;
+    case EME_FEATURE_ALWAYS_ENABLED:
+      // TODO(sandersd): This should be NOTREACHED(). http://crbug.com/457482
+      return requirement != EME_FEATURE_NOT_ALLOWED;
+  }
+
+  NOTREACHED();
+  return false;
+}
+
 void KeySystems::AddContainerMask(const std::string& container, uint32 mask) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!container_to_codec_mask_map_.count(container));
   container_to_codec_mask_map_[container] = static_cast<EmeCodec>(mask);
 }
 
 void KeySystems::AddCodecMask(const std::string& codec, uint32 mask) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!codec_string_map_.count(codec));
   codec_string_map_[codec] = static_cast<EmeCodec>(mask);
@@ skipping 70 matching lines @@
 bool CanUseAesDecryptor(const std::string& concrete_key_system) {
   return KeySystems::GetInstance().UseAesDecryptor(concrete_key_system);
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
 std::string GetPepperType(const std::string& concrete_key_system) {
   return KeySystems::GetInstance().GetPepperType(concrete_key_system);
 }
 #endif
 
+bool IsPersistentLicenseSessionSupported(
+    const std::string& key_system,
+    bool is_permission_granted) {
+  return KeySystems::GetInstance().IsPersistentLicenseSessionSupported(
+      key_system, is_permission_granted);
+}
+
+bool IsPersistentReleaseMessageSessionSupported(
+    const std::string& key_system,
+    bool is_permission_granted) {
+  return KeySystems::GetInstance().IsPersistentReleaseMessageSessionSupported(
+      key_system, is_permission_granted);
+}
+
+bool IsPersistentStateRequirementSupported(
+    const std::string& key_system,
+    EmeFeatureRequirement requirement,
+    bool is_permission_granted) {
+  return KeySystems::GetInstance().IsPersistentStateRequirementSupported(
+      key_system, requirement, is_permission_granted);
+}
+
+bool IsDistinctiveIdentifierRequirementSupported(
+    const std::string& key_system,
+    EmeFeatureRequirement requirement,
+    bool is_permission_granted) {
+  return KeySystems::GetInstance().IsDistinctiveIdentifierRequirementSupported(
+      key_system, requirement, is_permission_granted);
+}
+
 // These two functions are for testing purpose only. The declaration in the
 // header file is guarded by "#if defined(UNIT_TEST)" so that they can be used
 // by tests but not non-test code. However, this .cc file is compiled as part of
 // "media" where "UNIT_TEST" is not defined. So we need to specify
 // "MEDIA_EXPORT" here again so that they are visible to tests.
 
-MEDIA_EXPORT void AddContainerMask(const std::string& container,
-                                     uint32 mask) {
+MEDIA_EXPORT void AddContainerMask(const std::string& container, uint32 mask) {
   KeySystems::GetInstance().AddContainerMask(container, mask);
 }
 
 MEDIA_EXPORT void AddCodecMask(const std::string& codec, uint32 mask) {
   KeySystems::GetInstance().AddCodecMask(codec, mask);
 }
 
 }  // namespace media