Switch CDM.h to use uint32_t for size types per style guide.

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 CDM_CONTENT_DECRYPTION_MODULE_H_
 #define CDM_CONTENT_DECRYPTION_MODULE_H_
 
 #if defined(_MSC_VER)
 typedef unsigned char uint8_t;
 typedef unsigned int uint32_t;
@@ skipping 41 matching lines @@
 
 // Returns a pointer to the requested CDM upon success.
 // Returns NULL if an error occurs or the requested |cdm_interface_version| or
 // |key_system| is not supported or another error occurs.
 // The caller should cast the returned pointer to the type matching
 // |cdm_interface_version|.
 // Caller retains ownership of arguments and must call Destroy() on the returned
 // object.
 CDM_EXPORT void* CreateCdmInstance(
     int cdm_interface_version,
-    const char* key_system, int key_system_size,
+    const char* key_system, uint32_t key_system_size,
     GetCdmHostFunc get_cdm_host_func, void* user_data);
 
 CDM_EXPORT const char* GetCdmVersion();
 }
 
 namespace cdm {
 
 class AudioFrames_1;
 class AudioFrames_2;
 typedef AudioFrames_2 AudioFrames;
@@ skipping 41 matching lines @@
 //
 // After decryption, the decrypted bytes should be copied over the position
 // of the corresponding cipher bytes in the original buffer to form the output
 // buffer. Following the above example, the decrypted buffer should be:
 //
 // |<----- subsample1 ----->|<----- subsample2 ----->|<----- subsample3 ----->|
 // |   clear1   | decrypted1|  clear2  |  decrypted2 | clear3 |   decrypted3  |
 //
 // TODO(xhwang): Add checks to make sure these structs have fixed layout.
 struct SubsampleEntry {
-  SubsampleEntry(int32_t clear_bytes, int32_t cipher_bytes)
+  SubsampleEntry(uint32_t clear_bytes, uint32_t cipher_bytes)
       : clear_bytes(clear_bytes), cipher_bytes(cipher_bytes) {}
 
-  int32_t clear_bytes;
-  int32_t cipher_bytes;
+  uint32_t clear_bytes;
+  uint32_t cipher_bytes;
 };
 
 // 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),
         subsamples(NULL),
         num_subsamples(0),
         timestamp(0) {}
 
   const uint8_t* data;  // Pointer to the beginning of the input data.
-  int32_t data_size;  // Size (in bytes) of |data|.
+  uint32_t data_size;  // Size (in bytes) of |data|.
 
-  int32_t data_offset;  // Number of bytes to be discarded before decryption.
+  uint32_t data_offset;  // Number of bytes to be discarded before decryption.
 
   const uint8_t* key_id;  // Key ID to identify the decryption key.
-  int32_t key_id_size;  // Size (in bytes) of |key_id|.
+  uint32_t key_id_size;  // Size (in bytes) of |key_id|.
 
   const uint8_t* iv;  // Initialization vector.
-  int32_t iv_size;  // Size (in bytes) of |iv|.
+  uint32_t iv_size;  // Size (in bytes) of |iv|.
 
   const struct SubsampleEntry* subsamples;
-  int32_t num_subsamples;  // Number of subsamples in |subsamples|.
+  uint32_t num_subsamples;  // Number of subsamples in |subsamples|.
 
   int64_t timestamp;  // Presentation timestamp in microseconds.
 };
 
 struct AudioDecoderConfig {
   enum AudioCodec {
     kUnknownAudioCodec = 0,
     kCodecVorbis,
     kCodecAac
   };
 
   AudioDecoderConfig()
       : codec(kUnknownAudioCodec),
         channel_count(0),
         bits_per_channel(0),
         samples_per_second(0),
         extra_data(NULL),
         extra_data_size(0) {}
 
   AudioCodec codec;
   int32_t channel_count;
   int32_t bits_per_channel;
   int32_t samples_per_second;
 
   // Optional byte data required to initialize audio decoders, such as the
   // vorbis setup header.
   uint8_t* extra_data;
-  int32_t extra_data_size;
+  uint32_t extra_data_size;
 };
 
 // Supported sample formats for AudioFrames.
 enum AudioFormat {
   kUnknownAudioFormat = 0,  // Unknown format value. Used for error reporting.
   kAudioFormatU8,  // Interleaved unsigned 8-bit w/ bias of 128.
   kAudioFormatS16,  // Interleaved signed 16-bit.
   kAudioFormatS32,  // Interleaved signed 32-bit.
   kAudioFormatF32,  // Interleaved float 32-bit.
   kAudioFormatPlanarS16,  // Signed 16-bit planar.
@@ skipping 45 matching lines @@
   VideoCodecProfile profile;
   VideoFormat format;
 
   // Width and height of video frame immediately post-decode. Not all pixels
   // in this region are valid.
   Size coded_size;
 
   // Optional byte data required to initialize video decoders, such as H.264
   // AAVC data.
   uint8_t* extra_data;
-  int32_t extra_data_size;
+  uint32_t extra_data_size;
 };
 
 enum StreamType {
   kStreamTypeAudio = 0,
   kStreamTypeVideo = 1
 };
 
 // Structure provided to ContentDecryptionModule::OnPlatformChallengeResponse()
 // after a platform challenge was initiated via Host::SendPlatformChallenge().
 // All values will be NULL / zero in the event of a challenge failure.
 struct PlatformChallengeResponse {
   // |challenge| provided during Host::SendPlatformChallenge() combined with
   // nonce data and signed with the platform's private key.
   const uint8_t* signed_data;
-  int32_t signed_data_length;
+  uint32_t signed_data_length;
 
   // RSASSA-PKCS1-v1_5-SHA256 signature of the |signed_data| block.
   const uint8_t* signed_data_signature;
-  int32_t signed_data_signature_length;
+  uint32_t signed_data_signature_length;
 
   // X.509 device specific certificate for the |service_id| requested.
   const uint8_t* platform_key_certificate;
-  int32_t platform_key_certificate_length;
+  uint32_t platform_key_certificate_length;
 };
 
 // Supported output protection methods for use with EnableOutputProtection() and
 // returned by OnQueryOutputProtectionStatus().
 enum OutputProtectionMethods {
   kProtectionNone = 0,
   kProtectionHDCP = 1 << 0
 };
 
 // Connected output link types returned by OnQueryOutputProtectionStatus().
