Change EmeInitDataType to be an enum class

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 16 matching lines @@
 
 // These names are used by UMA. Do not change them!
 const char kClearKeyKeySystemNameForUMA[] = "ClearKey";
 const char kUnknownKeySystemNameForUMA[] = "Unknown";
 
 struct NamedInitDataType {
   const char* name;
   EmeInitDataType type;
 };
 
-// Mapping between initialization data types names and enum values. When adding
-// entries, make sure to update IsSaneInitDataTypeWithContainer().
+// Mapping between initialization data types names and enum values.
 static NamedInitDataType kInitDataTypeNames[] = {
-    {"webm", EME_INIT_DATA_TYPE_WEBM},
-#if defined(USE_PROPRIETARY_CODECS)
-    {"cenc", EME_INIT_DATA_TYPE_CENC},
-#endif  // defined(USE_PROPRIETARY_CODECS)
-    {"keyids", EME_INIT_DATA_TYPE_KEYIDS},
+    {"webm", EmeInitDataType::WEBM},
+    {"cenc", EmeInitDataType::CENC},
+    {"keyids", EmeInitDataType::KEYIDS},
 };
 
 struct NamedCodec {
   const char* name;
   EmeCodec type;
 };
 
 // Mapping between containers and their codecs.
 // Only audio codec can belong to a "audio/*" container. Both audio and video
 // codecs can belong to a "video/*" container.
@@ skipping 23 matching lines @@
 
 static void AddClearKey(std::vector<KeySystemInfo>* concrete_key_systems) {
   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 | EME_INIT_DATA_TYPE_KEYIDS;
+      kSupportedInitDataTypeWebM | kSupportedInitDataTypeKeyIds;
   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_init_data_types |= kSupportedInitDataTypeCenc;
   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;
 
@@ skipping 195 matching lines @@
   // Always update supported key systems during construction.
   UpdateSupportedKeySystems();
 }
 
 EmeInitDataType KeySystems::GetInitDataTypeForName(
     const std::string& init_data_type) const {
   InitDataTypesMap::const_iterator iter =
       init_data_type_name_map_.find(init_data_type);
   if (iter != init_data_type_name_map_.end())
     return iter->second;
-  return EME_INIT_DATA_TYPE_NONE;
+  return EmeInitDataType::NONE;

[sandersd (OOO until July 31), 2015/03/23 21:27:30]

This method is only used from one place, and it's for masking. It should be the
masks that are returned.

I'm fine with either removing |kInitDataTypeNames| and its uses, or updating it
to hold mask values. Slight preference for removing entirely, because it will be
easier to switch away from a string parameter in the next CL.

[jrummell, 2015/03/25 21:44:25]

In the future calls to IsSupportedKeySystemWithInitDataType() below will pass in
the EMEInitDataType rather than a string, so there will still need to be a
conversion.

As well, it will get used publicly in the next CL to convert the strings until
everything is converted to the enum. Leaving it as is until is can be completely
removed.

 }
 
 SupportedCodecs KeySystems::GetCodecMaskForContainer(
     const std::string& container) const {
   ContainerCodecsMap::const_iterator iter =
       container_to_codec_mask_map_.find(container);
   if (iter != container_to_codec_mask_map_.end())
     return iter->second;
   return EME_CODEC_NONE;
 }
@@ skipping 183 matching lines @@
     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.
   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 KeySystemInfo& info = key_system_iter->second;
-  EmeInitDataType eme_init_data_type = GetInitDataTypeForName(init_data_type);
-  return (info.supported_init_data_types & eme_init_data_type) != 0;
+  // Check |init_data_type|.
+  SupportedInitDataTypes available_init_data_types =
+      key_system_iter->second.supported_init_data_types;
+  switch (GetInitDataTypeForName(init_data_type)) {
+    case EmeInitDataType::NONE:
+      return false;
+    case EmeInitDataType::WEBM:
+      return (available_init_data_types & kSupportedInitDataTypeWebM) != 0;
+    case EmeInitDataType::CENC:
+      return (available_init_data_types & kSupportedInitDataTypeCenc) != 0;
+    case EmeInitDataType::KEYIDS:
+      return (available_init_data_types & kSupportedInitDataTypeKeyIds) != 0;
+  }
+  NOTREACHED();
+  return false;
 }
 
 // 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) {
@@ skipping 238 matching lines @@
 
 std::string GetPrefixedKeySystemName(const std::string& key_system) {
   DCHECK_NE(key_system, kPrefixedClearKeyKeySystem);
 
   if (key_system == kClearKeyKeySystem)
     return kPrefixedClearKeyKeySystem;
 
   return key_system;
 }
 
-bool IsSaneInitDataTypeWithContainer(
-    const std::string& init_data_type,
-    const std::string& container) {
-  if (init_data_type == "cenc") {
-    return container == "audio/mp4" || container == "video/mp4";
-  } else if (init_data_type == "webm") {
-    return  container == "audio/webm" || container == "video/webm";
-  } else {
-    return true;
-  }
-}
-
 bool PrefixedIsSupportedConcreteKeySystem(const std::string& key_system) {
   return KeySystems::GetInstance().IsConcreteSupportedKeySystem(key_system);
 }
 
 bool IsSupportedKeySystem(const std::string& key_system) {
   if (!KeySystems::GetInstance().IsSupportedKeySystem(key_system))
     return false;
 
   // TODO(ddorwin): Move this to where we add key systems when prefixed EME is
   // removed (crbug.com/249976).
@@ skipping 82 matching lines @@
 
 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