Call CDMWrapper from PpapiDecryptor.

ppapi/examples/content_decryptor/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 <iostream>
+
 #include "base/basictypes.h"
 #include "base/rand_util.h"
 #include "base/values.h"
 #include "base/memory/scoped_ptr.h"
+#include "ppapi/c/dev/pp_decryption_buffer_dev.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"
+#include "ppapi/utility/threading/simple_thread.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 DecryptedData {
   DecryptedData() : callback(PP_MakeCompletionCallback(NULL, NULL)) {}
   PP_CompletionCallback callback;
   std::string data;
+  uint32_t id;
 };
 
 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:
   const static size_t kSessionIdLength = 8;
   CDMWrapper(PP_Instance instance, pp::Module* module);
-  virtual ~CDMWrapper() {}
+  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 Decrypt(const PP_DecryptionBuffer_Dev& encrypted_buffer);
   virtual bool DecryptAndDecode(PP_Resource encrypted_block,
                                 PP_CompletionCallback callback) {
     return false;
   }
 
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
+    std::cout << "Init!!!!!!!!!!!!!!!!!" << std::endl;
+    bool success = thread_->Start();
+    std::cout << "SimpleThread Start() returns: " << success << std::endl;
+    int32_t result = thread_->message_loop().PostWork(
+        callback_factory_.NewCallback(&CDMWrapper::CallOnBackground));
+    std::cout << "PostWork returns: " << result << std::endl;
     return true;
   }
 
  private:
+  void CallOnBackground(int32_t result) {
+    std::cout << "CallOnBackground called on Background !!!!!!!!!" << std::endl;
+  }
+
   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 DecryptedData& decrypted_data);
@@ skipping 13 matching lines @@
 
   // 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_;
+
+  pp::SimpleThread* thread_;
 };
 
 CDMWrapper::CDMWrapper(PP_Instance instance,
                        pp::Module* module)
     : pp::Instance(instance),
       pp::ContentDecryptor_Dev(this) {
+  thread_ = new pp::SimpleThread(this);
   callback_factory_.Initialize(this);
 }
 
+CDMWrapper::~CDMWrapper() {
+  delete thread_;
+}
+
 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);
+  //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();
+  key_system_ = "org.chromium.externalclearkey";
   decryptor_message.key_system = key_system_;
-  session_id_ = base::RandBytesAsString(kSessionIdLength);
+  session_id_ = "1";
   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) {
@@ skipping 15 matching lines @@
 }
 
 bool CDMWrapper::CancelKeyRequest(PP_Var session_id_var) {
   std::string session_id = StringVar::FromPPVar(session_id_var)->value();
 
   // 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) {
+bool CDMWrapper::Decrypt(const PP_DecryptionBuffer_Dev& encrypted_buffer) {
+  pp::Buffer_Dev block_buffer(encrypted_buffer.data);
+  if (!block_buffer.data())
     return false;
-  }
 
   DecryptedData decrypted_data;
-  decrypted_data.callback = callback;
   decrypted_data.data = "Pretend I'm decrypted data!";
+  decrypted_data.id = encrypted_buffer.id;
   CallOnMain(callback_factory_.NewCallback(&CDMWrapper::DeliverBlock,
                                            decrypted_data));
   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);
+  pp::Var key_system(decryptor_message.key_system);
+  pp::Var session_id(decryptor_message.session_id);
+  pp::ContentDecryptor_Dev::KeyAdded(key_system.pp_var(), session_id.pp_var());
 }
 
 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::Var key_system(decryptor_message.key_system);
+  pp::Var session_id(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,
+  pp::Var default_url(decryptor_message.default_url);
+  pp::ContentDecryptor_Dev::KeyMessage(key_system.pp_var(),
+                                       session_id.pp_var(),
                                        message,
-                                       default_url);
+                                       default_url.pp_var());
 }
 
 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,
+  pp::Var key_system(decryptor_message.key_system);
+  pp::Var session_id(decryptor_message.session_id);
+  pp::ContentDecryptor_Dev::KeyError(key_system.pp_var(),
+                                     session_id.pp_var(),
                                      decryptor_message.media_error,
                                      decryptor_message.system_error);
 }
 
 void CDMWrapper::DeliverBlock(int32 result,
                               const DecryptedData& decrypted_data) {
   PP_Resource decrypted_resource = StringToBufferResource(
       decrypted_data.data);
   if (decrypted_resource) {
     pp::ContentDecryptor_Dev::DeliverBlock(decrypted_resource,
-                                           decrypted_data.callback);
+                                           decrypted_data.id);
   }
 }
 
 // This object is the global object representing this plugin library as long
 // as it is loaded.
 class MyModule : public pp::Module {
  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