@@ skipping 26 matching lines @@
   static const int kVersion = kCdmInterfaceVersion_1;
   typedef Host_1 Host;
 
   // Generates a |key_request| given |type| and |init_data|.
   //
   // Returns kSuccess if the key request was successfully generated, in which
   // case the CDM must send the key message by calling Host::SendKeyMessage().
   // Returns kSessionError if any error happened, in which case the CDM must
   // send a key error by calling Host::SendKeyError().
   virtual Status GenerateKeyRequest(
-      const char* type, int type_size,
-      const uint8_t* init_data, int init_data_size) = 0;
+      const char* type, uint32_t type_size,
+      const uint8_t* init_data, uint32_t init_data_size) = 0;
 
   // Adds the |key| to the CDM to be associated with |key_id|.
   //
   // Returns kSuccess if the key was successfully added, kSessionError
   // 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;
+  virtual Status AddKey(const char* session_id, uint32_t session_id_size,
+                        const uint8_t* key, uint32_t key_size,
+                        const uint8_t* key_id, uint32_t key_id_size) = 0;
 
   // Cancels any pending key request made to the CDM for |session_id|.
   //
   // Returns kSuccess if all pending key requests for |session_id| were
   // successfully canceled or there was no key request to be canceled,
   // kSessionError otherwise.
   virtual Status CancelKeyRequest(
-      const char* session_id, int session_id_size) = 0;
+      const char* session_id, uint32_t session_id_size) = 0;
 
   // Performs scheduled operation with |context| when the timer fires.
   virtual void TimerExpired(void* context) = 0;
 
   // Decrypts the |encrypted_buffer|.
   //
   // Returns kSuccess if decryption succeeded, in which case the callee
   // should have filled the |decrypted_buffer| and passed the ownership of
   // |data| in |decrypted_buffer| to the caller.
   // Returns kNoKey if the CDM did not have the necessary decryption key
@@ skipping 94 matching lines @@
   static const int kVersion = kCdmInterfaceVersion_2;
   typedef Host_2 Host;
 
   // Generates a |key_request| given |type| and |init_data|.
   //
   // Returns kSuccess if the key request was successfully generated, in which
   // case the CDM must send the key message by calling Host::SendKeyMessage().
   // Returns kSessionError if any error happened, in which case the CDM must
   // send a key error by calling Host::SendKeyError().
   virtual Status GenerateKeyRequest(
-      const char* type, int type_size,
-      const uint8_t* init_data, int init_data_size) = 0;
+      const char* type, uint32_t type_size,
+      const uint8_t* init_data, uint32_t init_data_size) = 0;
 
   // Adds the |key| to the CDM to be associated with |key_id|.
   //
   // Returns kSuccess if the key was successfully added, kSessionError
   // 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;
