Componentize EncryptedMediaMessageFilter and rename it CdmMessageFilter.

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 "components/encrypted_media/renderer/widevine_key_systems.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;
 using content::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(
@@ skipping 54 matching lines @@
   // failure case.
   info.key_system = kExternalClearKeyInitializeFailKeySystem;
   concrete_key_systems->push_back(info);
 
   // A key system that triggers a crash in ClearKeyCdm.
   info.key_system = kExternalClearKeyCrashKeySystem;
   concrete_key_systems->push_back(info);
 }
 #endif  // defined(ENABLE_PEPPER_CDMS)
 
-
-#if defined(WIDEVINE_CDM_AVAILABLE)
-enum WidevineCdmType {
-  WIDEVINE,
-  WIDEVINE_HR,
-#if defined(OS_ANDROID)
-  WIDEVINE_HR_NON_COMPOSITING,
-#endif
-};
-
-#if !defined(OS_ANDROID)
+#if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
 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('.');
-  DCHECK_GT(last_period, 0);
-  return name.substr(0, last_period);
-}
-
-static void AddWidevineWithCodecs(
-    WidevineCdmType widevine_cdm_type,
-    SupportedCodecs supported_codecs,
-    std::vector<KeySystemInfo>* concrete_key_systems) {
-  KeySystemInfo info(kWidevineKeySystem);
-
-  switch (widevine_cdm_type) {
-    case WIDEVINE:
-      // For standard Widevine, add parent name.
-      info.parent_key_system = GetDirectParentName(kWidevineKeySystem);
-      break;
-    case WIDEVINE_HR:
-      info.key_system.append(".hr");
-      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.
-  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
 // additional_param_* that lists the supported codecs. The name is "codecs" and
 // the value is a comma-delimited list of codecs.
 // This function finds "codecs" and parses the value into the vector |codecs|.
 // Converts the codec strings to UTF-8 since we only expect ASCII strings and
 // this simplifies the rest of the code in this file.
-void GetSupportedCodecs(
+static void GetSupportedCodecs(
     const std::vector<base::string16>& additional_param_names,
     const std::vector<base::string16>& additional_param_values,
-    std::vector<std::string>* codecs) {
-  DCHECK(codecs->empty());
+    SupportedCodecs* result_supported_codecs) {
   DCHECK_EQ(additional_param_names.size(), additional_param_values.size());
+  std::vector<std::string> codecs;
   for (size_t i = 0; i < additional_param_names.size(); ++i) {
     if (additional_param_names[i] ==
         base::ASCIIToUTF16(kCdmSupportedCodecsParamName)) {
       const base::string16& codecs_string16 = additional_param_values[i];
       std::string codecs_string;
       if (!base::UTF16ToUTF8(codecs_string16.c_str(),
                              codecs_string16.length(),
                              &codecs_string)) {
         DLOG(WARNING) << "Non-UTF-8 codecs string.";
         // Continue using the best effort conversion.
       }
       base::SplitString(codecs_string,
                         kCdmSupportedCodecsValueDelimiter,
-                        codecs);
+                        &codecs);
       break;
     }
   }
-}
-
-static void AddPepperBasedWidevine(
-    std::vector<KeySystemInfo>* concrete_key_systems) {
-#if defined(WIDEVINE_CDM_MIN_GLIBC_VERSION)
-  Version glibc_version(gnu_get_libc_version());
-  DCHECK(glibc_version.IsValid());
-  if (glibc_version.IsOlderThan(WIDEVINE_CDM_MIN_GLIBC_VERSION))
-    return;
-#endif  // defined(WIDEVINE_CDM_MIN_GLIBC_VERSION)
-
-  std::vector<base::string16> additional_param_names;
-  std::vector<base::string16> additional_param_values;
-  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 = content::EME_CODEC_NONE;
   for (size_t i = 0; i < codecs.size(); ++i) {
     if (codecs[i] == kCdmSupportedCodecVorbis)

[ddorwin, 2014/05/02 01:12:58]

These constants are currently defined in widevine_cdm_common.h. This function
implies that it is generic, but it is not. If we want it to be, we need to move
them. (I don't see an advantage at the moment..

       supported_codecs |= content::EME_CODEC_WEBM_VORBIS;
     if (codecs[i] == kCdmSupportedCodecVp8)
       supported_codecs |= content::EME_CODEC_WEBM_VP8;
 #if defined(USE_PROPRIETARY_CODECS)
     if (codecs[i] == kCdmSupportedCodecAac)
       supported_codecs |= content::EME_CODEC_MP4_AAC;
     if (codecs[i] == kCdmSupportedCodecAvc1)
       supported_codecs |= content::EME_CODEC_MP4_AVC1;
 #endif  // defined(USE_PROPRIETARY_CODECS)
   }
+  *result_supported_codecs = supported_codecs;
+}
 
-  AddWidevineWithCodecs(WIDEVINE, supported_codecs, concrete_key_systems);
+static bool IsWidevineCdmAvailable(SupportedCodecs* supported_codecs) {

[xhwang, 2014/05/01 22:41:22]

The function name doesn't reflect what the function is doing. The function also
get supported codecs, which is more than "wv cdm available".

[ycheo (away), 2014/05/01 23:27:32]

Yes, the naming is difficult.
I have 3 options and could you choose one or recommend another one?
1. CheckWidevineAvailabilityAndGetSupportedCodecs().
2. GetSupportedCodecsIfWidevineIsAvailable().
3. Split the function as two (IsWidevineCdmAvailable(), GetSupportedCodecs())
and expose additional_param_(names|values) as parameters.

[xhwang, 2014/05/02 00:22:31]

This is only used before calling AddPepperBasedWidevine(). Can we always call
AddPepperBasedWidevine() and put the content of this function in
AddPepperBasedWidevine()? That can also help us hide SupportedCodecs (which is
an impl detail) in AddChromeKeySystems().

[ycheo (away), 2014/05/02 00:30:26]

That means I need to componentize PluginInfoMessageFilter also, right?

[ddorwin, 2014/05/02 01:12:58]

Since we have all the details in components, I think it's fine to keep them
there. However, we do need to fix this function.

How about this?
// Returns true if the Widevine is supported and the codecs successfully
obtained.
bool GetPepperBasedWidevineCodecs(codecs);

Or better yet, just wrap 184-189 in a local AddPepperBasedWidevine() function
that inlines this function. That seems to make the mose sense.

I guess that returns to what we previously had with AddPepperBasedWidevine()

[ycheo (away), 2014/05/02 10:05:46]

I applied the second one.

+#if defined(WIDEVINE_CDM_MIN_GLIBC_VERSION)
+  Version glibc_version(gnu_get_libc_version());
+  DCHECK(glibc_version.IsValid());
+  if (glibc_version.IsOlderThan(WIDEVINE_CDM_MIN_GLIBC_VERSION))
+    return false;
+#endif  // defined(WIDEVINE_CDM_MIN_GLIBC_VERSION)
 
-  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 = content::EME_CODEC_WEBM_ALL | content::EME_CODEC_MP4_ALL;
-  content::RenderThread::Get()->Send(
-      new ChromeViewHostMsg_GetSupportedKeySystems(request, &response));
-  DCHECK(response.compositing_codecs & content::EME_CODEC_ALL)
-      << "unrecognized codec";
-  DCHECK(response.non_compositing_codecs & content::EME_CODEC_ALL)
-      << "unrecognized codec";
-  if (response.compositing_codecs != content::EME_CODEC_NONE) {
-    AddWidevineWithCodecs(
-        WIDEVINE,
-        static_cast<SupportedCodecs>(response.compositing_codecs),
-        concrete_key_systems);
+  std::vector<base::string16> additional_param_names;
+  std::vector<base::string16> additional_param_values;
+  if (!IsPepperCdmRegistered(kWidevineCdmPluginMimeType,
+                             &additional_param_names,
+                             &additional_param_values)) {
+    DVLOG(1) << "Widevine CDM is not currently available.";
+    return false;
   }
 
-  if (response.non_compositing_codecs != content::EME_CODEC_NONE) {
-    AddWidevineWithCodecs(
-        WIDEVINE_HR_NON_COMPOSITING,
-        static_cast<SupportedCodecs>(response.non_compositing_codecs),
-        concrete_key_systems);
-  }
+  GetSupportedCodecs(additional_param_names, additional_param_values,
+                     supported_codecs);
+  return true;
 }
-#endif  // defined(ENABLE_PEPPER_CDMS)
-#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+#endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS)
 
 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);
+  SupportedCodecs supported_codecs;
+  if (IsWidevineCdmAvailable(&supported_codecs)) {
+    encrypted_media::AddPepperBasedWidevine(key_systems_info,
+                                            IsWidevineHrSupported(),
+                                            supported_codecs);
+  }
 #elif defined(OS_ANDROID)
-  AddAndroidWidevine(key_systems_info);
-#endif
-#endif
+  encrypted_media::AddAndroidWidevine(key_systems_info);
+#endif  // defined(ENABLE_PEPPER_CDMS)
+#endif  // defined(WIDEVINE_CDM_AVAILABLE)
 }