Update CDM interface and add clear key CDM.

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_CONTENT_DECRYPTION_MODULE_H_
 #define WEBKIT_MEDIA_CRYPTO_CONTENT_DECRYPTION_MODULE_H_
 
 #if defined(_MSC_VER)
 typedef unsigned char uint8_t;
 typedef unsigned int uint32_t;
 typedef __int64 int64_t;
 #else
 #include <stdint.h>
 #endif
 
+#include "cdm_export.h"
+
 namespace cdm {
 class ContentDecryptionModule;
 }
 
 extern "C" {
-cdm::ContentDecryptionModule* CreateCdmInstance();
-void DestroyCdmInstance(cdm::ContentDecryptionModule* instance);
-const char* GetCdmVersion();
+CDM_EXPORT cdm::ContentDecryptionModule* CreateCdmInstance();

[xhwang, 2012/08/20 21:09:45]

This is to simulate what's in MEDIA_EXPORT, or CONTENT_EXPORT, the chromium way
to make symbols visible.

[ddorwin, 2012/08/20 21:27:07]

I don't think its definition should be based on defined(COMPONENT_BUILD) then.
We always want to export these because this is always a .so/.dll.

[xhwang, 2012/08/20 21:57:10]

Done.

+CDM_EXPORT void DestroyCdmInstance(cdm::ContentDecryptionModule* instance);
+CDM_EXPORT const char* GetCdmVersion();
 }
 
 namespace cdm {
 
+enum Status {

[xhwang, 2012/08/20 21:09:45]

Move it here so that the caller (e.g. CdmWrapper) doesn't need to use the long
name like cdm::ContentDecryptionModule::Status.

+  kSuccess = 0,
+  kErrorUnknown,
+  kErrorNoKey
+};
+
+struct KeyRequest {
+  char* session_id;
+  uint32_t session_id_size;
+  uint8_t* key_request;
+  uint32_t key_request_size;
+  char* default_url;
+  uint32_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
 // (in the subsample order) into a single logical stream. The clear bytes should
 // not be considered as part of decryption.
@@ skipping 37 matching lines @@
 
 struct OutputBuffer {
   uint8_t* data;  // Pointer to the beginning of the output data.
   uint32_t data_size;  // Size (in bytes) of |data|.
 
   int64_t timestamp;  // Presentation timestamp in microseconds.
 };
 
 class ContentDecryptionModule {
  public:
-  enum Status {
-    kSuccess = 0,
-    kErrorUnknown,
-    kErrorNoKey
-  };
-
-  // Generates a |key_request| as well as a |session_id| given the |init_data|.
-  // The CDM may also extract a |default_url|.
+  // Generates a |key_request| given the |init_data|.
   // Returns kSuccess if the key request was successfully generated,
   // in which case the callee should have allocated memory for the output
-  // parameters (e.g |session_id|) and passed the ownership to the caller.
-  // Returns kErrorUnknown otherwise, in which case the output
-  // parameters should not be used by the caller.
+  // parameters (e.g |session_id| in |key_request|) and passed the ownership
+  // to the caller.
+  // Returns kErrorUnknown otherwise, in which case the output parameters should
+  // not be used by the caller.
   //
   // TODO(xhwang): It's not safe to pass the ownership of the dynamically
   // allocated memory over library boundaries. Fix it after related PPAPI change
   // and sample CDM are landed.
   virtual Status GenerateKeyRequest(const uint8_t* init_data,
                                     int init_data_size,
-                                    char** session_id,
-                                    int* session_id_size,
-                                    uint8_t** key_request,
-                                    int* key_request_size,
-                                    char** default_url,
-                                    int* default_url_size) = 0;
+                                    KeyRequest* key_request) = 0;
 
   // Adds the |key| to the CDM to be associated with |key_id|.
   // Returns kSuccess if the key was successfully added.
   // Returns kErrorUnknown otherwise.
   virtual Status AddKey(const char* session_id,
                         int session_id_size,
                         const uint8_t* key,
                         int key_size,
                         const uint8_t* key_id,
                         int key_id_size) = 0;
@@ skipping 10 matching lines @@
   // should have filled the |decrypted_buffer| and passed the ownership of
   // |data| in |decrypted_buffer| to the caller.
   // Returns kErrorNoKey if the CDM did not have the necessary decryption key
   // to decrypt.
   // Returns kErrorUnknown if any other error happened.
   // In these two cases, |decrypted_buffer| should not be used by the caller.
   //
   // TODO(xhwang): It's not safe to pass the ownership of the dynamically
   // allocated memory over library boundaries. Fix it after related PPAPI change
   // and sample CDM are landed.
-  virtual Status Decrypt(const char* session_id,
-                         int session_id_size,
-                         const InputBuffer& encrypted_buffer,
+  virtual Status Decrypt(const InputBuffer& encrypted_buffer,
                          OutputBuffer* decrypted_buffer) = 0;
 
   virtual ~ContentDecryptionModule() {};
 };
 
 }  // namespace cdm
 
 #endif  // WEBKIT_MEDIA_CRYPTO_CONTENT_DECRYPTION_MODULE_H_