Change EmeInitDataType to be an enum class

Mask values are seperated out into consts of type
SupportedInitDataTypes. Also removes unused function
IsSaneInitDataTypeWithContainer().

BUG=417440
TEST=EME layout tests pass

Review URL: https://codereview.chromium.org/1027363002

Cr-Commit-Position: refs/heads/master@{#322286}

chrome/renderer/media/chrome_key_systems.cc

@@ -76,10 +76,10 @@ static void AddExternalClearKey(
   info.key_system = kExternalClearKeyKeySystem;
 
   info.supported_init_data_types =
-      media::EME_INIT_DATA_TYPE_WEBM | media::EME_INIT_DATA_TYPE_KEYIDS;
+    media::kInitDataTypeMaskWebM | media::kInitDataTypeMaskKeyIds;
   info.supported_codecs = media::EME_CODEC_WEBM_ALL;
 #if defined(USE_PROPRIETARY_CODECS)
-  info.supported_init_data_types |= media::EME_INIT_DATA_TYPE_CENC;
+  info.supported_init_data_types |= media::kInitDataTypeMaskCenc;
   info.supported_codecs |= media::EME_CODEC_MP4_ALL;
 #endif  // defined(USE_PROPRIETARY_CODECS)
 

chromecast/renderer/key_systems_cast.cc

@@ -22,7 +22,7 @@ void AddKeySystemWithCodecs(
     std::vector<::media::KeySystemInfo>* key_systems_info) {
   ::media::KeySystemInfo info;
   info.key_system = key_system_name;
-  info.supported_init_data_types = ::media::EME_INIT_DATA_TYPE_CENC;
+  info.supported_init_data_types = ::media::kInitDataTypeMaskCenc;
   info.supported_codecs =
       ::media::EME_CODEC_MP4_AAC | ::media::EME_CODEC_MP4_AVC1;
   info.max_audio_robustness = ::media::EmeRobustness::EMPTY;

components/cdm/renderer/android_key_systems.cc

@@ -107,10 +107,10 @@ void AddAndroidPlatformKeySystems(
       // 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::EME_INIT_DATA_TYPE_WEBM;
+        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::EME_INIT_DATA_TYPE_CENC;
+        info.supported_init_data_types |= media::kInitDataTypeMaskCenc;
 #endif  // defined(USE_PROPRIETARY_CODECS)
       info.max_audio_robustness = EmeRobustness::EMPTY;
       info.max_video_robustness = EmeRobustness::EMPTY;

components/cdm/renderer/widevine_key_systems.cc

@@ -62,10 +62,10 @@ void AddWidevineWithCodecs(
   // 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::EME_INIT_DATA_TYPE_WEBM;
+    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::EME_INIT_DATA_TYPE_CENC;
+    info.supported_init_data_types |= media::kInitDataTypeMaskCenc;
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
   info.max_audio_robustness = max_audio_robustness;

content/browser/media/cdm/browser_cdm_manager.cc

@@ -347,14 +347,14 @@ void BrowserCdmManager::OnCreateSessionAndGenerateRequest(
     return;
   }
 
-  media::EmeInitDataType eme_init_data_type = media::EME_INIT_DATA_TYPE_NONE;
+  media::EmeInitDataType eme_init_data_type;
   switch (init_data_type) {
     case INIT_DATA_TYPE_WEBM:
-      eme_init_data_type = media::EME_INIT_DATA_TYPE_WEBM;
+      eme_init_data_type = media::EmeInitDataType::WEBM;
       break;
 #if defined(USE_PROPRIETARY_CODECS)
     case INIT_DATA_TYPE_CENC:
-      eme_init_data_type = media::EME_INIT_DATA_TYPE_CENC;
+      eme_init_data_type = media::EmeInitDataType::CENC;
       break;
 #endif
     default:
@@ -560,11 +560,11 @@ void BrowserCdmManager::CreateSessionAndGenerateRequestIfPermitted(
   // "audio"/"video" does not matter, so use "video".
   std::string init_data_type_string;
   switch (init_data_type) {
-    case media::EME_INIT_DATA_TYPE_WEBM:
+    case media::EmeInitDataType::WEBM:
       init_data_type_string = "video/webm";
       break;
 #if defined(USE_PROPRIETARY_CODECS)
-    case media::EME_INIT_DATA_TYPE_CENC:
+    case media::EmeInitDataType::CENC:
       init_data_type_string = "video/mp4";
       break;
 #endif

media/base/eme_constants.h

@@ -9,18 +9,23 @@
 
 namespace media {
 
-// Defines bitmask values that specify registered initialization data types used
+// Defines values that specify registered Initialization Data Types used
 // in Encrypted Media Extensions (EME).
-// The mask values are stored in a SupportedInitDataTypes.
-enum EmeInitDataType {
-  EME_INIT_DATA_TYPE_NONE = 0,
-  EME_INIT_DATA_TYPE_WEBM = 1 << 0,
-#if defined(USE_PROPRIETARY_CODECS)
-  EME_INIT_DATA_TYPE_CENC = 1 << 1,
-#endif  // defined(USE_PROPRIETARY_CODECS)
-  EME_INIT_DATA_TYPE_KEYIDS = 1 << 2,
+// http://w3c.github.io/encrypted-media/initdata-format-registry.html#registry
+// The mask values are stored in a InitDataTypeMask.
+enum class EmeInitDataType {
+  UNKNOWN,
+  WEBM,
+  CENC,
+  KEYIDS
 };
 
+typedef uint32_t InitDataTypeMask;
+const InitDataTypeMask kInitDataTypeMaskNone = 0;
+const InitDataTypeMask kInitDataTypeMaskWebM = 1 << 0;
+const InitDataTypeMask kInitDataTypeMaskCenc = 1 << 1;
+const InitDataTypeMask kInitDataTypeMaskKeyIds = 1 << 2;
+
 // Defines bitmask values that specify codecs used in Encrypted Media Extension
 // (EME). Each value represents a codec within a specific container.
 // The mask values are stored in a SupportedCodecs.
@@ -51,7 +56,6 @@ enum EmeCodec {
 #endif  // defined(USE_PROPRIETARY_CODECS)
 };
 
-typedef uint32_t SupportedInitDataTypes;
 typedef uint32_t SupportedCodecs;
 
 enum EmeSessionTypeSupport {

media/base/key_system_info.cc

@@ -7,7 +7,7 @@
 namespace media {
 
 KeySystemInfo::KeySystemInfo()
-    : supported_init_data_types(EME_INIT_DATA_TYPE_NONE),
+    : supported_init_data_types(kInitDataTypeMaskNone),
       supported_codecs(EME_CODEC_NONE),
       max_audio_robustness(EmeRobustness::INVALID),
       max_video_robustness(EmeRobustness::INVALID),

media/base/key_system_info.h

@@ -35,7 +35,7 @@ struct MEDIA_EXPORT KeySystemInfo {
 
   std::string key_system;
 
-  SupportedInitDataTypes supported_init_data_types;
+  InitDataTypeMask supported_init_data_types;
   SupportedCodecs supported_codecs;
   EmeRobustness max_audio_robustness;
   EmeRobustness max_video_robustness;

media/base/key_systems.cc

@@ -34,14 +34,11 @@ struct NamedInitDataType {
   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 {
@@ -120,7 +117,7 @@ static void AddClearKey(std::vector<KeySystemInfo>* concrete_key_systems) {
   // VP9 support is device dependent.
 
   info.supported_init_data_types =
-      EME_INIT_DATA_TYPE_WEBM | EME_INIT_DATA_TYPE_KEYIDS;
+      kInitDataTypeMaskWebM | kInitDataTypeMaskKeyIds;
   info.supported_codecs = EME_CODEC_WEBM_ALL;
 
 #if defined(OS_ANDROID)
@@ -134,7 +131,7 @@ static void AddClearKey(std::vector<KeySystemInfo>* concrete_key_systems) {
 #endif  // defined(OS_ANDROID)
 
 #if defined(USE_PROPRIETARY_CODECS)
-  info.supported_init_data_types |= EME_INIT_DATA_TYPE_CENC;
+  info.supported_init_data_types |= kInitDataTypeMaskCenc;
   info.supported_codecs |= EME_CODEC_MP4_ALL;
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
@@ -368,7 +365,7 @@ EmeInitDataType KeySystemsImpl::GetInitDataTypeForName(
       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::UNKNOWN;
 }
 
 SupportedCodecs KeySystemsImpl::GetCodecMaskForContainer(
@@ -591,10 +588,21 @@ bool KeySystemsImpl::IsSupportedKeySystemWithInitDataType(
   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|.
+  InitDataTypeMask available_init_data_types =
+      key_system_iter->second.supported_init_data_types;
+  switch (GetInitDataTypeForName(init_data_type)) {
+    case EmeInitDataType::UNKNOWN:
+      return false;
+    case EmeInitDataType::WEBM:
+      return (available_init_data_types & kInitDataTypeMaskWebM) != 0;
+    case EmeInitDataType::CENC:
+      return (available_init_data_types & kInitDataTypeMaskCenc) != 0;
+    case EmeInitDataType::KEYIDS:
+      return (available_init_data_types & kInitDataTypeMaskKeyIds) != 0;
+  }
+  NOTREACHED();
+  return false;
 }
 
 bool KeySystemsImpl::PrefixedIsSupportedKeySystemWithMediaMimeType(
@@ -953,18 +961,6 @@ std::string GetPrefixedKeySystemName(const std::string& key_system) {
   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 KeySystemsImpl::GetInstance().IsConcreteSupportedKeySystem(key_system);
 }

media/base/key_systems.h

@@ -79,15 +79,6 @@ MEDIA_EXPORT std::string GetUnprefixedKeySystemName(
 MEDIA_EXPORT std::string GetPrefixedKeySystemName(
     const std::string& key_system);
 
-// Returns false if a container-specific |init_data_type| is specified with an
-// inappropriate container.
-// TODO(sandersd): Remove this essentially internal detail if the spec is
-// updated to not convolve the two in a single method call.
-// TODO(sandersd): Use enum values instead of strings. http://crbug.com/417440
-MEDIA_EXPORT bool IsSaneInitDataTypeWithContainer(
-    const std::string& init_data_type,
-    const std::string& container);
-
 // Use for unprefixed EME only!
 // Returns whether |key_system| is a supported key system.
 // Note: Shouldn't be used for prefixed API as the original

media/base/key_systems_unittest.cc

@@ -190,7 +190,7 @@ void TestMediaClient::AddUsesAesKeySystem(
   system.key_system = name;
   system.supported_codecs = EME_CODEC_WEBM_ALL;
   system.supported_codecs |= TEST_CODEC_FOO_ALL;
-  system.supported_init_data_types = EME_INIT_DATA_TYPE_WEBM;
+  system.supported_init_data_types = kInitDataTypeMaskWebM;
   system.max_audio_robustness = EmeRobustness::EMPTY;
   system.max_video_robustness = EmeRobustness::EMPTY;
   system.persistent_license_support = EME_SESSION_TYPE_NOT_SUPPORTED;
@@ -207,7 +207,7 @@ void TestMediaClient::AddExternalKeySystem(
   ext.key_system = kExternal;
   ext.supported_codecs = EME_CODEC_WEBM_ALL;
   ext.supported_codecs |= TEST_CODEC_FOO_ALL;
-  ext.supported_init_data_types = EME_INIT_DATA_TYPE_WEBM;
+  ext.supported_init_data_types = kInitDataTypeMaskWebM;
   ext.max_audio_robustness = EmeRobustness::EMPTY;
   ext.max_video_robustness = EmeRobustness::EMPTY;
   ext.persistent_license_support = EME_SESSION_TYPE_SUPPORTED;