Add CdmService to keep track of CDMs

chrome/common/chrome_content_client.cc

 // Copyright (c) 2012 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/common/chrome_content_client.h"
 
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
@@ skipping 15 matching lines @@
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/pepper_flash.h"
 #include "chrome/common/secure_origin_whitelist.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/common_resources.h"
 #include "components/data_reduction_proxy/content/common/data_reduction_proxy_messages.h"
 #include "components/dom_distiller/core/url_constants.h"
 #include "components/version_info/version_info.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/key_system_registration.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/user_agent.h"
 #include "extensions/common/constants.h"
 #include "gpu/config/gpu_info.h"
 #include "net/http/http_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
@@ skipping 25 matching lines @@
 #include "ppapi/shared_impl/ppapi_permissions.h"
 #endif
 
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) && \
     !defined(WIDEVINE_CDM_IS_COMPONENT)
 #include "chrome/common/widevine_cdm_constants.h"
 #endif
 
 namespace {
 
+// File name of the External ClearKey CDM on different platforms.
+const base::FilePath::CharType kExternalClearKeyCdmFileName[] =
+#if defined(OS_MACOSX)
+    FILE_PATH_LITERAL("libclearkeycdm.dylib");
+#elif defined(OS_WIN)
+    FILE_PATH_LITERAL("clearkeycdm.dll");
+#else  // OS_LINUX, etc.
+    FILE_PATH_LITERAL("libclearkeycdm.so");
+#endif
+
+// Key system name for External Clear Key (used for testing). The different
+// variations cause different behavior, but they all come from the same library.
+const char kExternalClearKeyKeySystem[] = "org.chromium.externalclearkey";
+const char kExternalClearKeyDecryptOnlyKeySystem[] =
+    "org.chromium.externalclearkey.decryptonly";
+const char kExternalClearKeyFileIOTestKeySystem[] =
+    "org.chromium.externalclearkey.fileiotest";
+const char kExternalClearKeyInitializeFailKeySystem[] =
+    "org.chromium.externalclearkey.initializefail";
+const char kExternalClearKeyCrashKeySystem[] =
+    "org.chromium.externalclearkey.crash";
+
 #if defined(ENABLE_PLUGINS)
 #if defined(ENABLE_PDF)
 const char kPDFPluginExtension[] = "pdf";
 const char kPDFPluginDescription[] = "Portable Document Format";
 const char kPDFPluginOutOfProcessMimeType[] =
     "application/x-google-chrome-pdf";
 const uint32_t kPDFPluginPermissions =
     ppapi::PERMISSION_PRIVATE | ppapi::PERMISSION_DEV;
 #endif  // defined(ENABLE_PDF)
 
 content::PepperPluginInfo::GetInterfaceFunc g_pdf_get_interface;
 content::PepperPluginInfo::PPP_InitializeModuleFunc g_pdf_initialize_module;
 content::PepperPluginInfo::PPP_ShutdownModuleFunc g_pdf_shutdown_module;
 
 #if !defined(DISABLE_NACL)
 content::PepperPluginInfo::GetInterfaceFunc g_nacl_get_interface;
 content::PepperPluginInfo::PPP_InitializeModuleFunc g_nacl_initialize_module;
 content::PepperPluginInfo::PPP_ShutdownModuleFunc g_nacl_shutdown_module;
 #endif
 
+#if defined(WIDEVINE_CDM_AVAILABLE) && !defined(WIDEVINE_CDM_IS_COMPONENT)
+static bool IsWidevineAvailable(base::FilePath* cdm_adapter_path,

[xhwang, 2016/01/29 07:43:06]

Probably we should move this function and the ECK registration code into a
different file. This file just have too many unrelated stuff...

+                                base::string16* codecs_supported) {
+  static bool skip_widevine_cdm_file_check = false;
+  if (PathService::Get(chrome::FILE_WIDEVINE_CDM_ADAPTER, cdm_adapter_path)) {
+    if (skip_widevine_cdm_file_check || base::PathExists(*cdm_adapter_path)) {
+      skip_widevine_cdm_file_check = true;
+
+      // Add the supported codecs as if they came from the component manifest.
+      std::vector<std::string> codecs;
+      codecs.push_back(kCdmSupportedCodecVorbis);
+      codecs.push_back(kCdmSupportedCodecVp8);
+      codecs.push_back(kCdmSupportedCodecVp9);
+#if defined(USE_PROPRIETARY_CODECS)
+      codecs.push_back(kCdmSupportedCodecAac);
+      codecs.push_back(kCdmSupportedCodecAvc1);
+#endif  // defined(USE_PROPRIETARY_CODECS)
+      *codecs_supported = base::ASCIIToUTF16(base::JoinString(
+          codecs, std::string(1, kCdmSupportedCodecsValueDelimiter)));
+      return true;
+    }
+  }
+
+  return false;
+}
+#endif  // defined(WIDEVINE_CDM_AVAILABLE) &&
+        // !defined(WIDEVINE_CDM_IS_COMPONENT)
+
 // Appends the known built-in plugins to the given vector. Some built-in
 // plugins are "internal" which means they are compiled into the Chrome binary,
 // and some are extra shared libraries distributed with the browser (these are
 // not marked internal, aside from being automatically registered, they're just
 // regular plugins).
 void ComputeBuiltInPlugins(std::vector<content::PepperPluginInfo>* plugins) {
 #if defined(ENABLE_PDF)
   content::PepperPluginInfo pdf_info;
   pdf_info.is_internal = true;
   pdf_info.is_out_of_process = true;
@@ skipping 37 matching lines @@
     nacl.internal_entry_points.get_interface = g_nacl_get_interface;
     nacl.internal_entry_points.initialize_module = g_nacl_initialize_module;
     nacl.internal_entry_points.shutdown_module = g_nacl_shutdown_module;
     nacl.permissions = ppapi::PERMISSION_PRIVATE | ppapi::PERMISSION_DEV;
     plugins->push_back(nacl);
   }
 #endif  // !defined(DISABLE_NACL)
 
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) && \
     !defined(WIDEVINE_CDM_IS_COMPONENT)
