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() {}

[ddorwin, 2012/09/12 23:53:01]

Do we need this? It can't be constructed because it's abstract, so it's already
essentially protected. The copy constructor might be problematic and require
this to be declared. Anyway, it should be protected I think.

[Tom Finegan, 2012/09/13 10:33:40]

Need it to construct PpbCdmBuffer, but I made it protected.

+  virtual ~Buffer() {}
+  virtual uint8_t* buffer() const = 0;
+  virtual int32_t size() const = 0;
+
+ private:
+  Buffer(const Buffer&);
+  void operator=(const Buffer&);
+};
+
 // 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.

[ddorwin, 2012/09/12 23:53:01]

Is that really an exception? ReleaseBuffer() frees it in the wrapper.

[Tom Finegan, 2012/09/13 10:33:40]

Done.

+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*.

[ddorwin, 2012/09/12 23:53:01]

The caller does own the Buffer* but not the underlying buffer.

[Tom Finegan, 2012/09/13 10:33:40]

Done.

+  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.

[ddorwin, 2012/09/12 23:53:01]

No return value now

[Tom Finegan, 2012/09/13 10:33:40]

Done.

+  virtual void ReleaseBuffer(const Buffer& buffer) = 0;
+};
+
 }  // namespace cdm
 
 #endif  // WEBKIT_MEDIA_CRYPTO_PPAPI_CONTENT_DECRYPTION_MODULE_H_