Add PpapiDecryptor which wraps a CDM plugin.

webkit/media/crypto/key_systems.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 "webkit/media/crypto/key_systems.h"
 
 #include "media/base/decryptor.h"
 #include "media/crypto/aes_decryptor.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
+#include "webkit/media/crypto/ppapi_decryptor.h"
 
 namespace webkit_media {
 
 namespace {
 
 const char kClearKeyKeySystem[] = "webkit-org.w3.clearkey";
+const char kExternalClearKeyKeySystem[] = "webkit-org.w3.external-clearkey";

[ddorwin, 2012/07/17 21:31:28]

I haven't thought this through entirely, but it seems maybe it should be
org.chromium... since this will never be an org.w3 thing.

[xhwang, 2012/07/18 19:43:17]

Done.

 
 struct MediaFormatAndKeySystem {
   const char* mime_type;
   const char* codec;
   const char* key_system;
 };
 
+struct KeySystemPluginNamePair {

[ddorwin, 2012/07/17 21:31:28]

MimeType here and below.

[xhwang, 2012/07/18 19:43:17]

Use PluginType as discussed.

+  const char* key_system;
+  const char* plugin_name;
+};
+
 static const MediaFormatAndKeySystem
 supported_format_key_system_combinations[] = {
   // TODO(ddorwin): Reconsider based on how usage of this class evolves.
   // For now, this class is stateless, so we do not have the opportunity to
   // build a list using ParseCodecString() like
   // net::MimeUtil::InitializeMimeTypeMaps(). Therfore, the following line must
   // be separate entries.
   // { "video/webm", "vorbis,vp8,vp8.0", kClearKeyKeySystem },
   { "video/webm", "vorbis", kClearKeyKeySystem },
   { "video/webm", "vp8", kClearKeyKeySystem },
   { "video/webm", "vp8.0", kClearKeyKeySystem },
   { "audio/webm", "vorbis", kClearKeyKeySystem },
   { "video/webm", "", kClearKeyKeySystem },
   { "audio/webm", "", kClearKeyKeySystem }

[ddorwin, 2012/07/17 21:31:28]

Need to update these tables too.

[xhwang, 2012/07/18 19:43:17]

Done.

 };
 
+static const KeySystemPluginNamePair key_system_to_plugin_name_mapping[] = {
+  // TODO(xhwang): Update this with the real plugin name.
+  { kExternalClearKeyKeySystem, "application/x-ppapi-example" }

[ddorwin, 2012/07/17 21:31:28]

FYI, the same TODO as in the above table would apply here as well.

+};
+
 bool IsSupportedKeySystemWithContainerAndCodec(const std::string& mime_type,
                                                const std::string& codec,
                                                const std::string& key_system) {
   for (size_t i = 0;
        i < arraysize(supported_format_key_system_combinations);
        ++i) {
     const MediaFormatAndKeySystem& combination =
         supported_format_key_system_combinations[i];
     if (combination.mime_type == mime_type &&
         combination.codec == codec &&
         combination.key_system == key_system)
       return true;
   }
 
   return false;
 }
 
 }  // namespace
 
 bool IsSupportedKeySystem(const WebKit::WebString& key_system) {
   if (key_system == kClearKeyKeySystem)

[ddorwin, 2012/07/17 21:31:28]

Need to add new key system(s). Maybe we should base this on a table too.

[xhwang, 2012/07/18 19:43:17]

Done. I'll keep "if" here instead of using table as we only have two entries
now.

     return true;
   return false;
 }
 
 bool IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {
   if (codecs.empty())
     return IsSupportedKeySystemWithContainerAndCodec(mime_type, "", key_system);
 
   for (size_t i = 0; i < codecs.size(); ++i) {
     if (!IsSupportedKeySystemWithContainerAndCodec(
             mime_type, codecs[i], key_system))
       return false;
   }
 
   return true;
 }
 
-scoped_ptr<media::Decryptor> CreateDecryptor(const std::string& key_system,
-                                             media::DecryptorClient* client) {
+const char* GetPluginName(const std::string& key_system) {
+  for (size_t i = 0; i < arraysize(key_system_to_plugin_name_mapping); ++i) {
+    if (key_system_to_plugin_name_mapping[i].key_system == key_system)
+      return key_system_to_plugin_name_mapping[i].plugin_name;
+  }
+
+  return NULL;
+}
+
+scoped_ptr<media::Decryptor> CreateDecryptor(
+    const std::string& key_system,
+    media::DecryptorClient* client,
+    const CreatePluginCB& create_plugin_cb) {

[ddorwin, 2012/07/17 21:31:28]

It's unexpected that this cb isn't always called. Can we make the callback more
generic and call it for all cases?

[xhwang, 2012/07/18 19:43:17]

Removed CreatePluginCB and just passing the client and frame. This whole
function is moved into ProxyDecryptor.

   if (key_system == kClearKeyKeySystem)
     return scoped_ptr<media::Decryptor>(new media::AesDecryptor(client));
+  else if (key_system == kExternalClearKeyKeySystem)

[ddorwin, 2012/07/17 21:31:28]

I think we should GetPlugingMimeType() and if not NULL then create
PpapiDecryptor with that value.
We don't need to duplicate string comparisons.

[xhwang, 2012/07/18 19:43:17]

Moved this check and related logic into PpapiDecryptor::Init(). 

+    return scoped_ptr<media::Decryptor>(
+        new webkit_media::PpapiDecryptor(client, create_plugin_cb));
   return scoped_ptr<media::Decryptor>();
 }
 
 }  // namespace webkit_media