-  static bool skip_widevine_cdm_file_check = false;
-  if (PathService::Get(chrome::FILE_WIDEVINE_CDM_ADAPTER, &path)) {
-    if (skip_widevine_cdm_file_check || base::PathExists(path)) {
-      content::PepperPluginInfo widevine_cdm;
-      widevine_cdm.is_out_of_process = true;
-      widevine_cdm.path = path;
-      widevine_cdm.name = kWidevineCdmDisplayName;
-      widevine_cdm.description = kWidevineCdmDescription +
-                                 std::string(" (version: ") +
-                                 WIDEVINE_CDM_VERSION_STRING + ")";
-      widevine_cdm.version = WIDEVINE_CDM_VERSION_STRING;
-      content::WebPluginMimeType widevine_cdm_mime_type(
-          kWidevineCdmPluginMimeType,
-          kWidevineCdmPluginExtension,
-          kWidevineCdmPluginMimeTypeDescription);
+  base::string16 codecs_supported;
+  if (IsWidevineAvailable(&path, &codecs_supported)) {
+    content::PepperPluginInfo widevine_cdm;
+    widevine_cdm.is_out_of_process = true;
+    widevine_cdm.path = path;
+    widevine_cdm.name = kWidevineCdmDisplayName;
+    widevine_cdm.description = kWidevineCdmDescription +
+                               std::string(" (version: ") +
+                               WIDEVINE_CDM_VERSION_STRING + ")";
+    widevine_cdm.version = WIDEVINE_CDM_VERSION_STRING;
+    content::WebPluginMimeType widevine_cdm_mime_type(
+        kWidevineCdmPluginMimeType, kWidevineCdmPluginExtension,
+        kWidevineCdmPluginMimeTypeDescription);
 
-      // Add the supported codecs as if they came from the component manifest.
-      std::vector<std::string> codecs;
-      codecs.push_back(kCdmSupportedCodecVorbis);
-      codecs.push_back(kCdmSupportedCodecVp8);
-      codecs.push_back(kCdmSupportedCodecVp9);
-#if defined(USE_PROPRIETARY_CODECS)
-      codecs.push_back(kCdmSupportedCodecAac);
-      codecs.push_back(kCdmSupportedCodecAvc1);
-#endif  // defined(USE_PROPRIETARY_CODECS)
-      std::string codec_string = base::JoinString(
-          codecs, std::string(1, kCdmSupportedCodecsValueDelimiter));
-      widevine_cdm_mime_type.additional_param_names.push_back(
-          base::ASCIIToUTF16(kCdmSupportedCodecsParamName));
-      widevine_cdm_mime_type.additional_param_values.push_back(
-          base::ASCIIToUTF16(codec_string));
+    widevine_cdm_mime_type.additional_param_names.push_back(
+        base::ASCIIToUTF16(kCdmSupportedCodecsParamName));
+    widevine_cdm_mime_type.additional_param_values.push_back(codecs_supported);
 
-      widevine_cdm.mime_types.push_back(widevine_cdm_mime_type);
-      widevine_cdm.permissions = kWidevineCdmPluginPermissions;
-      plugins->push_back(widevine_cdm);
-
-      skip_widevine_cdm_file_check = true;
-    }
+    widevine_cdm.mime_types.push_back(widevine_cdm_mime_type);
+    widevine_cdm.permissions = kWidevineCdmPluginPermissions;
+    plugins->push_back(widevine_cdm);
   }
 #endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(ENABLE_PEPPER_CDMS) &&
         // !defined(WIDEVINE_CDM_IS_COMPONENT)
 }
 
 content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path,
                                                 const std::string& version,
                                                 bool is_debug) {
   content::PepperPluginInfo plugin;
 
@@ skipping 308 matching lines @@
     flash_versions.push_back(system_flash.release());
 
   // This function will return only the most recent version of the flash plugin.
   content::PepperPluginInfo* max_flash =
       FindMostRecentPlugin(flash_versions.get());
   if (max_flash)
     plugins->push_back(*max_flash);
 #endif  // defined(ENABLE_PLUGINS)
 }
 
