Extract supported codecs from CDM component manifest.

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 <string.h>
 
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
+#include "base/strings/string16.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/component_updater/component_updater_service.h"
 #include "chrome/browser/component_updater/default_component_installer.h"
 #include "chrome/browser/plugins/plugin_prefs.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/widevine_cdm_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/plugin_service.h"
@@ skipping 41 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::FilePath& path,
-                               const base::Version& version,
-                               content::PepperPluginInfo* plugin_info) {
+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) {
   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->name = kWidevineCdmDisplayName;
   plugin_info->description = kWidevineCdmDescription;
   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;
   plugin_info->mime_types.push_back(widevine_cdm_mime_type);
   plugin_info->permissions = kWidevineCdmPluginPermissions;
 
   return true;
 }
 
-void RegisterWidevineCdmWithChrome(const base::FilePath& path,
-                                   const base::Version& version) {
+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("x-cdm-codecs", &codecs)) {
+    DLOG_IF(WARNING, codecs.empty())
+        << "Widevine CDM component manifest has empty codecs list";
+    additional_param_names->push_back(base::ASCIIToUTF16("codecs"));
+    additional_param_values->push_back(codecs);
+  } else {
+    DLOG(WARNING) << "Widevine CDM component manifest is missing 'codecs'";
+  }
+}
+
+void RegisterWidevineCdmWithChrome(const base::Version& version,
+                                   const base::FilePath& path,
+                                   scoped_ptr<base::DictionaryValue> manifest) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  std::vector<base::string16> additional_param_names;
+  std::vector<base::string16> additional_param_values;
+  GetAdditionalParams(
+      *manifest, &additional_param_names, &additional_param_values);
   content::PepperPluginInfo plugin_info;
-  if (!MakeWidevineCdmPluginInfo(path, version, &plugin_info))
+  if (!MakeWidevineCdmPluginInfo(version,
+                                 path,
+                                 additional_param_names,
+                                 additional_param_values,
+                                 &plugin_info)) {
     return;
+  }
 
+  // true = Add to beginning of list to override any existing registrations.
   PluginService::GetInstance()->RegisterInternalPlugin(
       plugin_info.ToWebPluginInfo(), true);
   PluginService::GetInstance()->RefreshPlugins();
 }
 
 }  // namespace
 
 class WidevineCdmComponentInstallerTraits : public ComponentInstallerTraits {
  public:
   WidevineCdmComponentInstallerTraits();
   virtual ~WidevineCdmComponentInstallerTraits() {}
 
  private:
   // The following methods override ComponentInstallerTraits.
   virtual bool CanAutoUpdate() const OVERRIDE;
   virtual bool OnCustomInstall(const base::DictionaryValue& manifest,
                                const base::FilePath& install_dir) OVERRIDE;
   virtual bool VerifyInstallation(
       const base::FilePath& install_dir) const OVERRIDE;
-  virtual void ComponentReady(const base::Version& version,
-                              const base::FilePath& path) OVERRIDE;
+  virtual void ComponentReady(
+      const base::Version& version,
+      const base::FilePath& path,
+      scoped_ptr<base::DictionaryValue> manifest) OVERRIDE;
   virtual base::FilePath GetBaseDirectory() const OVERRIDE;
   virtual void GetHash(std::vector<uint8>* hash) const OVERRIDE;
   virtual std::string GetName() const OVERRIDE;
   DISALLOW_COPY_AND_ASSIGN(WidevineCdmComponentInstallerTraits);
 };
 
 WidevineCdmComponentInstallerTraits::WidevineCdmComponentInstallerTraits() {
 }
 
 bool WidevineCdmComponentInstallerTraits::CanAutoUpdate() const {
   return true;
 }
 
 // The adapter is copied into the install directory as part of the installation.
 bool WidevineCdmComponentInstallerTraits::OnCustomInstall(
     const base::DictionaryValue& manifest,
     const base::FilePath& install_path) {
   base::FilePath adapter_install_path = GetPlatformDirectory(install_path)
       .AppendASCII(kWidevineCdmAdapterFileName);
   base::FilePath adapter_source_path;
   PathService::Get(chrome::FILE_WIDEVINE_CDM_ADAPTER, &adapter_source_path);
   return base::CopyFile(adapter_source_path, adapter_install_path);
 }
 
 // Once the component is installed, register the new version with Chrome.
 void WidevineCdmComponentInstallerTraits::ComponentReady(
     const base::Version& version,
-    const base::FilePath& path) {
+    const base::FilePath& path,
+    scoped_ptr<base::DictionaryValue> manifest) {
+  // TODO(ddorwin): Check API version compatibility. Return if fails.
   base::FilePath adapter_install_path = GetPlatformDirectory(path)
       .AppendASCII(kWidevineCdmAdapterFileName);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-      &RegisterWidevineCdmWithChrome, adapter_install_path, version));
+      &RegisterWidevineCdmWithChrome,
+      version, adapter_install_path, base::Passed(&manifest)));
 }
 
 bool WidevineCdmComponentInstallerTraits::VerifyInstallation(
     const base::FilePath& install_dir) const {
   return base::PathExists(GetPlatformDirectory(install_dir)
           .AppendASCII(kWidevineCdmFileName))
       && base::PathExists(GetPlatformDirectory(install_dir)
           .AppendASCII(kWidevineCdmAdapterFileName));
 }
 
@@ skipping 25 matching lines @@
   scoped_ptr<ComponentInstallerTraits> traits(
       new WidevineCdmComponentInstallerTraits);
   // |cus| will take ownership of |installer| during installer->Register(cus).
   DefaultComponentInstaller* installer
       = new DefaultComponentInstaller(traits.Pass());
   installer->Register(cus);
 #else
   return;
 #endif  // defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
 }