Add PPAPI decryptor interfaces.

webkit/media/crypto/content_decryptor.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 <cassert>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/string_number_conversions.h"
+#include "base/memory/scoped_ptr.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/cpp/completion_callback.h"
+#include "ppapi/cpp/core.h"
+#include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/module.h"
+#include "ppapi/cpp/resource.h"
+#include "ppapi/cpp/var.h"
+#include "ppapi/cpp/dev/buffer_dev.h"
+#include "ppapi/cpp/dev/content_decryptor_dev.h"
+#include "ppapi/shared_impl/var.h"
+#include "ppapi/utility/completion_callback_factory.h"
+
+using ppapi::StringVar;
+
+namespace {
+
+struct DecryptorMessage {
+  DecryptorMessage() : media_error(0), system_error(0) {}
+  std::string key_system;
+  std::string session_id;
+  std::string default_url;
+  std::string message_data;
+  uint16 media_error;
+  uint16 system_error;
+};
+
+struct DecryptedBlock {
+  DecryptedBlock() : callback(PP_MakeCompletionCallback(NULL, NULL)) {}
+  PP_CompletionCallback callback;
+  std::string data;
+};
+
+bool IsMainThread() {
+  return pp::Module::Get()->core()->IsMainThread();
+}
+
+void CallOnMain(pp::CompletionCallback cb) {
+  pp::Module::Get()->core()->CallOnMainThread(0, cb, PP_OK);
+}
+
+}  // namespace
+
+
+// A wrapper class responsible for managing interaction between the browser and
+// a Content Decryption Module (CDM).
+class CDMWrapper : public pp::Instance,
+                   public pp::ContentDecryptor_Dev {
+ public:
+  CDMWrapper(PP_Instance instance, pp::Module* module);
+  virtual ~CDMWrapper() {}
+
+  // PPP_ContentDecryptor_Dev methods
+  virtual bool GenerateKeyRequest(PP_Var key_system, PP_Resource init_data);
+  virtual bool AddKey(PP_Var session_id, PP_Resource key);
+  virtual bool CancelKeyRequest(PP_Var session_id);
+  virtual bool Decrypt(PP_Resource encrypted_block,
+                       PP_CompletionCallback callback);
+
+  virtual bool DecryptAndDecode(PP_Resource encrypted_block,
+                                PP_CompletionCallback callback) {
+    return false;
+  }
+
+  virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
+    return true;
+  }
+
+ private:
+  PP_Resource StringToBufferResource(const std::string& str);
+
+  // <code>PPB_ContentDecryptor_Dev</code> dispatchers. These are passed to
+  // <code>callback_factory_</code> to ensure that calls into
+  // <code>PPP_ContentDecryptor_Dev</code> are asynchronous.
+  void NeedKey(int32 result, const DecryptorMessage& decryptor_message);
+  void KeyAdded(int32 result, const DecryptorMessage& decryptor_message);
+  void KeyMessage(int32 result, const DecryptorMessage& decryptor_message);
+  void KeyError(int32 result, const DecryptorMessage& decryptor_message);
+  void DeliverBlock(int32 result, const DecryptedBlock& decrypted_block);
+
+  pp::CompletionCallbackFactory<CDMWrapper> callback_factory_;
+
+  virtual bool IsValidSessionId(std::string session_id) {
+    // TODO(tomfinegan): The CDM MUST handle multiple session IDs. This simple
+    // implementation exists for testing purposes.
+    return (!session_id_.empty() && session_id == session_id_);
+  }
+
+  // TODO(tomfinegan): This needs to be mappable to init data (key IDs in the
+  // WebM case). For WebM it most likely will be 1 key ID and 1 session per
+  // stream. For now we'll just use a random number.
+  uint32 next_session_id_;
+  std::string session_id_;
+
+  // Key ID obtained from init data passed to <code>GenerateKeyRequest</code>.
+  // As-is: WebM video specific; Inadequate for WebM with encrypted audio (A/V
+  // will not have same key ID/key/session ID). Probably inadequate for ISO.
+  std::string key_id_;
+
+  // TODO(tomfinegan): Should these be multimaps of session_id:key_system and
+  // session_id:key? Or am I completely confused? :)
+  std::string key_;
+  std::string key_system_;
+};
+
+CDMWrapper::CDMWrapper(PP_Instance instance,
+                       pp::Module* module)
+    : pp::Instance(instance),
+      pp::ContentDecryptor_Dev(this),
+      next_session_id_(0) {
+  callback_factory_.Initialize(this);
+}
+
+bool CDMWrapper::GenerateKeyRequest(PP_Var key_system_arg,
+                                    PP_Resource init_data) {
+  if (init_data) {
+    pp::Buffer_Dev init_buffer(init_data);
+    if (!init_buffer.data() || init_buffer.size() == 0) {
+      return false;
+    }
+
+    // TODO(tomfinegan): Testing only implementation; init data will not always
+    // be the key ID.
+    key_id_.assign(reinterpret_cast<char*>(init_buffer.data()),
+                   init_buffer.size());
+  }
+
+  StringVar* key_system_var = StringVar::FromPPVar(key_system_arg);
+
+  // TODO(tomfinegan): confirm support for the key system.
+
+  DecryptorMessage decryptor_message;
+  key_system_ = key_system_var->value();
+  decryptor_message.key_system = key_system_;
+  session_id_ = base::UintToString(next_session_id_++);
+  decryptor_message.session_id = session_id_;
+  decryptor_message.default_url = "http://www.google.com";
+  decryptor_message.message_data = "key request";
+
+  CallOnMain(callback_factory_.NewCallback(&CDMWrapper::KeyMessage,
+                                           decryptor_message));
+  return true;
+}
+
+bool CDMWrapper::AddKey(PP_Var session_id_var, PP_Resource key) {
+  if (!IsValidSessionId(StringVar::FromPPVar(session_id_var)->value()))
+    return false;
+
+  pp::Buffer_Dev key_buffer(key);
+  if (!key_buffer.data())
+    return false;
+
+  key_.assign(reinterpret_cast<char*>(key_buffer.data()), key_buffer.size());
+
+  DecryptorMessage decryptor_message;
+  decryptor_message.key_system = key_system_;
+  decryptor_message.session_id = session_id_;
+  CallOnMain(callback_factory_.NewCallback(&CDMWrapper::KeyAdded,
+                                           decryptor_message));
+  return true;
+}
+
+bool CDMWrapper::CancelKeyRequest(PP_Var session_id_var) {
+  std::string session_id = StringVar::FromPPVar(session_id_var)->value();
+
+  if (!IsValidSessionId(session_id))
+    return false;
+
+  // TODO(tomfinegan): cancel pending key request in CDM.
+
+  return true;
+}
+
+bool CDMWrapper::Decrypt(PP_Resource encrypted_block,
+                         PP_CompletionCallback callback) {
+  pp::Buffer_Dev block_buffer(encrypted_block);
+  if (!block_buffer.data() || !callback.func) {
+    return false;
+  }
+
+  DecryptedBlock decrypted_block;
+  decrypted_block.callback = callback;
+  decrypted_block.data = "Pretend I'm decrypted data!";
+  CallOnMain(callback_factory_.NewCallback(&CDMWrapper::DeliverBlock,
+                                           decrypted_block));
+  return true;
+}
+
+PP_Resource CDMWrapper::StringToBufferResource(const std::string& str) {
+  if (str.empty())
+    return 0;
+
+  pp::Buffer_Dev buffer(this, str.size());
+  if (!buffer.data())
+    return 0;
+
+  memcpy(buffer.data(), str.data(), str.size());
+  return buffer.detach();
+}
+
+void CDMWrapper::NeedKey(int32 result,
+                         const DecryptorMessage& decryptor_message) {
+  PP_Var key_system = StringVar::StringToPPVar(decryptor_message.key_system);
+  PP_Var session_id = StringVar::StringToPPVar(decryptor_message.session_id);
+  PP_Resource init_data =
+      StringToBufferResource(decryptor_message.message_data);
+  pp::ContentDecryptor_Dev::NeedKey(key_system, session_id, init_data);
+}
+
+void CDMWrapper::KeyAdded(int32 result,
+                          const DecryptorMessage& decryptor_message) {
+  PP_Var key_system = StringVar::StringToPPVar(decryptor_message.key_system);
+  PP_Var session_id = StringVar::StringToPPVar(decryptor_message.session_id);
+  pp::ContentDecryptor_Dev::KeyAdded(key_system, session_id);
+}
+
+void CDMWrapper::KeyMessage(int32 result,
+                            const DecryptorMessage& decryptor_message) {
+  PP_Var key_system = StringVar::StringToPPVar(decryptor_message.key_system);
+  PP_Var session_id = StringVar::StringToPPVar(decryptor_message.session_id);
+  PP_Resource message =
+      StringToBufferResource(decryptor_message.message_data);
+  PP_Var default_url =
+      StringVar::StringToPPVar(decryptor_message.default_url);
+  pp::ContentDecryptor_Dev::KeyMessage(key_system,
+                                       session_id,
+                                       message,
+                                       default_url);
+}
+
+void CDMWrapper::KeyError(int32 result,
+                          const DecryptorMessage& decryptor_message) {
+  PP_Var key_system = StringVar::StringToPPVar(decryptor_message.key_system);
+  PP_Var session_id = StringVar::StringToPPVar(decryptor_message.session_id);
+  pp::ContentDecryptor_Dev::KeyError(key_system,
+                                     session_id,
+                                     decryptor_message.media_error,
+                                     decryptor_message.system_error);
+}
+
+void CDMWrapper::DeliverBlock(int32 result,
+                              const DecryptedBlock& decrypted_block) {
+  PP_Resource decrypted_resource = StringToBufferResource(
+      decrypted_block.data);
+  if (decrypted_resource) {
+    pp::ContentDecryptor_Dev::DeliverBlock(decrypted_resource,
+                                           decrypted_block.callback);
+  }
+}
+
+// This object is the global object representing this plugin library as long
+// as it is loaded.
+class MyModule : public pp::Module {

[dmichael (off chromium), 2012/07/31 03:36:31]

I'm confused about what this file is...  is this the "plugin"? (Admitting that
IIRC, you guys are doing something a little different than a regular plugin...)

If so, you shouldn't be using anything from ppapi/shared_impl (like
StringVar::StringToPPVar above). That's for Chrome's internal use only, and
using it here is likely to break stuff.

[Tom Finegan, 2012/08/01 04:19:22]

Don't worry-- it _is_ confusing. :)

The pepper plugin is a wrapper that's going to be used to load CDMs (Content
Decryption Modules) and be responsible for things like:
- handling the movement of data between chrome and the CDM
- ensure calls into the CDM are asynchronous (to avoid having each author/vendor
deal with threading etc)
Removed the shared_impl stuff (from the source code and the gyp file). Is my
usage correct?

+ public:
+  MyModule() : pp::Module() {}
+  virtual ~MyModule() {}
+
+  virtual pp::Instance* CreateInstance(PP_Instance instance) {
+    return new CDMWrapper(instance, this);
+  }
+};
+
+namespace pp {
+
+// Factory function for your specialization of the Module object.
+Module* CreateModule() {
+  return new MyModule();
+}
+
+}  // namespace pp