Add CDM allocator interface.

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 memcpy.
 #include <vector>
 
 #include "base/compiler_specific.h"  // For OVERRIDE.
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_stdint.h"
+#include "ppapi/c/dev/ppb_buffer_dev.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/module_impl.h"

[Tom Finegan, 2012/09/01 05:00:09]

I might not need this-- was trying to use pp::get_interface<PPB_Buffer_Dev>() to
get at the PPB_Buffer_Dev C interface, but that wasn't working. Maybe I should
have been passing PPB_BUFFER_DEV_INTERFACE. Using
pp::Module::Get()->GetBrowserInterface solved the problem, anyway.

 #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"
+#include "webkit/media/crypto/ppapi/cdm_allocator.h"
 #include "webkit/media/crypto/ppapi/content_decryption_module.h"
 
 namespace {
 
 // This must be consistent with MediaKeyError defined in the spec:
 // http://goo.gl/rbdnR
 // TODO(xhwang): Add PP_MediaKeyError enum to avoid later static_cast in
 // PluginInstance.
 enum MediaKeyError {
   kUnknownError = 1,
@@ skipping 16 matching lines @@
   else
     pp::Module::Get()->core()->CallOnMainThread(0, cb, PP_OK);
 }
 
 }  // namespace
 
 namespace webkit_media {
 
 // A wrapper class for abstracting away PPAPI interaction and threading for a
 // Content Decryption Module (CDM).
-class CdmWrapper : public pp::Instance,
+class CdmWrapper : public CdmAllocatorInterface,

[xhwang, 2012/09/01 13:49:09]

Instead of making the CdmWrapper a CdmAllocator, how about making a new class in
this file named PpbBufferCdmAllocator?

In this CL, CdmWrapper::Allocate() doesn't use anything in CdmWrapper and does
not need to be a class method of CdmWrapper.

[Tom Finegan, 2012/09/01 21:32:49]

It uses pp_instance(), and buffer_iface_ is now a CdmWrapper member.

[ddorwin, 2012/09/04 09:53:15]

Pass it into the constructor. Also, see my comment in the CdmAllocator file.
It could just as easily be a member of the new class.

+                   public pp::Instance,
                    public pp::ContentDecryptor_Private {
  public:
   CdmWrapper(PP_Instance instance, pp::Module* module);
   virtual ~CdmWrapper();
 
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     return true;
   }
 
   // PPP_ContentDecryptor_Private methods
   // Note: As per comments in PPP_ContentDecryptor_Private, these calls should
   // return false if the call was not forwarded to the CDM and should return
   // true otherwise. Once the call reaches the CDM, the call result/status
   // should be reported through the PPB_ContentDecryptor_Private interface.
   virtual bool GenerateKeyRequest(const std::string& key_system,
                                   pp::VarArrayBuffer init_data) OVERRIDE;
   virtual bool AddKey(const std::string& session_id,
                       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,
       const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
   virtual bool DecryptAndDecode(
       pp::Buffer_Dev encrypted_buffer,
       const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
 
+  uint8_t* Allocate(int32_t size, int32_t* id) OVERRIDE;

[xhwang, 2012/09/01 13:49:09]

Add void Deallocate(uint8_t*, int32_t id)

[Tom Finegan, 2012/09/01 21:32:49]

See comments in cdm_allocator.h

+
  private:
   // Creates a PP_Resource containing a PPB_Buffer_Impl, copies |data| into the
   // buffer resource, and returns it. Returns a an invalid PP_Resource with an
   // ID of 0 on failure. Upon success, the returned Buffer resource has a
   // reference count of 1.
   PP_Resource MakeBufferResource(const uint8_t* data, uint32_t data_size);
 
   // <code>PPB_ContentDecryptor_Private</code> dispatchers. These are passed to
   // <code>callback_factory_</code> to ensure that calls into
   // <code>PPP_ContentDecryptor_Private</code> are asynchronous.
@@ skipping 23 matching lines @@
 }
 
 bool CdmWrapper::GenerateKeyRequest(const std::string& key_system,
                                     pp::VarArrayBuffer init_data) {
   PP_DCHECK(!key_system.empty());
 
   if (!cdm_) {
     cdm_ = CreateCdmInstance();
     if (!cdm_)
       return false;
+    if (!cdm_->Initialize(this))

[xhwang, 2012/09/01 13:49:09]

Merge these two if's to: if (!cdm_ || !cdm_->Initialize(...))

[Tom Finegan, 2012/09/01 21:32:49]

Done.

+      return false;
   }
 
   cdm::KeyMessage key_request;
   cdm::Status status = cdm_->GenerateKeyRequest(
       reinterpret_cast<const uint8_t*>(init_data.Map()),
       init_data.ByteLength(),
       &key_request);
 
   if (status != cdm::kSuccess ||
       !key_request.message ||
@@ skipping 95 matching lines @@
 
   return true;
 }
 
 bool CdmWrapper::DecryptAndDecode(
     pp::Buffer_Dev encrypted_buffer,
     const PP_EncryptedBlockInfo& encrypted_block_info) {
   return false;
 }
 
+// This method uses the C buffer interface (PPB_Buffer_Dev) because callers
+// require that the buffer is mapped.
+uint8_t* CdmWrapper::Allocate(int32_t size, int32_t* id) {
+  PP_DCHECK(size > 0);
+  PP_DCHECK(id);
+
+  const PPB_Buffer_Dev* buffer_iface = static_cast<const PPB_Buffer_Dev*>(
+      pp::Module::Get()->GetBrowserInterface(PPB_BUFFER_DEV_INTERFACE));
+  PP_DCHECK(buffer_iface);

[Tom Finegan, 2012/09/01 05:00:09]

I'll move this to Init and make buffer_iface a member; doing this every time we
allocate a buffer is unnecessary.

[Tom Finegan, 2012/09/01 21:32:49]

Done.

+
+  PP_Resource buffer_resource = buffer_iface->Create(pp_instance(), size);
+  PP_DCHECK(buffer_resource);
+  PP_DCHECK(id);
+
+  void* buffer = buffer_iface->Map(buffer_resource);
+  *id = buffer_resource;
+
+  return reinterpret_cast<uint8_t*>(buffer);
+}
+
 PP_Resource CdmWrapper::MakeBufferResource(const uint8_t* data,
                                            uint32_t data_size) {
   if (!data || !data_size)
     return 0;
 
   pp::Buffer_Dev buffer(this, data_size);
   if (!buffer.data())
     return 0;
 
   memcpy(buffer.data(), data, data_size);
@@ skipping 31 matching lines @@
   pp::ContentDecryptor_Private::KeyError(key_system_,
                                          session_id,
                                          kUnknownError,
                                          0);
 }
 
 void CdmWrapper::DeliverBlock(int32_t result,
                               const cdm::Status& status,
                               cdm::OutputBuffer& output_buffer,
                               const PP_DecryptTrackingInfo& tracking_info) {
-  pp::Buffer_Dev decrypted_buffer(MakeBufferResource(output_buffer.data,
-                                                     output_buffer.data_size));
-
   PP_DecryptedBlockInfo decrypted_block_info;
   decrypted_block_info.tracking_info.request_id = tracking_info.request_id;
   decrypted_block_info.tracking_info.timestamp = output_buffer.timestamp;
 
   switch (status) {
     case cdm::kSuccess:
       decrypted_block_info.result = PP_DECRYPTRESULT_SUCCESS;
       break;
     case cdm::kErrorNoKey:
       decrypted_block_info.result = PP_DECRYPTRESULT_DECRYPT_NOKEY;
       break;
     default:
       decrypted_block_info.result = PP_DECRYPTRESULT_DECRYPT_ERROR;
   }
 
-  pp::ContentDecryptor_Private::DeliverBlock(decrypted_buffer,
+  pp::ContentDecryptor_Private::DeliverBlock(output_buffer.buffer_id,
                                              decrypted_block_info);
-
-  // TODO(xhwang): Fix this. This is not always safe as the memory is allocated
-  // in another shared object.
-  delete [] output_buffer.data;
   output_buffer.data = NULL;
 }
 
 // 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 webkit_media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new webkit_media::MyModule();
 }
 
 }  // namespace pp