+  virtual Status AddKey(const char* session_id, uint32_t session_id_size,
+                        const uint8_t* key, uint32_t key_size,
+                        const uint8_t* key_id, uint32_t key_id_size) = 0;
 
   // Cancels any pending key request made to the CDM for |session_id|.
   //
   // Returns kSuccess if all pending key requests for |session_id| were
   // successfully canceled or there was no key request to be canceled,
   // kSessionError otherwise.
   virtual Status CancelKeyRequest(
-      const char* session_id, int session_id_size) = 0;
+      const char* session_id, uint32_t session_id_size) = 0;
 
   // Performs scheduled operation with |context| when the timer fires.
   virtual void TimerExpired(void* context) = 0;
 
   // Decrypts the |encrypted_buffer|.
   //
   // Returns kSuccess if decryption succeeded, in which case the callee
   // should have filled the |decrypted_buffer| and passed the ownership of
   // |data| in |decrypted_buffer| to the caller.
   // Returns kNoKey if the CDM did not have the necessary decryption key
@@ skipping 105 matching lines @@
 
 typedef ContentDecryptionModule_2 ContentDecryptionModule;
 const int kCdmInterfaceVersion = ContentDecryptionModule::kVersion;
 
 // Represents a buffer created by Allocator implementations.
 class Buffer {
  public:
   // Destroys the buffer in the same context as it was created.
   virtual void Destroy() = 0;
 
-  virtual int32_t Capacity() const = 0;
+  virtual uint32_t Capacity() const = 0;
   virtual uint8_t* Data() = 0;
-  virtual void SetSize(int32_t size) = 0;
-  virtual int32_t Size() const = 0;
+  virtual void SetSize(uint32_t size) = 0;
+  virtual uint32_t Size() const = 0;
 
  protected:
   Buffer() {}
   virtual ~Buffer() {}
 
  private:
   Buffer(const Buffer&);
   void operator=(const Buffer&);
 };
 
 // Deprecated.
 // Remove after CDMs start to use ContentDecryptionModule*::Host::kVersion.
 const int kHostInterfaceVersion_1 = 1;
 const int kHostInterfaceVersion_2 = 2;
 
 // Host interface that the CDM can call into to access browser side services.
 // Host interfaces are versioned for backward compatibility. CDM should use
 // HostFactory object to request a Host interface of a particular version.
 class Host_1 {
  public:
   static const int kVersion = kHostInterfaceVersion_1;
 
   // Returns a Buffer* containing non-zero members upon success, or NULL on
   // failure. The caller owns the Buffer* after this call. The buffer is not
   // guaranteed to be zero initialized. The capacity of the allocated Buffer
   // is guaranteed to be not less than |capacity|.
-  virtual Buffer* Allocate(int32_t capacity) = 0;
+  virtual Buffer* Allocate(uint32_t capacity) = 0;
 
   // Requests the host to call ContentDecryptionModule::TimerFired() |delay_ms|
   // from now with |context|.
   virtual void SetTimer(int64_t delay_ms, void* context) = 0;
 
   // Returns the current epoch wall time in seconds.
   virtual double GetCurrentWallTimeInSeconds() = 0;
 
   // Sends a keymessage event to the application.
   // Length parameters should not include null termination.
   virtual void SendKeyMessage(
-      const char* session_id, int32_t session_id_length,
-      const char* message, int32_t message_length,
-      const char* default_url, int32_t default_url_length) = 0;
+      const char* session_id, uint32_t session_id_length,
+      const char* message, uint32_t message_length,
+      const char* default_url, uint32_t default_url_length) = 0;
 
   // Sends a keyerror event to the application.
   // |session_id_length| should not include null termination.
   virtual void SendKeyError(const char* session_id,
-                            int32_t session_id_length,
+                            uint32_t session_id_length,
                             MediaKeyError error_code,
                             uint32_t system_code) = 0;
 
   // Get private data from the host. This function is limited to internal use.
   typedef const void* (*GetPrivateInterface)(const char* interface_name);
   virtual void GetPrivateData(int32_t* instance,
                               GetPrivateInterface* get_interface) = 0;
 
  protected:
   Host_1() {}
   virtual ~Host_1() {}
 };
 
 class Host_2 {
  public:
   static const int kVersion = kHostInterfaceVersion_2;
 
   // Returns a Buffer* containing non-zero members upon success, or NULL on
   // failure. The caller owns the Buffer* after this call. The buffer is not
   // guaranteed to be zero initialized. The capacity of the allocated Buffer
   // is guaranteed to be not less than |capacity|.
-  virtual Buffer* Allocate(int32_t capacity) = 0;
+  virtual Buffer* Allocate(uint32_t capacity) = 0;
 
   // Requests the host to call ContentDecryptionModule::TimerFired() |delay_ms|
   // from now with |context|.
   virtual void SetTimer(int64_t delay_ms, void* context) = 0;
 
   // Returns the current epoch wall time in seconds.
   virtual double GetCurrentWallTimeInSeconds() = 0;
 
   // Sends a keymessage event to the application.
   // Length parameters should not include null termination.
   virtual void SendKeyMessage(
-      const char* session_id, int32_t session_id_length,
-      const char* message, int32_t message_length,
-      const char* default_url, int32_t default_url_length) = 0;
+      const char* session_id, uint32_t session_id_length,
+      const char* message, uint32_t message_length,
+      const char* default_url, uint32_t default_url_length) = 0;
 
   // Sends a keyerror event to the application.
   // |session_id_length| should not include null termination.
   virtual void SendKeyError(const char* session_id,
-                            int32_t session_id_length,
+                            uint32_t session_id_length,
                             MediaKeyError error_code,
                             uint32_t system_code) = 0;
 
   // Get private data from the host. This function is limited to internal use.
   virtual void GetPrivateData(int32_t* instance,
                               Host_1::GetPrivateInterface* get_interface) = 0;
 
   // Sends a platform challenge for the given |service_id|. |challenge| is at
   // most 256 bits of data to be signed. Once the challenge has been completed,
   // the host will call ContentDecryptionModule::OnPlatformChallengeResponse()
   // with the signed challenge response and platform certificate. Length
   // parameters should not include null termination.
   virtual void SendPlatformChallenge(
-      const char* service_id, int32_t service_id_length,
-      const char* challenge, int32_t challenge_length) = 0;
+      const char* service_id, uint32_t service_id_length,
+      const char* challenge, uint32_t challenge_length) = 0;
 
   // Attempts to enable output protection (e.g. HDCP) on the display link. The
   // |desired_protection_mask| is a bit mask of OutputProtectionMethods. No
   // status callback is issued, the CDM must call QueryOutputProtectionStatus()
   // periodically to ensure the desired protections are applied.
   virtual void EnableOutputProtection(uint32_t desired_protection_mask) = 0;
 
   // Requests the current output protection status. Once the host has the status
   // it will call ContentDecryptionModule::OnQueryOutputProtectionStatus().
   virtual void QueryOutputProtectionStatus() = 0;
