media: Use new wrapper types for media mojo interfaces

media/mojo/services/mojo_cdm_service.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_service.h"
 
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 83 matching lines @@
   g_cdm_manager.Get().UnregisterCdm(cdm_id_);
 
   if (context_)
     context_->UnregisterCdm(cdm_id_);
 }
 
 void MojoCdmService::SetClient(mojom::ContentDecryptionModuleClientPtr client) {
   client_ = std::move(client);
 }
 
-void MojoCdmService::Initialize(const mojo::String& key_system,
-                                const mojo::String& security_origin,
+void MojoCdmService::Initialize(const std::string& key_system,
+                                const std::string& security_origin,
                                 mojom::CdmConfigPtr cdm_config,
                                 const InitializeCallback& callback) {
   DVLOG(1) << __FUNCTION__ << ": " << key_system;
   DCHECK(!cdm_);
 
   auto weak_this = weak_factory_.GetWeakPtr();
   cdm_factory_->Create(
-      key_system, GURL(security_origin.get()), cdm_config.To<CdmConfig>(),
+      key_system, GURL(security_origin), cdm_config.To<CdmConfig>(),
       base::Bind(&MojoCdmService::OnSessionMessage, weak_this),
       base::Bind(&MojoCdmService::OnSessionClosed, weak_this),
       base::Bind(&MojoCdmService::OnSessionKeysChange, weak_this),
       base::Bind(&MojoCdmService::OnSessionExpirationUpdate, weak_this),
       base::Bind(&MojoCdmService::OnCdmCreated, weak_this, callback));
 }
 
 void MojoCdmService::SetServerCertificate(
-    mojo::Array<uint8_t> certificate_data,
+    const std::vector<uint8_t>& certificate_data,
     const SetServerCertificateCallback& callback) {
   DVLOG(2) << __FUNCTION__;
-  cdm_->SetServerCertificate(certificate_data.storage(),
+  cdm_->SetServerCertificate(certificate_data,
                              base::MakeUnique<SimpleMojoCdmPromise>(callback));
 }
 
 void MojoCdmService::CreateSessionAndGenerateRequest(
     mojom::ContentDecryptionModule::SessionType session_type,
     mojom::ContentDecryptionModule::InitDataType init_data_type,
-    mojo::Array<uint8_t> init_data,
+    const std::vector<uint8_t>& init_data,
     const CreateSessionAndGenerateRequestCallback& callback) {
   DVLOG(2) << __FUNCTION__;
   cdm_->CreateSessionAndGenerateRequest(
       static_cast<MediaKeys::SessionType>(session_type),
-      static_cast<EmeInitDataType>(init_data_type), init_data.storage(),
+      static_cast<EmeInitDataType>(init_data_type), init_data,
       base::MakeUnique<NewSessionMojoCdmPromise>(callback));
 }
 
 void MojoCdmService::LoadSession(
     mojom::ContentDecryptionModule::SessionType session_type,
-    const mojo::String& session_id,
+    const std::string& session_id,
     const LoadSessionCallback& callback) {
   DVLOG(2) << __FUNCTION__;
   cdm_->LoadSession(static_cast<MediaKeys::SessionType>(session_type),
-                    session_id.To<std::string>(),
+                    session_id,
                     base::MakeUnique<NewSessionMojoCdmPromise>(callback));
 }
 
-void MojoCdmService::UpdateSession(const mojo::String& session_id,
-                                   mojo::Array<uint8_t> response,
+void MojoCdmService::UpdateSession(const std::string& session_id,
+                                   const std::vector<uint8_t>& response,
                                    const UpdateSessionCallback& callback) {
   DVLOG(2) << __FUNCTION__;
   cdm_->UpdateSession(
-      session_id.To<std::string>(), response.storage(),
+      session_id, response,
       std::unique_ptr<SimpleCdmPromise>(new SimpleMojoCdmPromise(callback)));
 }
 
-void MojoCdmService::CloseSession(const mojo::String& session_id,
+void MojoCdmService::CloseSession(const std::string& session_id,
                                   const CloseSessionCallback& callback) {
   DVLOG(2) << __FUNCTION__;
-  cdm_->CloseSession(session_id.To<std::string>(),
+  cdm_->CloseSession(session_id,
                      base::MakeUnique<SimpleMojoCdmPromise>(callback));
 }
 
-void MojoCdmService::RemoveSession(const mojo::String& session_id,
+void MojoCdmService::RemoveSession(const std::string& session_id,
                                    const RemoveSessionCallback& callback) {
   DVLOG(2) << __FUNCTION__;
-  cdm_->RemoveSession(session_id.To<std::string>(),
+  cdm_->RemoveSession(session_id,
                       base::MakeUnique<SimpleMojoCdmPromise>(callback));
 }
 
 scoped_refptr<MediaKeys> MojoCdmService::GetCdm() {
   return cdm_;
 }
 
 void MojoCdmService::OnCdmCreated(const InitializeCallback& callback,
                                   const scoped_refptr<MediaKeys>& cdm,
                                   const std::string& error_message) {
@@ skipping 31 matching lines @@
   DVLOG(1) << __FUNCTION__ << ": CDM successfully created with ID " << cdm_id_;
   cdm_promise_result->success = true;
   callback.Run(std::move(cdm_promise_result), cdm_id_,
                std::move(decryptor_service));
 }
 
 void MojoCdmService::OnSessionMessage(const std::string& session_id,
                                       MediaKeys::MessageType message_type,
                                       const std::vector<uint8_t>& message) {
   DVLOG(2) << __FUNCTION__ << "(" << message_type << ")";
-  client_->OnSessionMessage(session_id,
-                            static_cast<mojom::CdmMessageType>(message_type),
-                            mojo::Array<uint8_t>::From(message));
+  client_->OnSessionMessage(
+      session_id, static_cast<mojom::CdmMessageType>(message_type), message);
 }
 
 void MojoCdmService::OnSessionKeysChange(const std::string& session_id,
                                          bool has_additional_usable_key,
                                          CdmKeysInfo keys_info) {
   DVLOG(2) << __FUNCTION__
            << " has_additional_usable_key=" << has_additional_usable_key;
 
-  mojo::Array<mojom::CdmKeyInformationPtr> keys_data;
+  std::vector<mojom::CdmKeyInformationPtr> keys_data;
   for (auto* key : keys_info)
     keys_data.push_back(mojom::CdmKeyInformation::From(*key));
   client_->OnSessionKeysChange(session_id, has_additional_usable_key,
                                std::move(keys_data));
 }
 
 void MojoCdmService::OnSessionExpirationUpdate(
     const std::string& session_id,
     const base::Time& new_expiry_time_sec) {
   DVLOG(2) << __FUNCTION__ << " expiry=" << new_expiry_time_sec;
   client_->OnSessionExpirationUpdate(session_id,
                                      new_expiry_time_sec.ToDoubleT());
 }
 
 void MojoCdmService::OnSessionClosed(const std::string& session_id) {
   DVLOG(2) << __FUNCTION__;
   client_->OnSessionClosed(session_id);
 }
 
 void MojoCdmService::OnDecryptorConnectionError() {
   DVLOG(2) << __FUNCTION__;
 
   // MojoDecryptorService has lost connectivity to it's client, so it can be
   // freed.
   decryptor_.reset();
 }
 
 }  // namespace media