Add widevine third party

Add 2 new command options to use widevine:
- widevine-cdm-path: Path to widevine plugin
- widevine-cdm-version: Version of the widevine plugin

chromium_src/chrome/browser/renderer_host/pepper/widevine_cdm_message_filter.cc

@@ -0,0 +1,70 @@
+// 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/renderer_host/pepper/widevine_cdm_message_filter.h"
+
+#include "base/bind.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/common/webplugininfo.h"
+#include "content/public/browser/plugin_service.h"
+using content::PluginService;
+using content::WebPluginInfo;
+using content::BrowserThread;
+
+WidevineCdmMessageFilter::WidevineCdmMessageFilter(
+    int render_process_id,
+    content::BrowserContext* browser_context)
+    : BrowserMessageFilter(ChromeMsgStart),
+      render_process_id_(render_process_id),
+      browser_context_(browser_context) {
+}
+
+bool WidevineCdmMessageFilter::OnMessageReceived(const IPC::Message& message) {
+  IPC_BEGIN_MESSAGE_MAP(WidevineCdmMessageFilter, message)
+#if defined(ENABLE_PEPPER_CDMS)
+    IPC_MESSAGE_HANDLER(
+        ChromeViewHostMsg_IsInternalPluginAvailableForMimeType,
+        OnIsInternalPluginAvailableForMimeType)
+#endif
+    IPC_MESSAGE_UNHANDLED(return false)
+  IPC_END_MESSAGE_MAP()
+  return true;
+}
+
+#if defined(ENABLE_PEPPER_CDMS)
+void WidevineCdmMessageFilter::OnIsInternalPluginAvailableForMimeType(
+    const std::string& mime_type,
+    bool* is_available,
+    std::vector<base::string16>* additional_param_names,
+    std::vector<base::string16>* additional_param_values) {
+
+  std::vector<WebPluginInfo> plugins;
+  PluginService::GetInstance()->GetInternalPlugins(&plugins);
+
+  for (size_t i = 0; i < plugins.size(); ++i) {
+    const WebPluginInfo& plugin = plugins[i];
+    const std::vector<content::WebPluginMimeType>& mime_types =
+        plugin.mime_types;
+    for (size_t j = 0; j < mime_types.size(); ++j) {
+
+      if (mime_types[j].mime_type == mime_type) {
+        *is_available = true;
+        *additional_param_names = mime_types[j].additional_param_names;
+        *additional_param_values = mime_types[j].additional_param_values;
+        return;
+      }
+    }
+  }
+
+  *is_available = false;
+}
+#endif // defined(ENABLE_PEPPER_CDMS)
+
+void WidevineCdmMessageFilter::OnDestruct() const {
+  BrowserThread::DeleteOnUIThread::Destruct(this);
+}
+
+WidevineCdmMessageFilter::~WidevineCdmMessageFilter() {
+}

chromium_src/chrome/browser/renderer_host/pepper/widevine_cdm_message_filter.h

@@ -0,0 +1,49 @@
+// 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.
+
+#ifndef CHROME_BROWSER_RENDERER_HOST_PEPPER_WIDEVINE_CDM_MESSAGE_FILTER_H_
+#define CHROME_BROWSER_RENDERER_HOST_PEPPER_WIDEVINE_CDM_MESSAGE_FILTER_H_
+
+#include "chrome/common/widevine_cdm_messages.h"
+#include "content/public/browser/browser_message_filter.h"
+
+namespace content {
+class BrowserContext;
+}
+
+class WidevineCdmMessageFilter : public content::BrowserMessageFilter {
+ public:
+  explicit WidevineCdmMessageFilter(int render_process_id,
+      content::BrowserContext* browser_context);
+  bool OnMessageReceived(const IPC::Message& message) override;
+  void OnDestruct() const override;
+
+ private:
+  friend class content::BrowserThread;
+  friend class base::DeleteHelper<WidevineCdmMessageFilter>;
+
+  virtual ~WidevineCdmMessageFilter();
+
+  #if defined(ENABLE_PEPPER_CDMS)
+  // Returns whether any internal plugin supporting |mime_type| is registered
+  // and enabled. Does not determine whether the plugin can actually be
+  // instantiated (e.g. whether it has all its dependencies).
+  // When the returned *|is_available| is true, |additional_param_names| and
+  // |additional_param_values| contain the name-value pairs, if any, specified
+  // for the *first* non-disabled plugin found that is registered for
+  // |mime_type|.
+  void OnIsInternalPluginAvailableForMimeType(
+      const std::string& mime_type,
+      bool* is_available,
+      std::vector<base::string16>* additional_param_names,
+      std::vector<base::string16>* additional_param_values);
+#endif
+
+  int render_process_id_;
+  content::BrowserContext* browser_context_;
+
+  DISALLOW_COPY_AND_ASSIGN(WidevineCdmMessageFilter);
+};
+
+#endif  // CHROME_BROWSER_RENDERER_HOST_PEPPER_WIDEVINE_CDM_MESSAGE_FILTER_H_

