Store SupportedCodecs in KeySystemInfo and KeySystems.

chrome/renderer/media/chrome_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 "chrome/renderer/media/chrome_key_systems.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/renderer/render_thread.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(WIDEVINE_CDM_MIN_GLIBC_VERSION)
 #include <gnu/libc-version.h>
 #include "base/version.h"
 #endif
 
-#if defined(OS_ANDROID)
-#include "chrome/common/encrypted_media_messages_android.h"
-#endif
-
 using content::KeySystemInfo;
-
-const char kAudioWebM[] = "audio/webm";
-const char kVideoWebM[] = "video/webm";
-const char kVorbis[] = "vorbis";
-const char kVP8[] = "vp8";
-const char kVP80[] = "vp8.0";
-
-#if defined(USE_PROPRIETARY_CODECS)
-const char kAudioMp4[] = "audio/mp4";
-const char kVideoMp4[] = "video/mp4";
-const char kMp4a[] = "mp4a";
-const char kAvc1[] = "avc1";
-const char kAvc3[] = "avc3";
-#endif  // defined(USE_PROPRIETARY_CODECS)
+using media::SupportedCodecs;
 
 #if defined(ENABLE_PEPPER_CDMS)
 static bool IsPepperCdmRegistered(
     const std::string& pepper_type,
     std::vector<base::string16>* additional_param_names,
     std::vector<base::string16>* additional_param_values) {
   bool is_registered = false;
   content::RenderThread::Get()->Send(
       new ChromeViewHostMsg_IsInternalPluginRegisteredForMimeType(
           pepper_type,
@@ skipping 23 matching lines @@
   std::vector<base::string16> additional_param_names;
   std::vector<base::string16> additional_param_values;
   if (!IsPepperCdmRegistered(kExternalClearKeyPepperType,
                              &additional_param_names,
                              &additional_param_values)) {
     return;
   }
 
   KeySystemInfo info(kExternalClearKeyKeySystem);
 
-  info.supported_types[kAudioWebM].insert(kVorbis);
-  info.supported_types[kVideoWebM] = info.supported_types[kAudioWebM];
-  info.supported_types[kVideoWebM].insert(kVP8);
-  info.supported_types[kVideoWebM].insert(kVP80);
+  info.supported_codecs = media::WEBM_CODECS;
 #if defined(USE_PROPRIETARY_CODECS)
-  info.supported_types[kAudioMp4].insert(kMp4a);
-  info.supported_types[kVideoMp4] = info.supported_types[kAudioMp4];
-  info.supported_types[kVideoMp4].insert(kAvc1);
-  info.supported_types[kVideoMp4].insert(kAvc3);
+  info.supported_codecs |= media::MP4_CODECS;
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
   info.pepper_type = kExternalClearKeyPepperType;
 
   concrete_key_systems->push_back(info);
 
   // Add support of decrypt-only mode in ClearKeyCdm.
   info.key_system = kExternalClearKeyDecryptOnlyKeySystem;
   concrete_key_systems->push_back(info);
 
@@ skipping 16 matching lines @@
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
 enum WidevineCdmType {
   WIDEVINE,
   WIDEVINE_HR,
 #if defined(OS_ANDROID)
   WIDEVINE_HR_NON_COMPOSITING,
 #endif
 };
 
-// Defines bitmask values used to specify supported codecs.
-// Each value represents a codec within a specific container.
-// The mask values are stored in a SupportedCodecs.
-typedef uint32 SupportedCodecs;
-enum SupportedCodecMasks {
-  NO_CODECS = 0,
-  WEBM_VORBIS = 1 << 0,
-  WEBM_VP8 = 1 << 1,
-  WEBM_CODECS = (WEBM_VORBIS | WEBM_VP8),
-#if defined(USE_PROPRIETARY_CODECS)
-  MP4_AAC = 1 << 2,
-  MP4_AVC1 = 1 << 3,
-  MP4_CODECS = (MP4_AAC | MP4_AVC1),
-  ALL_CODECS = (WEBM_CODECS | MP4_CODECS),
-#else
-  ALL_CODECS = WEBM_CODECS,
-#endif  // defined(USE_PROPRIETARY_CODECS)
-  INVALID_CODECS = ~ALL_CODECS
-};
 
-#if defined(OS_ANDROID)
-#define COMPILE_ASSERT_MATCHING_ENUM(name) \
-  COMPILE_ASSERT(static_cast<int>(name) == \
-                 static_cast<int>(android::name), \
-                 mismatching_enums)
-COMPILE_ASSERT_MATCHING_ENUM(NO_CODECS);
-COMPILE_ASSERT_MATCHING_ENUM(WEBM_VORBIS);
-COMPILE_ASSERT_MATCHING_ENUM(WEBM_VP8);
-COMPILE_ASSERT_MATCHING_ENUM(WEBM_CODECS);
-COMPILE_ASSERT_MATCHING_ENUM(MP4_AAC);
-COMPILE_ASSERT_MATCHING_ENUM(MP4_AVC1);
-COMPILE_ASSERT_MATCHING_ENUM(MP4_CODECS);
-COMPILE_ASSERT_MATCHING_ENUM(ALL_CODECS);
-COMPILE_ASSERT_MATCHING_ENUM(INVALID_CODECS);
-#undef COMPILE_ASSERT_MATCHING_ENUM
-#else
+#if !defined(OS_ANDROID)
 static bool IsWidevineHrSupported() {
   // TODO(jrummell): Need to call CheckPlatformState() but it is
   // asynchronous, and needs to be done in the browser.
   return false;
 }
 #endif
 
 // Return |name|'s parent key system.
 static std::string GetDirectParentName(std::string name) {
   int last_period = name.find_last_of('.');
@@ skipping 17 matching lines @@
       break;
 #if defined(OS_ANDROID)
     case WIDEVINE_HR_NON_COMPOSITING:
       info.key_system.append(".hrnoncompositing");
       break;
 #endif
     default:
       NOTREACHED();
   }
 
-  // TODO(xhwang): A container or an initDataType may be supported even though
-  // there are no codecs supported in that container. Fix this when we support
-  // initDataType.
-  if (supported_codecs & WEBM_CODECS) {
-    if (supported_codecs & WEBM_VORBIS)
-      info.supported_types[kAudioWebM].insert(kVorbis);
-
-    if (supported_codecs & WEBM_VP8) {
-      info.supported_types[kVideoWebM] = info.supported_types[kAudioWebM];
-      info.supported_types[kVideoWebM].insert(kVP8);
-      info.supported_types[kVideoWebM].insert(kVP80);
-    }
-  }
-
-#if defined(USE_PROPRIETARY_CODECS)
-  if (supported_codecs & MP4_CODECS) {
-    if (supported_codecs & MP4_AAC)
-      info.supported_types[kAudioMp4].insert(kMp4a);
-
-    if (supported_codecs & MP4_AVC1) {
-      info.supported_types[kVideoMp4] = info.supported_types[kAudioMp4];
-      info.supported_types[kVideoMp4].insert(kAvc1);
-      info.supported_types[kVideoMp4].insert(kAvc3);
-    }
-  }
-#endif  // defined(USE_PROPRIETARY_CODECS)
+  info.supported_codecs = supported_codecs;
 
 #if defined(ENABLE_PEPPER_CDMS)
   info.pepper_type = kWidevineCdmPluginMimeType;
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
   concrete_key_systems->push_back(info);
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
 // When the adapter is registered, a name-value pair is inserted in
@@ skipping 41 matching lines @@
   if (!IsPepperCdmRegistered(kWidevineCdmPluginMimeType,
                              &additional_param_names,
                              &additional_param_values)) {
     DVLOG(1) << "Widevine CDM is not currently available.";
     return;
   }
 
   std::vector<std::string> codecs;
   GetSupportedCodecs(additional_param_names, additional_param_values, &codecs);
 
-  SupportedCodecs supported_codecs = NO_CODECS;
+  SupportedCodecs supported_codecs = media::NO_CODECS;
   for (size_t i = 0; i < codecs.size(); ++i) {
     if (codecs[i] == kCdmSupportedCodecVorbis)
-      supported_codecs |= WEBM_VORBIS;
+      supported_codecs |= media::WEBM_VORBIS;
     if (codecs[i] == kCdmSupportedCodecVp8)
-      supported_codecs |= WEBM_VP8;
+      supported_codecs |= media::WEBM_VP8;
 #if defined(USE_PROPRIETARY_CODECS)
     if (codecs[i] == kCdmSupportedCodecAac)
-      supported_codecs |= MP4_AAC;
+      supported_codecs |= media::MP4_AAC;
     if (codecs[i] == kCdmSupportedCodecAvc1)
-      supported_codecs |= MP4_AVC1;
+      supported_codecs |= media::MP4_AVC1;
 #endif  // defined(USE_PROPRIETARY_CODECS)
   }
 
   AddWidevineWithCodecs(WIDEVINE, supported_codecs, concrete_key_systems);
 
   if (IsWidevineHrSupported())
     AddWidevineWithCodecs(WIDEVINE_HR, supported_codecs, concrete_key_systems);
 }
 #elif defined(OS_ANDROID)
 static void AddAndroidWidevine(
     std::vector<KeySystemInfo>* concrete_key_systems) {
   SupportedKeySystemRequest request;
   SupportedKeySystemResponse response;
 
   request.key_system = kWidevineKeySystem;
-  request.codecs = static_cast<android::SupportedCodecs>(android::WEBM_CODECS |
-                                                         android::MP4_CODECS);
+  request.codecs = media::WEBM_CODECS | media::MP4_CODECS;
   content::RenderThread::Get()->Send(
       new ChromeViewHostMsg_GetSupportedKeySystems(request, &response));
-  DCHECK_EQ(response.compositing_codecs & android::INVALID_CODECS,
-            android::NO_CODECS)
+  DCHECK_EQ(response.compositing_codecs & media::INVALID_CODECS,
+            media::NO_CODECS)
       << "unrecognized codec";
-  DCHECK_EQ(response.non_compositing_codecs & android::INVALID_CODECS,
-            android::NO_CODECS)
+  DCHECK_EQ(response.non_compositing_codecs & media::INVALID_CODECS,
+            media::NO_CODECS)
       << "unrecognized codec";
-  if (response.compositing_codecs != android::NO_CODECS) {
+  if (response.compositing_codecs != media::NO_CODECS) {
     AddWidevineWithCodecs(
         WIDEVINE,
         static_cast<SupportedCodecs>(response.compositing_codecs),
         concrete_key_systems);
   }
 
-  if (response.non_compositing_codecs != android::NO_CODECS) {
+  if (response.non_compositing_codecs != media::NO_CODECS) {
     AddWidevineWithCodecs(
         WIDEVINE_HR_NON_COMPOSITING,
         static_cast<SupportedCodecs>(response.non_compositing_codecs),
         concrete_key_systems);
   }
 }
 #endif  // defined(ENABLE_PEPPER_CDMS)
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 
 void AddChromeKeySystems(std::vector<KeySystemInfo>* key_systems_info) {
 #if defined(ENABLE_PEPPER_CDMS)
   AddExternalClearKey(key_systems_info);
 #endif
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
 #if defined(ENABLE_PEPPER_CDMS)
   AddPepperBasedWidevine(key_systems_info);
 #elif defined(OS_ANDROID)
   AddAndroidWidevine(key_systems_info);
 #endif
 #endif
 }