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

content/renderer/media/crypto/ppapi_decryptor.cc

 // 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.
 
 #include "content/renderer/media/crypto/ppapi_decryptor.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 72 matching lines @@
       base::Bind(&PpapiDecryptor::OnSessionKeysChange, weak_this),
       base::Bind(&PpapiDecryptor::OnSessionExpirationUpdate, weak_this),
       base::Bind(&PpapiDecryptor::OnFatalPluginError, weak_this));
 }
 
 PpapiDecryptor::~PpapiDecryptor() {
   pepper_cdm_wrapper_.reset();
 }
 
 void PpapiDecryptor::SetServerCertificate(
-    const uint8* certificate_data,
-    int certificate_data_length,
+    const std::vector<uint8_t>& certificate,
     scoped_ptr<media::SimpleCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
     return;
   }
 
-  CdmDelegate()->SetServerCertificate(
-      certificate_data, certificate_data_length, promise.Pass());
+  CdmDelegate()->SetServerCertificate(certificate, promise.Pass());
 }
 
 void PpapiDecryptor::CreateSessionAndGenerateRequest(
     SessionType session_type,
     media::EmeInitDataType init_data_type,
-    const uint8* init_data,
-    int init_data_length,
+    const std::vector<uint8_t>& init_data,
     scoped_ptr<media::NewSessionCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
     return;
   }
 
   CdmDelegate()->CreateSessionAndGenerateRequest(session_type, init_data_type,
-                                                 init_data, init_data_length,
-                                                 promise.Pass());
+                                                 init_data, promise.Pass());
 }
 
 void PpapiDecryptor::LoadSession(
     SessionType session_type,
     const std::string& session_id,
     scoped_ptr<media::NewSessionCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
     return;
   }
   CdmDelegate()->LoadSession(session_type, session_id, promise.Pass());
 }
 
 void PpapiDecryptor::UpdateSession(
     const std::string& session_id,
-    const uint8* response,
-    int response_length,
+    const std::vector<uint8_t>& response,
     scoped_ptr<media::SimpleCdmPromise> promise) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
     return;
   }
-  CdmDelegate()->UpdateSession(session_id, response, response_length,
-                               promise.Pass());
+  CdmDelegate()->UpdateSession(session_id, response, promise.Pass());
 }
 
 void PpapiDecryptor::CloseSession(const std::string& session_id,
                                   scoped_ptr<media::SimpleCdmPromise> promise) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
     return;
   }
@@ skipping 222 matching lines @@
       DCHECK(!video_decoder_init_cb_.is_null());
       base::ResetAndReturn(&video_decoder_init_cb_).Run(success);
       break;
     default:
       NOTREACHED();
   }
 }
 
 void PpapiDecryptor::OnSessionMessage(const std::string& session_id,
                                       MessageType message_type,
-                                      const std::vector<uint8>& message,
+                                      const std::vector<uint8_t>& message,
                                       const GURL& legacy_destination_url) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   session_message_cb_.Run(session_id, message_type, message,
                           legacy_destination_url);
 }
 
 void PpapiDecryptor::OnSessionKeysChange(const std::string& session_id,
                                          bool has_additional_usable_key,
                                          media::CdmKeysInfo keys_info) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
@@ skipping 15 matching lines @@
 }
 
 void PpapiDecryptor::OnSessionClosed(const std::string& session_id) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   session_closed_cb_.Run(session_id);
 }
 
 void PpapiDecryptor::OnLegacySessionError(
     const std::string& session_id,
     MediaKeys::Exception exception_code,
-    uint32 system_code,
+    uint32_t system_code,
     const std::string& error_description) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   legacy_session_error_cb_.Run(session_id, exception_code, system_code,
                                error_description);
 }
 
 void PpapiDecryptor::AttemptToResumePlayback() {
   if (!new_audio_key_cb_.is_null())
     new_audio_key_cb_.Run();
 
   if (!new_video_key_cb_.is_null())
     new_video_key_cb_.Run();
 }
 
 void PpapiDecryptor::OnFatalPluginError() {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   pepper_cdm_wrapper_.reset();
 }
 
 ContentDecryptorDelegate* PpapiDecryptor::CdmDelegate() {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   return (pepper_cdm_wrapper_) ? pepper_cdm_wrapper_->GetCdmDelegate() : NULL;
 }
 
 }  // namespace content