chromium_src/chrome/common/chrome_paths.cc

@@ -15,6 +15,7 @@
 #include "base/version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths_internal.h"
+#include "chrome/common/widevine_cdm_constants.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/path_utils.h"
@@ -31,6 +32,8 @@
 #include "base/win/registry.h"
 #endif
 
+#include "third_party/widevine/cdm/stub/widevine_cdm_version.h"
+
 namespace {
 
 // The Pepper Flash plugins are in a directory with this name.
@@ -362,7 +365,7 @@ bool PathProvider(int key, base::FilePath* result) {
     case chrome::DIR_COMPONENT_WIDEVINE_CDM:
       if (!PathService::Get(chrome::DIR_USER_DATA, &cur))
         return false;
-      cur = cur.Append(FILE_PATH_LITERAL("WidevineCDM"));
+      cur = cur.Append(kWidevineCdmBaseDirectory);
       break;
 #endif  // defined(WIDEVINE_CDM_IS_COMPONENT)
     // TODO(xhwang): FILE_WIDEVINE_CDM_ADAPTER has different meanings.

chromium_src/chrome/common/widevine_cdm_constants.cc

@@ -0,0 +1,16 @@
+// 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/common/widevine_cdm_constants.h"
+
+#include "build/build_config.h"
+#include "ppapi/shared_impl/ppapi_permissions.h"
+
+const base::FilePath::CharType kWidevineCdmBaseDirectory[] =
+    FILE_PATH_LITERAL("WidevineCDM");
+
+const char kWidevineCdmPluginExtension[] = "";
+
+const int32 kWidevineCdmPluginPermissions = ppapi::PERMISSION_DEV |
+                                            ppapi::PERMISSION_PRIVATE;

chromium_src/chrome/common/widevine_cdm_constants.h

@@ -0,0 +1,19 @@
+// 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.
+
+#ifndef CHROME_COMMON_WIDEVINE_CDM_CONSTANTS_H_
+#define CHROME_COMMON_WIDEVINE_CDM_CONSTANTS_H_
+
+#include "base/basictypes.h"
+#include "base/files/file_path.h"
+
+// The Widevine CDM adapter and Widevine CDM are in this directory.
+extern const base::FilePath::CharType kWidevineCdmBaseDirectory[];
+
+extern const char kWidevineCdmPluginExtension[];
+
+// Permission bits for Widevine CDM plugin.
+extern const int32 kWidevineCdmPluginPermissions;
+
+#endif  // CHROME_COMMON_WIDEVINE_CDM_CONSTANTS_H_

chromium_src/chrome/common/widevine_cdm_messages.h

@@ -0,0 +1,31 @@
+// 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.
+
+// Multiply-included message file, hence no include guard.
+
+#include <vector>
+
+#include "ipc/ipc_message_macros.h"
+// #include "ipc/ipc_param_traits.h"
+
+#define IPC_MESSAGE_START ChromeMsgStart
+
+// Renderer -> Browser messages.
+
+#if defined(ENABLE_PEPPER_CDMS)
+// Returns whether any internal plugin supporting |mime_type| is registered and
+// enabled. Does not determine whether the plugin can actually be instantiated
+// (e.g. whether it has all its dependencies).
+// When the returned *|is_available| is true, |additional_param_names| and
+// |additional_param_values| contain the name-value pairs, if any, specified
+// for the *first* non-disabled plugin found that is registered for |mime_type|.
+IPC_SYNC_MESSAGE_CONTROL1_3(
+    ChromeViewHostMsg_IsInternalPluginAvailableForMimeType,
+    std::string /* mime_type */,
+    bool /* is_available */,
+    std::vector<base::string16> /* additional_param_names */,
+    std::vector<base::string16> /* additional_param_values */)
+#endif
+
+// Browser -> Renderer messages.

chromium_src/chrome/renderer/media/chrome_key_systems.cc

@@ -0,0 +1,173 @@
+// 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/widevine_cdm_messages.h"
+#include "components/cdm/renderer/widevine_key_systems.h"
+#include "content/public/renderer/render_thread.h"
+#include "media/base/eme_constants.h"
+
+#if defined(OS_ANDROID)
+#include "components/cdm/renderer/android_key_systems.h"
+#endif
+
+// #include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR.
+#include "third_party/widevine/cdm/stub/widevine_cdm_version.h"
+
+// 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
+
+using media::KeySystemInfo;
+using media::SupportedCodecs;
+
+#if defined(ENABLE_PEPPER_CDMS)
+static bool IsPepperCdmAvailable(
+    const std::string& pepper_type,
+    std::vector<base::string16>* additional_param_names,
+    std::vector<base::string16>* additional_param_values) {
+
+  bool is_available = false;
+  content::RenderThread::Get()->Send(
+      new ChromeViewHostMsg_IsInternalPluginAvailableForMimeType(
+          pepper_type,
+          &is_available,
+          additional_param_names,
+          additional_param_values));
+
+  return is_available;
+}
+
+#if defined(WIDEVINE_CDM_AVAILABLE)
+// 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 GetSupportedCodecsForPepperCdm(
+    const std::vector<base::string16>& additional_param_names,
+    const std::vector<base::string16>& additional_param_values,
+    std::vector<std::string>* codecs) {
+  DCHECK(codecs->empty());
+  DCHECK_EQ(additional_param_names.size(), additional_param_values.size());
+  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.
+      }
+      *codecs = base::SplitString(
+          codecs_string, std::string(1, kCdmSupportedCodecsValueDelimiter),
+          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+      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 (!IsPepperCdmAvailable(kWidevineCdmPluginMimeType,
+                            &additional_param_names,
+                            &additional_param_values)) {
+    // DVLOG(1) << "Widevine CDM is not currently available.";
+
+    return;
+  }
+
+  std::vector<std::string> codecs;
+  GetSupportedCodecsForPepperCdm(additional_param_names,
+                                 additional_param_values,
+                                 &codecs);
+
+  SupportedCodecs supported_codecs = media::EME_CODEC_NONE;
+
+  // Audio codecs are always supported.
+  // TODO(sandersd): Distinguish these from those that are directly supported,
+  // as those may offer a higher level of protection.
+  supported_codecs |= media::EME_CODEC_WEBM_OPUS;
+  supported_codecs |= media::EME_CODEC_WEBM_VORBIS;
+
+#if defined(USE_PROPRIETARY_CODECS)
+  supported_codecs |= media::EME_CODEC_MP4_AAC;
+
+#endif  // defined(USE_PROPRIETARY_CODECS)
+
+  for (size_t i = 0; i < codecs.size(); ++i) {
+    if (codecs[i] == kCdmSupportedCodecVp8)
+      supported_codecs |= media::EME_CODEC_WEBM_VP8;
+
+    if (codecs[i] == kCdmSupportedCodecVp9)
+      supported_codecs |= media::EME_CODEC_WEBM_VP9;
+
+#if defined(USE_PROPRIETARY_CODECS)
+    if (codecs[i] == kCdmSupportedCodecAvc1)
+      supported_codecs |= media::EME_CODEC_MP4_AVC1;
+
+#endif  // defined(USE_PROPRIETARY_CODECS)
+  }
+
+  cdm::AddWidevineWithCodecs(
+      cdm::WIDEVINE, supported_codecs,
+#if defined(OS_CHROMEOS)
+      media::EmeRobustness::HW_SECURE_ALL,  // Maximum audio robustness.
+      media::EmeRobustness::HW_SECURE_ALL,  // Maximim video robustness.
+      media::EmeSessionTypeSupport::
+          SUPPORTED_WITH_IDENTIFIER,  // Persistent-license.
+      media::EmeSessionTypeSupport::
+          NOT_SUPPORTED,                      // Persistent-release-message.
+      media::EmeFeatureSupport::REQUESTABLE,  // Persistent state.
+      media::EmeFeatureSupport::REQUESTABLE,  // Distinctive identifier.
+#else   // (Desktop)
+      media::EmeRobustness::SW_SECURE_CRYPTO,       // Maximum audio robustness.
+      media::EmeRobustness::SW_SECURE_DECODE,       // Maximum video robustness.
+      media::EmeSessionTypeSupport::NOT_SUPPORTED,  // persistent-license.
+      media::EmeSessionTypeSupport::
+          NOT_SUPPORTED,                        // persistent-release-message.
+      media::EmeFeatureSupport::REQUESTABLE,    // Persistent state.
+      media::EmeFeatureSupport::NOT_SUPPORTED,  // Distinctive identifier.
+#endif  // defined(OS_CHROMEOS)
+      concrete_key_systems);
+}
+#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+#endif  // defined(ENABLE_PEPPER_CDMS)
+
+void AddChromeKeySystems(std::vector<KeySystemInfo>* key_systems_info) {
+
+#if defined(ENABLE_PEPPER_CDMS)
+#if defined(WIDEVINE_CDM_AVAILABLE)
+
+  AddPepperBasedWidevine(key_systems_info);
+
+#endif  // defined(WIDEVINE_CDM_AVAILABLE)
+#endif  // defined(ENABLE_PEPPER_CDMS)
+
+#if defined(OS_ANDROID)
+  cdm::AddAndroidWidevine(key_systems_info);
+#endif  // defined(OS_ANDROID)
+}

chromium_src/chrome/renderer/media/chrome_key_systems.h

@@ -0,0 +1,14 @@
+// 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.
+
+#ifndef CHROME_RENDERER_MEDIA_CHROME_KEY_SYSTEMS_H_
+#define CHROME_RENDERER_MEDIA_CHROME_KEY_SYSTEMS_H_
+
+#include <vector>
+
+#include "media/base/key_system_info.h"
+
+void AddChromeKeySystems(std::vector<media::KeySystemInfo>* key_systems_info);
+
+#endif  // CHROME_RENDERER_MEDIA_CHROME_KEY_SYSTEMS_H_