+void ChromeContentClient::AddKeySystems(
+    std::vector<content::KeySystemRegistration>* key_systems) {
+#if defined(WIDEVINE_CDM_AVAILABLE) && !defined(WIDEVINE_CDM_IS_COMPONENT)

[ddorwin, 2016/01/26 20:21:53]

This code will run on Android. Yes, we want to register all at once, but the how
is different. Ideally, this would be handled by the platform-specific Mojo
service code. Should Chrome need to know how the Mojo CDM service is
implemented?

+  base::FilePath widevine_adapter_path;
+  base::string16 codecs_supported;
+  if (IsWidevineAvailable(&widevine_adapter_path, &codecs_supported)) {
+    // |key_systems| needs |path| to be the actual Widevine library,
+    // not the adapter, so adjust as necessary. It will be in the
+    // same directory as the installed adapter.
+    key_systems->push_back(content::KeySystemRegistration(
+        kWidevineKeySystem,
+        widevine_adapter_path.DirName().AppendASCII(kWidevineCdmFileName),
+        codecs_supported));
+  }
+#endif  // defined(WIDEVINE_CDM_AVAILABLE) &&
+        // !defined(WIDEVINE_CDM_IS_COMPONENT)
+
+  // External Clear Key is used for testing the interface to key systems.

[xhwang, 2016/01/29 07:43:06]

This CL is getting large. It seems we can split the registration of External
Clear Key (with command line) into a separate CL. WDYT?

[jrummell, 2016/03/04 01:19:40]

Done.

+  base::FilePath clearkey_path;
+  static bool skip_clearkey_cdm_file_check = false;
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kEnableExternalClearKey)) {
+    if (PathService::Get(chrome::DIR_INTERNAL_PLUGINS, &clearkey_path)) {
+      clearkey_path = clearkey_path.AppendASCII(kExternalClearKeyCdmFileName);
+      if (skip_clearkey_cdm_file_check || base::PathExists(clearkey_path)) {
+        skip_clearkey_cdm_file_check = true;
+
+        // External Clear Key supports all codecs.
+        std::vector<std::string> codecs_supported;
+        codecs_supported.push_back(kCdmSupportedCodecVorbis);
+        codecs_supported.push_back(kCdmSupportedCodecVp8);
+        codecs_supported.push_back(kCdmSupportedCodecVp9);
+#if defined(USE_PROPRIETARY_CODECS)
+        codecs_supported.push_back(kCdmSupportedCodecAac);
+        codecs_supported.push_back(kCdmSupportedCodecAvc1);
+#endif  // defined(USE_PROPRIETARY_CODECS)
+        base::string16 codecs = base::ASCIIToUTF16(base::JoinString(
+            codecs_supported,
+            std::string(1, kCdmSupportedCodecsValueDelimiter)));
+
+        key_systems->push_back(content::KeySystemRegistration(
+            kExternalClearKeyKeySystem, clearkey_path, codecs));
+        key_systems->push_back(content::KeySystemRegistration(
+            kExternalClearKeyDecryptOnlyKeySystem, clearkey_path, codecs));
+        key_systems->push_back(content::KeySystemRegistration(
+            kExternalClearKeyFileIOTestKeySystem, clearkey_path, codecs));
+        key_systems->push_back(content::KeySystemRegistration(
+            kExternalClearKeyInitializeFailKeySystem, clearkey_path, codecs));
+        key_systems->push_back(content::KeySystemRegistration(
+            kExternalClearKeyCrashKeySystem, clearkey_path, codecs));
+      }
+    }
+  }
+}
+
 #if defined(OS_CHROMEOS)
 static const int kNumChromeStandardURLSchemes = 6;
 #else
 static const int kNumChromeStandardURLSchemes = 5;
 #endif
 static const url::SchemeWithType kChromeStandardURLSchemes[
     kNumChromeStandardURLSchemes] = {
   {extensions::kExtensionScheme, url::SCHEME_WITHOUT_PORT},
   {chrome::kChromeNativeScheme, url::SCHEME_WITHOUT_PORT},
   {extensions::kExtensionResourceScheme, url::SCHEME_WITHOUT_PORT},
@@ skipping 96 matching lines @@
 #endif
 }
 
 bool ChromeContentClient::IsSupplementarySiteIsolationModeEnabled() {
 #if defined(ENABLE_EXTENSIONS)
   return extensions::IsIsolateExtensionsEnabled();
 #else
   return false;
 #endif
 }