Add CdmService to keep track of CDMs

chrome/browser/component_updater/widevine_cdm_component_installer.cc

 // Copyright (c) 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/browser/component_updater/widevine_cdm_component_installer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/widevine_cdm_constants.h"
 #include "components/component_updater/component_updater_service.h"
 #include "components/component_updater/default_component_installer.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/cdm_service.h"
 #include "content/public/browser/plugin_service.h"
+#include "content/public/common/cdm_info.h"
 #include "content/public/common/pepper_plugin_info.h"
 #include "media/cdm/supported_cdm_versions.h"
 #include "third_party/widevine/cdm/widevine_cdm_common.h"
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR. NOLINT
 
 using content::BrowserThread;
+using content::CdmService;
 using content::PluginService;
 
 namespace component_updater {
 
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
 
 namespace {
 
 // CRX hash. The extension id is: oimompecagnajdejgnnjijobebaeigek.
 const uint8_t kSha2Hash[] = {0xe8, 0xce, 0xcf, 0x42, 0x06, 0xd0, 0x93, 0x49,
@@ skipping 50 matching lines @@
 // Widevine CDM is packaged as a multi-CRX. Widevine CDM binaries are located in
 // _platform_specific/<platform_arch> folder in the package. This function
 // returns the platform-specific subdirectory that is part of that multi-CRX.
 base::FilePath GetPlatformDirectory(const base::FilePath& base_path) {
   std::string platform_arch = kWidevineCdmPlatform;
   platform_arch += '_';
   platform_arch += kWidevineCdmArch;
   return base_path.AppendASCII("_platform_specific").AppendASCII(platform_arch);
 }
 
-bool MakeWidevineCdmPluginInfo(
-    const base::Version& version,
-    const base::FilePath& path,
-    const std::vector<base::string16>& additional_param_names,
-    const std::vector<base::string16>& additional_param_values,
-    content::PepperPluginInfo* plugin_info) {
+bool MakeWidevineCdmPluginInfo(const base::Version& version,
+                               const base::FilePath& cdm_install_dir,
+                               const std::string& codecs,
+                               content::PepperPluginInfo* plugin_info) {
   if (!version.IsValid() ||
       version.components().size() !=
           static_cast<size_t>(kWidevineCdmVersionNumComponents)) {
     return false;
   }
 
   plugin_info->is_internal = false;
   // Widevine CDM must run out of process.
   plugin_info->is_out_of_process = true;
-  plugin_info->path = path;
+  plugin_info->path = GetPlatformDirectory(cdm_install_dir)
+                          .AppendASCII(kWidevineCdmAdapterFileName);
   plugin_info->name = kWidevineCdmDisplayName;
   plugin_info->description = kWidevineCdmDescription +
                              std::string(" (version: ") + version.GetString() +
                              ")";
   plugin_info->version = version.GetString();
   content::WebPluginMimeType widevine_cdm_mime_type(
       kWidevineCdmPluginMimeType,
       kWidevineCdmPluginExtension,
       kWidevineCdmPluginMimeTypeDescription);
-  widevine_cdm_mime_type.additional_param_names = additional_param_names;
-  widevine_cdm_mime_type.additional_param_values = additional_param_values;
+  widevine_cdm_mime_type.additional_param_names.push_back(
+      base::ASCIIToUTF16(kCdmSupportedCodecsParamName));
+  widevine_cdm_mime_type.additional_param_values.push_back(
+      base::ASCIIToUTF16(codecs));
+
   plugin_info->mime_types.push_back(widevine_cdm_mime_type);
   plugin_info->permissions = kWidevineCdmPluginPermissions;
 
   return true;
 }
 
 typedef bool (*VersionCheckFunc)(int version);
 
 bool CheckForCompatibleVersion(const base::DictionaryValue& manifest,
                                const std::string version_name,
@@ skipping 30 matching lines @@
                                    kCdmModuleVersionsName,
                                    media::IsSupportedCdmModuleVersion) &&
          CheckForCompatibleVersion(manifest,
                                    kCdmInterfaceVersionsName,
                                    media::IsSupportedCdmInterfaceVersion) &&
          CheckForCompatibleVersion(manifest,
                                    kCdmHostVersionsName,
                                    media::IsSupportedCdmHostVersion);
 }
 
-void GetAdditionalParams(const base::DictionaryValue& manifest,
-                         std::vector<base::string16>* additional_param_names,
-                         std::vector<base::string16>* additional_param_values) {
-  base::string16 codecs;
-  if (manifest.GetString(kCdmCodecsListName, &codecs)) {
+std::string GetCodecs(const base::DictionaryValue& manifest) {
+  std::string codecs;
+  if (manifest.GetStringASCII(kCdmCodecsListName, &codecs)) {
     DLOG_IF(WARNING, codecs.empty())
         << "Widevine CDM component manifest has empty codecs list";
-    additional_param_names->push_back(
-        base::ASCIIToUTF16(kCdmSupportedCodecsParamName));
-    additional_param_values->push_back(codecs);
   } else {
     DLOG(WARNING) << "Widevine CDM component manifest is missing codecs";
   }
+  return codecs;
 }
 
 void RegisterWidevineCdmWithChrome(
     const base::Version& cdm_version,
-    const base::FilePath& adapter_install_path,
+    const base::FilePath& cdm_install_dir,
     std::unique_ptr<base::DictionaryValue> manifest) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  std::vector<base::string16> additional_param_names;
-  std::vector<base::string16> additional_param_values;
-  GetAdditionalParams(
-      *manifest, &additional_param_names, &additional_param_values);
+  const std::string codecs = GetCodecs(*manifest);
+
   content::PepperPluginInfo plugin_info;
-  if (!MakeWidevineCdmPluginInfo(cdm_version,
-                                 adapter_install_path,
-                                 additional_param_names,
-                                 additional_param_values,
+  if (!MakeWidevineCdmPluginInfo(cdm_version, cdm_install_dir, codecs,
                                  &plugin_info)) {
     return;
   }
 
   // true = Add to beginning of list to override any existing registrations.
   PluginService::GetInstance()->RegisterInternalPlugin(
       plugin_info.ToWebPluginInfo(), true);
   // Tell the browser to refresh the plugin list. Then tell all renderers to
   // update their plugin list caches.
   PluginService::GetInstance()->RefreshPlugins();
   PluginService::GetInstance()->PurgePluginListCache(NULL, false);
+
+  // Also register Widevine with the CdmService.
+  const base::FilePath cdm_path =
+      GetPlatformDirectory(cdm_install_dir).AppendASCII(kWidevineCdmFileName);
+  const std::vector<std::string> supported_codecs = base::SplitString(
+      codecs, std::string(1, kCdmSupportedCodecsValueDelimiter),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+  CdmService::GetInstance()->RegisterCdm(content::CdmInfo(
+      kWidevineCdmType, cdm_version, cdm_path, supported_codecs));
 }
 
 }  // namespace
 
 class WidevineCdmComponentInstallerTraits : public ComponentInstallerTraits {
  public:
   WidevineCdmComponentInstallerTraits();
   ~WidevineCdmComponentInstallerTraits() override {}
 
  private:
@@ skipping 119 matching lines @@
     }
 
     base::FilePath adapter_source_path;
     PathService::Get(chrome::FILE_WIDEVINE_CDM_ADAPTER, &adapter_source_path);
     if (!base::CopyFile(adapter_source_path, adapter_install_path)) {
       PLOG(WARNING) << "Failed to copy Widevine CDM adapter.";
       return;
     }
   }
 
-  BrowserThread::PostTask(content::BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&RegisterWidevineCdmWithChrome,
-                                     cdm_version,
-                                     adapter_install_path,
-                                     base::Passed(&manifest)));
+  BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&RegisterWidevineCdmWithChrome, cdm_version, cdm_install_dir,
+                 base::Passed(&manifest)));
 }
 
 #endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
 
 void RegisterWidevineCdmComponent(ComponentUpdateService* cus) {
 #if defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
   base::FilePath adapter_source_path;
   PathService::Get(chrome::FILE_WIDEVINE_CDM_ADAPTER, &adapter_source_path);
   if (!base::PathExists(adapter_source_path))
     return;
   std::unique_ptr<ComponentInstallerTraits> traits(
       new WidevineCdmComponentInstallerTraits);
   // |cus| will take ownership of |installer| during installer->Register(cus).
   DefaultComponentInstaller* installer =
       new DefaultComponentInstaller(std::move(traits));
   installer->Register(cus, base::Closure());
 #endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
 }
 
 }  // namespace component_updater