Refactor KeySystems code to call a function to populate the info.

content/renderer/media/crypto/key_systems_info.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 "content/renderer/media/crypto/key_systems_info.h"
 
 #include "base/logging.h"
-#include "content/renderer/media/crypto/key_systems.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 #include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR.
 
 // The following must be after widevine_cdm_version.h.
 
 #if defined(WIDEVINE_CDM_AVAILABLE) && \
     defined(OS_LINUX) && !defined(OS_CHROMEOS)
 #include <gnu/libc-version.h>
 #include "base/logging.h"
 #include "base/version.h"
 #endif
 
 #if defined(DISABLE_WIDEVINE_CDM_CANPLAYTYPE)
 #include "base/command_line.h"
 #include "media/base/media_switches.h"
 #endif
 
 namespace content {
 
 static const char kClearKeyKeySystem[] = "webkit-org.w3.clearkey";
 
-#if defined(ENABLE_PEPPER_CDMS)
-static const char kExternalClearKeyKeySystem[] =
-    "org.chromium.externalclearkey";
-#elif defined(OS_ANDROID)
-static const uint8 kEmptyUuid[16] =
-    { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-      0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
-#endif
+static const char kAudioWebM[] = "audio/webm";
+static const char kVideoWebM[] = "video/webm";
+static const char kVorbis[] = "vorbis";
+static const char kVorbisVP8[] = "vorbis,vp8,vp8.0";
+
+static const char kAudioMp4[] = "audio/mp4";
+static const char kVideoMp4[] = "video/mp4";
+static const char kMp4a[] = "mp4a";
+static const char kAvc1[] = "avc1";
+static const char kMp4aAvc1[] = "mp4a,avc1";
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
+static void AddWidevineForTypes(bool is_webm_vp8_and_vorbis_supported,
+                        bool is_mp4_supported,
+                        bool is_aac_supported,
+                        bool is_avc1_supported,
+                        std::vector<KeySystemInfo>* concrete_key_systems) {
+  static const char kWidevineParentKeySystem[] = "com.widevine";
 
-#if defined(WIDEVINE_CDM_CENC_SUPPORT_AVAILABLE)
-// The supported codecs depend on what the CDM provides.
-static const char kWidevineVideoMp4Codecs[] =
-#if defined(WIDEVINE_CDM_AVC1_SUPPORT_AVAILABLE) && \
-    defined(WIDEVINE_CDM_AAC_SUPPORT_AVAILABLE)
-    "avc1,mp4a";
-#elif defined(WIDEVINE_CDM_AVC1_SUPPORT_AVAILABLE)
-    "avc1";
-#else
-    "";  // No codec strings are supported.
-#endif
-
-static const char kWidevineAudioMp4Codecs[] =
-#if defined(WIDEVINE_CDM_AAC_SUPPORT_AVAILABLE)
-    "mp4a";
-#else
-    "";  // No codec strings are supported.
-#endif
-#endif  // defined(WIDEVINE_CDM_CENC_SUPPORT_AVAILABLE)
-
-static void RegisterWidevine() {
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   Version glibc_version(gnu_get_libc_version());
   DCHECK(glibc_version.IsValid());
   if (glibc_version.IsOlderThan(WIDEVINE_CDM_MIN_GLIBC_VERSION))
     return;
 #endif  // defined(OS_LINUX) && !defined(OS_CHROMEOS)
 
-  AddConcreteSupportedKeySystem(
-      kWidevineKeySystem,
-      false,
+  KeySystemInfo info(kWidevineKeySystem);
+
+  if (is_webm_vp8_and_vorbis_supported) {
+    info.supported_types.push_back(std::make_pair(kAudioWebM, kVorbis));
+    info.supported_types.push_back(std::make_pair(kVideoWebM, kVorbisVP8));
+  }
+
+  DCHECK(!is_mp4_supported || (!is_aac_supported && !is_aac_supported));
+#if defined(USE_PROPRIETARY_CODECS)
+  if (is_mp4_supported) {
+    const char* video_codecs = is_avc1_supported ?
+                               (is_aac_supported ? kMp4aAvc1 : kAvc1) :
+                               "";
+    const char* audio_codecs = is_aac_supported ? kMp4a : "";
+
+    info.supported_types.push_back(std::make_pair(kAudioMp4, audio_codecs));
+    info.supported_types.push_back(std::make_pair(kVideoMp4, video_codecs));
+  }
+#endif  // defined(USE_PROPRIETARY_CODECS)
+
+  info.parent_key_system = kWidevineParentKeySystem;
+
 #if defined(ENABLE_PEPPER_CDMS)
-      kWidevineCdmPluginMimeType,
+  info.pepper_type = kWidevineCdmPluginMimeType;
 #elif defined(OS_ANDROID)
+  static const uint8 WidevineUuid[16] =
       { 0xED, 0xEF, 0x8B, 0xA9, 0x79, 0xD6, 0x4A, 0xCE,
-        0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED },
+        0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED };
+  info.uuid.assign(WidevineUuid, WidevineUuid + arraysize(WidevineUuid));
 #endif  // defined(ENABLE_PEPPER_CDMS)
-      "com.widevine");
-  AddSupportedType(kWidevineKeySystem, "video/webm", "vorbis,vp8,vp8.0");
-  AddSupportedType(kWidevineKeySystem, "audio/webm", "vorbis");
-#if defined(USE_PROPRIETARY_CODECS) && \
-    defined(WIDEVINE_CDM_CENC_SUPPORT_AVAILABLE)
-  AddSupportedType(kWidevineKeySystem, "video/mp4", kWidevineVideoMp4Codecs);
-  AddSupportedType(kWidevineKeySystem, "audio/mp4", kWidevineAudioMp4Codecs);
-#endif  // defined(USE_PROPRIETARY_CODECS) &&
-        // defined(WIDEVINE_CDM_CENC_SUPPORT_AVAILABLE)
-}
-#endif  // WIDEVINE_CDM_AVAILABLE
 
-
-static void RegisterClearKey() {
-  // Clear Key.
-  AddConcreteSupportedKeySystem(
-      kClearKeyKeySystem,
-      true,
-#if defined(ENABLE_PEPPER_CDMS)
-      std::string(),
-#elif defined(OS_ANDROID)
-      kEmptyUuid,
-#endif  // defined(ENABLE_PEPPER_CDMS)
-      std::string());
-  AddSupportedType(kClearKeyKeySystem, "video/webm", "vorbis,vp8,vp8.0");
-  AddSupportedType(kClearKeyKeySystem, "audio/webm", "vorbis");
-#if defined(USE_PROPRIETARY_CODECS)
-  AddSupportedType(kClearKeyKeySystem, "video/mp4", "avc1,mp4a");
-  AddSupportedType(kClearKeyKeySystem, "audio/mp4", "mp4a");
-#endif  // defined(USE_PROPRIETARY_CODECS)
+  concrete_key_systems->push_back(info);
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
-static void RegisterExternalClearKey() {
-  // External Clear Key (used for testing).
-  AddConcreteSupportedKeySystem(kExternalClearKeyKeySystem, false,
-                                "application/x-ppapi-clearkey-cdm",
-                                std::string());
-  AddSupportedType(kExternalClearKeyKeySystem,
-                   "video/webm", "vorbis,vp8,vp8.0");
-  AddSupportedType(kExternalClearKeyKeySystem, "audio/webm", "vorbis");
+// Supported types are determined at compile time.
+static void AddPepperBasedWidevine(
+    std::vector<KeySystemInfo>* concrete_key_systems) {
+  AddWidevineForTypes(true,  // WebM, VP8 & Vorbis.

[scherkus (not reviewing), 2013/09/03 17:56:16]

considering you call this method once, how about having the #ifdefs do
push_back(...) instead of passing a bool and maintaining another set of if (...)
conditions for the push_back(...) calls?

[ddorwin, 2013/09/03 19:34:59]

AddWidevineForTypes() is intended to be used by other platforms, such as
Android. Android will have its own knowledge and detection that will translate
into these bools.

Also, the logic to translate from the ifdef's/bools to the items added is not
straightforward, so that is encapsulated in AddWidevineForTypes(). For the ifdef
version, see original code 42-60.

+#if defined(WIDEVINE_CDM_CENC_SUPPORT_AVAILABLE)
+                      true,  // MP4.
+#if defined(WIDEVINE_CDM_AAC_SUPPORT_AVAILABLE)
+                      true,  // AAC.
+#else
+                      false,  // No AAC.
+#endif
+#if defined(WIDEVINE_CDM_AVC1_SUPPORT_AVAILABLE)
+                      true,  // AVC1.
+#else
+                      false,  // No AVC1.
+#endif
+#else
+                      false, false, false,  // No MP4 codecs.
+#endif  // defined(WIDEVINE_CDM_CENC_SUPPORT_AVAILABLE)
+                      concrete_key_systems);
+}
+#endif  // defined(ENABLE_PEPPER_CDMS)
+#endif  // WIDEVINE_CDM_AVAILABLE
+
+static void AddClearKey(std::vector<KeySystemInfo>* concrete_key_systems) {
+  KeySystemInfo info(kClearKeyKeySystem);
+
+  info.supported_types.push_back(std::make_pair(kAudioWebM, kVorbis));
+  info.supported_types.push_back(std::make_pair(kVideoWebM, kVorbisVP8));
 #if defined(USE_PROPRIETARY_CODECS)
-  AddSupportedType(kExternalClearKeyKeySystem, "video/mp4", "avc1,mp4a");
-  AddSupportedType(kExternalClearKeyKeySystem, "audio/mp4", "mp4a");
+  info.supported_types.push_back(std::make_pair(kAudioMp4, kMp4a));
+  info.supported_types.push_back(std::make_pair(kVideoMp4, kMp4aAvc1));
 #endif  // defined(USE_PROPRIETARY_CODECS)
+
+  info.use_aes_decryptor = true;
+
+  concrete_key_systems->push_back(info);
+}
+
+#if defined(ENABLE_PEPPER_CDMS)
+// External Clear Key (used for testing).
+static void AddExternalClearKey(
+    std::vector<KeySystemInfo>* concrete_key_systems) {
+  static const char kExternalClearKeyKeySystem[] =
+      "org.chromium.externalclearkey";
+  static const char kExternalClearKeyPepperType[] =
+      "application/x-ppapi-clearkey-cdm";
+
+  KeySystemInfo info(kExternalClearKeyKeySystem);
+
+  info.supported_types.push_back(std::make_pair(kAudioWebM, kVorbis));
+  info.supported_types.push_back(std::make_pair(kVideoWebM, kVorbisVP8));
+#if defined(USE_PROPRIETARY_CODECS)
+  info.supported_types.push_back(std::make_pair(kAudioMp4, kMp4a));
+  info.supported_types.push_back(std::make_pair(kVideoMp4, kMp4aAvc1));
+#endif  // defined(USE_PROPRIETARY_CODECS)
+
+  info.pepper_type = kExternalClearKeyPepperType;
+
+  concrete_key_systems->push_back(info);
 }
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
-void RegisterKeySystems() {
-  RegisterClearKey();
+void AddKeySystems(std::vector<KeySystemInfo>* key_systems_info) {
+  AddClearKey(key_systems_info);
 
 #if defined(ENABLE_PEPPER_CDMS)
-  RegisterExternalClearKey();
+  AddExternalClearKey(key_systems_info);
 #endif
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
-  RegisterWidevine();
+#if defined(ENABLE_PEPPER_CDMS)
+  AddPepperBasedWidevine(key_systems_info);
+#else
+#error TODO(ddorwin): Need to check the platform
+#endif
 #endif
 }
 
 bool IsCanPlayTypeSuppressed(const std::string& key_system) {
 #if defined(DISABLE_WIDEVINE_CDM_CANPLAYTYPE)
   // See http://crbug.com/237627.
   if (key_system == kWidevineKeySystem &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kOverrideEncryptedMediaCanPlayType))
     return true;
 #endif
   return false;
 }
 
 std::string KeySystemNameForUMAInternal(const WebKit::WebString& key_system) {
   if (key_system == kClearKeyKeySystem)
     return "ClearKey";
 #if defined(WIDEVINE_CDM_AVAILABLE)
   if (key_system == kWidevineKeySystem)
     return "Widevine";
 #endif  // WIDEVINE_CDM_AVAILABLE
   return "Unknown";
 }
 
 } // namespace content