Componentize EncryptedMediaMessageFilter and rename it CdmMessageFilter.

content/renderer/media/crypto/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 "content/renderer/media/crypto/key_systems.h"
 
 #include <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/eme_codec.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/key_system_info.h"
+#include "content/public/renderer/render_thread.h"
 #include "content/renderer/media/crypto/key_systems_support_uma.h"
 
 #if defined(OS_ANDROID)
+#include "content/common/media/encrypted_media_messages_android.h"
 #include "media/base/android/media_codec_bridge.h"
 #endif
 
 #include "widevine_cdm_version.h" // In SHARED_INTERMEDIATE_DIR.
 
 namespace content {
 
 const char kClearKeyKeySystem[] = "org.w3.clearkey";
 const char kPrefixedClearKeyKeySystem[] = "webkit-org.w3.clearkey";
 const char kUnsupportedClearKeyKeySystem[] = "unsupported-org.w3.clearkey";
@@ skipping 37 matching lines @@
   info.supported_codecs = EME_CODEC_WEBM_ALL;
 #if defined(USE_PROPRIETARY_CODECS)
   info.supported_codecs |= EME_CODEC_MP4_ALL;
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
   info.use_aes_decryptor = true;
 
   concrete_key_systems->push_back(info);
 }
 
+#if defined(OS_ANDROID)
+static void AddAndroidWidevine(
+    std::vector<KeySystemInfo>* concrete_key_systems) {
+  static const char kKeySystemSuffixHrNonCompositing[] = ".hrnoncompositing";

[Tom Sepez, 2014/04/28 18:21:52]

nit: kinda wish this constant wasn't buried so deep in file.

+  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 ViewHostMsg_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) {
+    concrete_key_systems->push_back(KeySystemInfo::Build(
+        kWidevineKeySystem,
+        true,  // has_parent
+        NULL,  // suffix
+        static_cast<SupportedCodecs>(response.compositing_codecs)));
+  }
+
+  if (response.non_compositing_codecs != content::EME_CODEC_NONE) {
+    concrete_key_systems->push_back(KeySystemInfo::Build(
+        kWidevineKeySystem,
+        false,  // has_parent
+        kKeySystemSuffixHrNonCompositing,  // suffix
+        static_cast<SupportedCodecs>(response.non_compositing_codecs)));
+  }
+}
+#endif
+
 class KeySystems {
  public:
   static KeySystems& GetInstance();
 
   bool IsConcreteSupportedKeySystem(const std::string& key_system);
 
   bool IsSupportedKeySystemWithMediaMimeType(
       const std::string& mime_type,
       const std::vector<std::string>& codecs,
       const std::string& key_system);
@@ skipping 85 matching lines @@
     container_codec_masks_[container_codec_mask.type] =
         container_codec_mask.mask;
   }
   for (size_t i = 0; i < arraysize(kCodecMasks); ++i) {
     const CodecMask& codec_mask = kCodecMasks[i];
     DCHECK(codec_masks_.find(codec_mask.type) == codec_masks_.end());
     codec_masks_[codec_mask.type] = codec_mask.mask;
   }
 
   std::vector<KeySystemInfo> key_systems_info;
   GetContentClient()->renderer()->AddKeySystems(&key_systems_info);

[ddorwin, 2014/04/28 18:47:45]

I think we should not make (or compile support for) this call on OS_ANDROID.
Instead, we should make the IPC to get the answers from the browser, which may
then ask chrome/.

   // Clear Key is always supported.
   AddClearKey(&key_systems_info);
   AddConcreteSupportedKeySystems(key_systems_info);
+#if defined(OS_ANDROID)
+  AddAndroidWidevine(&key_systems_info);

[ddorwin, 2014/04/28 18:47:45]

Like desktop, this should be in chrome/, but on the browser side.

+#endif  // defined(OS_ANDROID)
 #if defined(WIDEVINE_CDM_AVAILABLE)
   key_systems_support_uma_.AddKeySystemToReport(kWidevineKeySystem);
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 }
 
 void KeySystems::AddConcreteSupportedKeySystems(
     const std::vector<KeySystemInfo>& concrete_key_systems) {
   for (size_t i = 0; i < concrete_key_systems.size(); ++i) {
     const KeySystemInfo& key_system_info = concrete_key_systems[i];
     AddConcreteSupportedKeySystem(key_system_info.key_system,
@@ skipping 249 matching lines @@
 CONTENT_EXPORT void AddContainerMask(const std::string& container,
                                      uint32 mask) {
   KeySystems::GetInstance().AddContainerMask(container, mask);
 }
 
 CONTENT_EXPORT void AddCodecMask(const std::string& codec, uint32 mask) {
   KeySystems::GetInstance().AddCodecMask(codec, mask);
 }
 
 }  // namespace content