@@ skipping 40 matching lines @@
 
   virtual void SetFormat(VideoFormat format) = 0;
   virtual VideoFormat Format() const = 0;
 
   virtual void SetSize(cdm::Size size) = 0;
   virtual cdm::Size Size() const = 0;
 
   virtual void SetFrameBuffer(Buffer* frame_buffer) = 0;
   virtual Buffer* FrameBuffer() = 0;
 
-  virtual void SetPlaneOffset(VideoPlane plane, int32_t offset) = 0;
-  virtual int32_t PlaneOffset(VideoPlane plane) = 0;
+  virtual void SetPlaneOffset(VideoPlane plane, uint32_t offset) = 0;
+  virtual uint32_t PlaneOffset(VideoPlane plane) = 0;
 
-  virtual void SetStride(VideoPlane plane, int32_t stride) = 0;
-  virtual int32_t Stride(VideoPlane plane) = 0;
+  virtual void SetStride(VideoPlane plane, uint32_t stride) = 0;
+  virtual uint32_t Stride(VideoPlane plane) = 0;
 
   virtual void SetTimestamp(int64_t timestamp) = 0;
   virtual int64_t Timestamp() const = 0;
 
  protected:
   VideoFrame() {}
   virtual ~VideoFrame() {}
 };
 
 //
@@ skipping 34 matching lines @@
   virtual AudioFormat Format() const = 0;
 
  protected:
   AudioFrames_2() {}
   virtual ~AudioFrames_2() {}
 };
 
 }  // namespace cdm
 
 #endif  // CDM_CONTENT_DECRYPTION_MODULE_H_