Use std::vector<uint8_t> instead of uint8*/int for MediaKeys interface

media/base/media_keys.h

 // Copyright 2013 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 MEDIA_BASE_MEDIA_KEYS_H_
 #define MEDIA_BASE_MEDIA_KEYS_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 71 matching lines @@
     LICENSE_REQUEST,
     LICENSE_RENEWAL,
     LICENSE_RELEASE,
     MESSAGE_TYPE_MAX = LICENSE_RELEASE
   };
 
   virtual ~MediaKeys();
 
   // Provides a server certificate to be used to encrypt messages to the
   // license server.
-  virtual void SetServerCertificate(const uint8* certificate_data,
-                                    int certificate_data_length,
+  virtual void SetServerCertificate(const std::vector<uint8>& certificate,
                                     scoped_ptr<SimpleCdmPromise> promise) = 0;
 
   // Creates a session with |session_type|. Then generates a request with the
   // |init_data_type| and |init_data|.
   // Note:
   // 1. The session ID will be provided when the |promise| is resolved.
   // 2. The generated request should be returned through a SessionMessageCB,
   //    which must be AFTER the |promise| is resolved. Otherwise, the session ID
   //    in the callback will not be recognized.
   // 3. UpdateSession(), CloseSession() and RemoveSession() should only be
   //    called after the |promise| is resolved.
   virtual void CreateSessionAndGenerateRequest(
       SessionType session_type,
       EmeInitDataType init_data_type,
-      const uint8* init_data,
-      int init_data_length,
+      const std::vector<uint8>& init_data,
       scoped_ptr<NewSessionCdmPromise> promise) = 0;
 
   // Loads a session with the |session_id| provided.
   // Note: UpdateSession(), CloseSession() and RemoveSession() should only be
   //       called after the |promise| is resolved.
   virtual void LoadSession(SessionType session_type,
                            const std::string& session_id,
                            scoped_ptr<NewSessionCdmPromise> promise) = 0;
 
   // Updates a session specified by |session_id| with |response|.
   virtual void UpdateSession(const std::string& session_id,
-                             const uint8* response,
-                             int response_length,
+                             const std::vector<uint8>& response,
                              scoped_ptr<SimpleCdmPromise> promise) = 0;
 
   // Closes the session specified by |session_id|. The CDM should resolve or
   // reject the |promise| when the call has been processed. This may be before
   // the session is closed. Once the session is closed, a SessionClosedCB must
   // also be called.
   virtual void CloseSession(const std::string& session_id,
                             scoped_ptr<SimpleCdmPromise> promise) = 0;
 
   // Removes stored session data associated with the session specified by
@@ skipping 11 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MediaKeys);
 };
 
 // Key event callbacks. See the spec for details:
 // https://dvcs.w3.org/hg/html-media/raw-file/default/encrypted-media/encrypted-media.html#event-summary
 
 typedef base::Callback<void(const std::string& session_id,
                             MediaKeys::MessageType message_type,
                             const std::vector<uint8>& message,

[xhwang, 2015/04/21 04:47:11]

use uint8_t here as well

[jrummell, 2015/04/21 22:59:36]

Done.

                             const GURL& legacy_destination_url)>
     SessionMessageCB;
 
 // Called when the session specified by |session_id| is closed. Note that the
 // CDM may close a session at any point, such as in response to a CloseSession()
 // call, when the session is no longer needed, or when system resources are
 // lost. See for details: http://w3c.github.io/encrypted-media/#session-close
 typedef base::Callback<void(const std::string& session_id)> SessionClosedCB;
 
 typedef base::Callback<void(const std::string& session_id,
                             MediaKeys::Exception exception,
                             uint32 system_code,
                             const std::string& error_message)>
     LegacySessionErrorCB;
 
 typedef base::Callback<void(const std::string& session_id,
                             bool has_additional_usable_key,
                             CdmKeysInfo keys_info)> SessionKeysChangeCB;
 
 typedef base::Callback<void(const std::string& session_id,
                             const base::Time& new_expiry_time)>
     SessionExpirationUpdateCB;
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_MEDIA_KEYS_H_