Add CDM allocator interface.

webkit/media/crypto/ppapi/content_decryption_module.h

 // 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.
 
 #ifndef WEBKIT_MEDIA_CRYPTO_PPAPI_CONTENT_DECRYPTION_MODULE_H_
 #define WEBKIT_MEDIA_CRYPTO_PPAPI_CONTENT_DECRYPTION_MODULE_H_
 
 #if defined(_MSC_VER)
 typedef unsigned char uint8_t;
 typedef unsigned int uint32_t;
 typedef int int32_t;
 typedef __int64 int64_t;
 #else
 #include <stdint.h>
 #endif
 
 #include "webkit/media/crypto/ppapi/cdm_export.h"
 
 namespace cdm {
+class Allocator;
 class ContentDecryptionModule;
 }
 
 extern "C" {
-CDM_EXPORT cdm::ContentDecryptionModule* CreateCdmInstance();
+CDM_EXPORT cdm::ContentDecryptionModule* CreateCdmInstance(
+    cdm::Allocator* allocator);
 CDM_EXPORT void DestroyCdmInstance(cdm::ContentDecryptionModule* instance);
 CDM_EXPORT const char* GetCdmVersion();
 }
 
 namespace cdm {
 
 enum Status {
   kSuccess = 0,
   kNeedMoreData,  // Decoder needs more data to produce a decoded frame/sample.
   kNoKey,  // The required decryption key is not available.
   kError
 };
 
 // Represents a key message sent by the CDM. It does not own any pointers in
 // this struct.
-// TODO(xhwang): Use int32_t instead of uint32_t for sizes here and below and
-// update checks to include <0.
 struct KeyMessage {
   KeyMessage()
       : session_id(NULL),
         session_id_size(0),
         message(NULL),
         message_size(0),
         default_url(NULL),
         default_url_size(0) {}
 
   char* session_id;
-  uint32_t session_id_size;
+  int32_t session_id_size;
+
+  // TODO(tomfinegan): Replace |message| and |message_size| with a CdmBuffer.
   uint8_t* message;
-  uint32_t message_size;
+  int32_t message_size;
+
   char* default_url;
-  uint32_t default_url_size;
+  int32_t default_url_size;
 };
 
 // An input buffer can be split into several continuous subsamples.
 // A SubsampleEntry specifies the number of clear and cipher bytes in each
 // subsample. For example, the following buffer has three subsamples:
 //
 // |<----- subsample1 ----->|<----- subsample2 ----->|<----- subsample3 ----->|
 // |   clear1   |  cipher1  |  clear2  |   cipher2   | clear3 |    cipher3    |
 //
 // For decryption, all of the cipher bytes in a buffer should be concatenated
@@ skipping 12 matching lines @@
 //
 // TODO(xhwang): Add checks to make sure these structs have fixed layout.
 struct SubsampleEntry {
   SubsampleEntry(uint32_t clear_bytes, uint32_t cipher_bytes)
       : clear_bytes(clear_bytes), cipher_bytes(cipher_bytes) {}
 
   uint32_t clear_bytes;
   uint32_t cipher_bytes;
 };
 
+// Encapsulates all data required to interact with buffers allocated by
+// Allocator implementations. Note that the buffer described by this object is
+// not freed when the object is destroyed.
+class Buffer {
+ public:
+  Buffer() {}
+  virtual ~Buffer() {}
+  virtual uint8_t* buffer() const = 0;
+  virtual int32_t size() const = 0;

[dmichael (off chromium), 2012/09/10 16:10:35]

Consider disallowing copy and assign here, too.

[Tom Finegan, 2012/09/11 02:58:06]

Done, but did it manually (don't want to add the base/basictypes.h dependency in
CDM.h).

+};
+
 // Represents an input buffer to be decrypted (and possibly decoded). It does
 // own any pointers in this struct.
 struct InputBuffer {
   InputBuffer()
       : data(NULL),
         data_size(0),
         data_offset(0),
         key_id(NULL),
         key_id_size(0),
         iv(NULL),
         iv_size(0),
         checksum(NULL),
         checksum_size(0),
         subsamples(NULL),
         num_subsamples(0),
         timestamp(0) {}
 
   const uint8_t* data;  // Pointer to the beginning of the input data.
-  uint32_t data_size;  // Size (in bytes) of |data|.
+  int32_t data_size;  // Size (in bytes) of |data|.
 
-  uint32_t data_offset;  // Number of bytes to be discarded before decryption.
+  int32_t data_offset;  // Number of bytes to be discarded before decryption.
 
   const uint8_t* key_id;  // Key ID to identify the decryption key.
-  uint32_t key_id_size;  // Size (in bytes) of |key_id|.
+  int32_t key_id_size;  // Size (in bytes) of |key_id|.
 
   const uint8_t* iv;  // Initialization vector.
-  uint32_t iv_size;  // Size (in bytes) of |iv|.
+  int32_t iv_size;  // Size (in bytes) of |iv|.
 
   const uint8_t* checksum;
-  uint32_t checksum_size;  // Size (in bytes) of the |checksum|.
+  int32_t checksum_size;  // Size (in bytes) of the |checksum|.
 
   const struct SubsampleEntry* subsamples;
-  uint32_t num_subsamples;  // Number of subsamples in |subsamples|.
+  int32_t num_subsamples;  // Number of subsamples in |subsamples|.
 
   int64_t timestamp;  // Presentation timestamp in microseconds.
 };
 
 // Represents an output decrypted buffer. It does not own |data|.
 struct OutputBuffer {
   OutputBuffer()
-      : data(NULL),
-        data_size(0),
-        timestamp(0) {}
-
-  const uint8_t* data;  // Pointer to the beginning of the output data.
-  uint32_t data_size;  // Size (in bytes) of |data|.
+      : timestamp(0),
+        buffer(NULL) {}
 
   int64_t timestamp;  // Presentation timestamp in microseconds.
+  cdm::Buffer* buffer;
 };
 
 // Surface formats based on FOURCC labels, see:
 // http://www.fourcc.org/yuv.php
 enum VideoFormat {
   kUnknownVideoFormat = 0,  // Unknown format value.  Used for error reporting.
   kEmptyVideoFrame,  // An empty frame.
   kYv12,  // 12bpp YVU planar 1x1 Y, 2x2 VU samples.
   kI420  // 12bpp YVU planar 1x1 Y, 2x2 UV samples.
 };
@@ skipping 154 matching lines @@
 
   // Stops the CDM video decoder and sets it to an uninitialized state. The
   // caller can call InitializeVideoDecoder() again after this call to
   // re-initialize the video decoder. This can be used to reconfigure the
   // video decoder if the config changes.
   virtual void StopVideoDecoder() = 0;
 
   virtual ~ContentDecryptionModule() {}
 };
 
+// Interface class that hides cross object memory allocation details from CDMs.
+// Allocated buffers should only be freed by the CDM wrapper with the single
+// exception noted by the |ReleaseBuffer()| comment.
+class Allocator {
+ public:
+  Allocator() {}
+  virtual ~Allocator() {}
+
+  // Returns a Buffer* containing non-zero members upon success, or NULL on
+  // failure. The caller does not own the Buffer*.
+  virtual Buffer* Allocate(int32_t size) = 0;
+
+  // Used by the CDM to release a buffer that will not be delivered to the CDM
+  // wrapper. Returns true when |buffer| is valid, and false otherwise.
+  virtual void ReleaseBuffer(const Buffer& buffer) = 0;
+};
+
 }  // namespace cdm
 
 #endif  // WEBKIT_MEDIA_CRYPTO_PPAPI_CONTENT_DECRYPTION_MODULE_H_