Modify the PPAPI CDM interface to pass more info.

webkit/media/crypto/ppapi/cdm_wrapper.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 <cstring>  // For std::memcpy.
 
 #include "base/compiler_specific.h"  // For OVERRIDE.
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_stdint.h"
+#include "ppapi/c/private/pp_content_decryptor.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/core.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/pass_ref.h"
 #include "ppapi/cpp/resource.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/cpp/var_array_buffer.h"
 #include "ppapi/cpp/dev/buffer_dev.h"
 #include "ppapi/cpp/private/content_decryptor_private.h"
 #include "ppapi/utility/completion_callback_factory.h"
 
 namespace {
 
 struct DecryptorMessage {
   DecryptorMessage() : media_error(0), system_code(0) {}
   std::string key_system;
   std::string session_id;
   std::string default_url;
   std::string message_data;
   int32_t media_error;
   int32_t system_code;
 };
 
 struct DecryptedBlock {
-  DecryptedBlock() : request_id(0) {}
-  int32_t request_id;
-  std::string data;
+  std::string decrypted_data;
+  PP_DecryptedBlockInfo decrypted_block_info;

[dmichael (off chromium), 2012/08/21 17:37:08]

Do you maybe still want a default constructor so you can zero out this struct?

[Tom Finegan, 2012/08/21 22:57:38]

Definitely, added. (memset abuse!)

 };
 
 void CallOnMain(pp::CompletionCallback cb) {
   pp::Module::Get()->core()->CallOnMainThread(0, cb, PP_OK);
 }
 
 }  // namespace
 
 
 // A wrapper class for abstracting away PPAPI interaction and threading for a
 // Content Decryption Module (CDM).
 class CDMWrapper : public pp::Instance,
                    public pp::ContentDecryptor_Private {
  public:
   CDMWrapper(PP_Instance instance, pp::Module* module);
   virtual ~CDMWrapper() {}
 
   // PPP_ContentDecryptor_Private methods
   virtual bool GenerateKeyRequest(const std::string& key_system,
                                   pp::VarArrayBuffer init_data) OVERRIDE;
   virtual bool AddKey(const std::string& session_id,
-                      pp::VarArrayBuffer key) OVERRIDE;
+                      pp::VarArrayBuffer key,
+                      pp::VarArrayBuffer init_data) OVERRIDE;
   virtual bool CancelKeyRequest(const std::string& session_id) OVERRIDE;
-  virtual bool Decrypt(pp::Buffer_Dev encrypted_buffer,
-                       int32_t request_id) OVERRIDE;
+  virtual bool Decrypt(
+      pp::Buffer_Dev encrypted_buffer,
+      const PP_EncryptedBlockInfo* encrypted_block_info) OVERRIDE;
 
-  virtual bool DecryptAndDecode(pp::Buffer_Dev encrypted_buffer,
-                                int32_t request_id) OVERRIDE {
+  virtual bool DecryptAndDecode(
+      pp::Buffer_Dev encrypted_buffer,
+      const PP_EncryptedBlockInfo* encrypted_block_info) OVERRIDE {
     return false;
   }
 
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     return true;
   }
 
  private:
   PP_Resource StringToBufferResource(const std::string& str);
 
@@ skipping 25 matching lines @@
   decryptor_message.session_id = "0";
   decryptor_message.default_url = "http://www.google.com";
   decryptor_message.message_data = "GenerateKeyRequest";
 
   CallOnMain(callback_factory_.NewCallback(&CDMWrapper::KeyMessage,
                                            decryptor_message));
   return true;
 }
 
 bool CDMWrapper::AddKey(const std::string& session_id,
-                        pp::VarArrayBuffer key) {
+                        pp::VarArrayBuffer key,
+                        pp::VarArrayBuffer init_data) {
   const std::string key_string(reinterpret_cast<char*>(key.Map()),
                                key.ByteLength());
+  const std::string init_data_string(reinterpret_cast<char*>(init_data.Map()),
+                                     init_data.ByteLength());

[dmichael (off chromium), 2012/08/21 17:37:08]

surprised you don't get an unused variable warning/error from Windows compile.

I can't remember if it was this part where I complained before, but I still
think you won't want to use string when you talk to the real CDM, since you're
forced to copy if you do. Just some raw bytes would probably do. If this is just
a placeholder, though, it's fine.

[Tom Finegan, 2012/08/21 22:57:38]

This is just a placeholder-- the CDM takes uint8* and a length. 

 
   PP_DCHECK(!session_id.empty() && !key_string.empty());
 
   DecryptorMessage decryptor_message;
   decryptor_message.key_system = "AddKey";
   decryptor_message.session_id = "0";
   decryptor_message.default_url = "http://www.google.com";
   decryptor_message.message_data = "AddKey";
   CallOnMain(callback_factory_.NewCallback(&CDMWrapper::KeyAdded,
                                            decryptor_message));
   return true;
 }
 
 bool CDMWrapper::CancelKeyRequest(const std::string& session_id) {
   // TODO(tomfinegan): cancel pending key request in CDM.
 
   PP_DCHECK(!session_id.empty());
 
   DecryptorMessage decryptor_message;
   decryptor_message.key_system = "CancelKeyRequest";
   decryptor_message.session_id = "0";
   decryptor_message.default_url = "http://www.google.com";
   decryptor_message.message_data = "CancelKeyRequest";
   CallOnMain(callback_factory_.NewCallback(&CDMWrapper::KeyMessage,
                                            decryptor_message));
   return true;
 }
 
 bool CDMWrapper::Decrypt(pp::Buffer_Dev encrypted_buffer,
-                         int32_t request_id) {
+                         const PP_EncryptedBlockInfo* encrypted_block_info) {
   PP_DCHECK(!encrypted_buffer.is_null());
+  PP_DCHECK(encrypted_block_info);
 
   DecryptedBlock decrypted_block;
-  decrypted_block.request_id = request_id;
-  decrypted_block.data = "Pretend I'm decrypted data!";
+  decrypted_block.decrypted_data = "Pretend I'm decrypted data!";
   CallOnMain(callback_factory_.NewCallback(&CDMWrapper::DeliverBlock,
                                            decrypted_block));

[dmichael (off chromium), 2012/08/21 17:37:08]

This copies potentially a lot of data... have you thought about ways to avoid
copying? FWIW, since you're only running out-of-process, you don't even need to
defer the callback. We enforce that the browser handles calls asynchronously in
some other places, like PostMessage. You can make the same assertion here, and
simplify some of this code, perhaps?

[Tom Finegan, 2012/08/21 22:57:38]

Added TODO per offline discussion.

   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;
@@ skipping 32 matching lines @@
                           const DecryptorMessage& decryptor_message) {
   pp::ContentDecryptor_Private::KeyError(decryptor_message.key_system,
                                          decryptor_message.session_id,
                                          decryptor_message.media_error,
                                          decryptor_message.system_code);
 }
 
 void CDMWrapper::DeliverBlock(int32_t result,
                               const DecryptedBlock& decrypted_block) {
   pp::Buffer_Dev decrypted_buffer(
-      StringToBufferResource(decrypted_block.data));
-  pp::ContentDecryptor_Private::DeliverBlock(decrypted_buffer,
-                                             decrypted_block.request_id);
+      StringToBufferResource(decrypted_block.decrypted_data));
+  pp::ContentDecryptor_Private::DeliverBlock(
+      decrypted_buffer,
+      &decrypted_block.decrypted_block_info);
 }
 
 // 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