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

media/mojo/services/mojo_cdm.cc

 // Copyright 2014 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 "media/mojo/services/mojo_cdm.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
 #include "media/mojo/services/media_type_converters.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/connect.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/interface_impl.h"
 #include "third_party/mojo/src/mojo/public/interfaces/application/service_provider.mojom.h"
 #include "url/gurl.h"
 
 namespace media {
 
-static mojo::Array<uint8_t> CreateMojoArray(const uint8_t* data, int length) {
-  DCHECK(data);
-  DCHECK_GT(length, 0);
-  std::vector<uint8_t> vector(data, data + length);
-  mojo::Array<uint8_t> array;
-  array.Swap(&vector);
-  return array.Pass();
-}
-
 template <typename PromiseType>
 static void RejectPromise(scoped_ptr<PromiseType> promise,
                           mojo::CdmPromiseResultPtr result) {
   promise->reject(static_cast<MediaKeys::Exception>(result->exception),
                   result->system_code, result->error_message);
 }
 
 MojoCdm::MojoCdm(mojo::ContentDecryptionModulePtr remote_cdm,
                  const SessionMessageCB& session_message_cb,
                  const SessionClosedCB& session_closed_cb,
@@ skipping 17 matching lines @@
 
   mojo::ContentDecryptionModuleClientPtr client_ptr;
   binding_.Bind(GetProxy(&client_ptr));
   remote_cdm_->SetClient(client_ptr.Pass());
 }
 
 MojoCdm::~MojoCdm() {
   DVLOG(1) << __FUNCTION__;
 }
 
-void MojoCdm::SetServerCertificate(const uint8_t* certificate_data,
-                                   int certificate_data_length,
+void MojoCdm::SetServerCertificate(const std::vector<uint8_t>& certificate,
                                    scoped_ptr<SimpleCdmPromise> promise) {
   remote_cdm_->SetServerCertificate(
-      CreateMojoArray(certificate_data, certificate_data_length),
+      mojo::Array<uint8_t>::From(certificate),
       base::Bind(&MojoCdm::OnPromiseResult<>, weak_factory_.GetWeakPtr(),
                  base::Passed(&promise)));
 }
 
 void MojoCdm::CreateSessionAndGenerateRequest(
     SessionType session_type,
     EmeInitDataType init_data_type,
-    const uint8_t* init_data,
-    int init_data_length,
+    const std::vector<uint8_t>& init_data,
     scoped_ptr<NewSessionCdmPromise> promise) {
   remote_cdm_->CreateSessionAndGenerateRequest(
       static_cast<mojo::ContentDecryptionModule::SessionType>(session_type),
       static_cast<mojo::ContentDecryptionModule::InitDataType>(init_data_type),
-      CreateMojoArray(init_data, init_data_length),
+      mojo::Array<uint8_t>::From(init_data),
       base::Bind(&MojoCdm::OnPromiseResult<std::string>,
                  weak_factory_.GetWeakPtr(), base::Passed(&promise)));
 }
 
 void MojoCdm::LoadSession(SessionType session_type,
                           const std::string& session_id,
                           scoped_ptr<NewSessionCdmPromise> promise) {
   remote_cdm_->LoadSession(
       static_cast<mojo::ContentDecryptionModule::SessionType>(session_type),
       session_id,
       base::Bind(&MojoCdm::OnPromiseResult<std::string>,
                  weak_factory_.GetWeakPtr(), base::Passed(&promise)));
 }
 
 void MojoCdm::UpdateSession(const std::string& session_id,
-                            const uint8_t* response,
-                            int response_length,
+                            const std::vector<uint8_t>& response,
                             scoped_ptr<SimpleCdmPromise> promise) {
   remote_cdm_->UpdateSession(
-      session_id, CreateMojoArray(response, response_length),
+      session_id, mojo::Array<uint8_t>::From(response),
       base::Bind(&MojoCdm::OnPromiseResult<>, weak_factory_.GetWeakPtr(),
                  base::Passed(&promise)));
 }
 
 void MojoCdm::CloseSession(const std::string& session_id,
                            scoped_ptr<SimpleCdmPromise> promise) {
   remote_cdm_->CloseSession(session_id, base::Bind(&MojoCdm::OnPromiseResult<>,
                                                    weak_factory_.GetWeakPtr(),
                                                    base::Passed(&promise)));
 }
@@ skipping 53 matching lines @@
                               key_data.Pass());
 }
 
 void MojoCdm::OnSessionExpirationUpdate(const mojo::String& session_id,
                                         double new_expiry_time_sec) {
   session_expiration_update_cb_.Run(
       session_id, base::Time::FromDoubleT(new_expiry_time_sec));
 }
 
 }  // namespace media