media: Use new wrapper types for media mojo interfaces

media/mojo/clients/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/clients/mojo_cdm.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 122 matching lines @@
                                 "Mojo CDM creation failed.");
   pending_init_promise_.reset();
 }
 
 void MojoCdm::SetServerCertificate(const std::vector<uint8_t>& certificate,
                                    std::unique_ptr<SimpleCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_cdm_->SetServerCertificate(
-      mojo::Array<uint8_t>::From(certificate),
-      base::Bind(&MojoCdm::OnPromiseResult<>, base::Unretained(this),
-                 base::Passed(&promise)));
+      certificate, base::Bind(&MojoCdm::OnSimpleCdmPromiseResult,
+                              base::Unretained(this), base::Passed(&promise)));
 }
 
 void MojoCdm::CreateSessionAndGenerateRequest(
     SessionType session_type,
     EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
     std::unique_ptr<NewSessionCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_cdm_->CreateSessionAndGenerateRequest(
       static_cast<mojom::ContentDecryptionModule::SessionType>(session_type),
       static_cast<mojom::ContentDecryptionModule::InitDataType>(init_data_type),
-      mojo::Array<uint8_t>::From(init_data),
-      base::Bind(&MojoCdm::OnPromiseResult<std::string>, base::Unretained(this),
-                 base::Passed(&promise)));
+      init_data, base::Bind(&MojoCdm::OnNewSessionCdmPromiseResult,
+                            base::Unretained(this), base::Passed(&promise)));
 }
 
 void MojoCdm::LoadSession(SessionType session_type,
                           const std::string& session_id,
                           std::unique_ptr<NewSessionCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_cdm_->LoadSession(
       static_cast<mojom::ContentDecryptionModule::SessionType>(session_type),
-      session_id, base::Bind(&MojoCdm::OnPromiseResult<std::string>,
+      session_id, base::Bind(&MojoCdm::OnNewSessionCdmPromiseResult,
                              base::Unretained(this), base::Passed(&promise)));
 }
 
 void MojoCdm::UpdateSession(const std::string& session_id,
                             const std::vector<uint8_t>& response,
                             std::unique_ptr<SimpleCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_cdm_->UpdateSession(
-      session_id, mojo::Array<uint8_t>::From(response),
-      base::Bind(&MojoCdm::OnPromiseResult<>, base::Unretained(this),
+      session_id, response,
+      base::Bind(&MojoCdm::OnSimpleCdmPromiseResult, base::Unretained(this),
                  base::Passed(&promise)));
 }
 
 void MojoCdm::CloseSession(const std::string& session_id,
                            std::unique_ptr<SimpleCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_cdm_->CloseSession(
-      session_id, base::Bind(&MojoCdm::OnPromiseResult<>,
+      session_id, base::Bind(&MojoCdm::OnSimpleCdmPromiseResult,
                              base::Unretained(this), base::Passed(&promise)));
 }
 
 void MojoCdm::RemoveSession(const std::string& session_id,
                             std::unique_ptr<SimpleCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_cdm_->RemoveSession(
-      session_id, base::Bind(&MojoCdm::OnPromiseResult<>,
+      session_id, base::Bind(&MojoCdm::OnSimpleCdmPromiseResult,
                              base::Unretained(this), base::Passed(&promise)));
 }
 
 CdmContext* MojoCdm::GetCdmContext() {
   DVLOG(2) << __FUNCTION__;
   return this;
 }
 
 media::Decryptor* MojoCdm::GetDecryptor() {
   base::AutoLock auto_lock(lock_);
@@ skipping 14 matching lines @@
   return decryptor_.get();
 }
 
 int MojoCdm::GetCdmId() const {
   base::AutoLock auto_lock(lock_);
   // Can be called on a different thread.
   DCHECK_NE(CdmContext::kInvalidCdmId, cdm_id_);
   return cdm_id_;
 }
 
-void MojoCdm::OnSessionMessage(const mojo::String& session_id,
+void MojoCdm::OnSessionMessage(const std::string& session_id,
                                mojom::CdmMessageType message_type,
-                               mojo::Array<uint8_t> message) {
+                               const std::vector<uint8_t>& message) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  session_message_cb_.Run(session_id,
-                          static_cast<MediaKeys::MessageType>(message_type),
-                          message.storage());
+  session_message_cb_.Run(
+      session_id, static_cast<MediaKeys::MessageType>(message_type), message);
 }
 
-void MojoCdm::OnSessionClosed(const mojo::String& session_id) {
+void MojoCdm::OnSessionClosed(const std::string& session_id) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   session_closed_cb_.Run(session_id);
 }
 
 void MojoCdm::OnSessionKeysChange(
-    const mojo::String& session_id,
+    const std::string& session_id,
     bool has_additional_usable_key,
-    mojo::Array<mojom::CdmKeyInformationPtr> keys_info) {
+    std::vector<mojom::CdmKeyInformationPtr> keys_info) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(jrummell): Handling resume playback should be done in the media
   // player, not in the Decryptors. http://crbug.com/413413.
   if (has_additional_usable_key) {
     base::AutoLock auto_lock(lock_);
     if (decryptor_) {
       DCHECK(decryptor_task_runner_);
       decryptor_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&MojoCdm::OnKeyAdded, weak_factory_.GetWeakPtr()));
     }
   }
 
   media::CdmKeysInfo key_data;
   key_data.reserve(keys_info.size());
   for (size_t i = 0; i < keys_info.size(); ++i) {
     key_data.push_back(
         keys_info[i].To<std::unique_ptr<media::CdmKeyInformation>>().release());
   }
   session_keys_change_cb_.Run(session_id, has_additional_usable_key,
                               std::move(key_data));
 }
 
-void MojoCdm::OnSessionExpirationUpdate(const mojo::String& session_id,
+void MojoCdm::OnSessionExpirationUpdate(const std::string& session_id,
                                         double new_expiry_time_sec) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   session_expiration_update_cb_.Run(
       session_id, base::Time::FromDoubleT(new_expiry_time_sec));
 }
 
 void MojoCdm::OnCdmInitialized(mojom::CdmPromiseResultPtr result,
                                int cdm_id,
@@ skipping 21 matching lines @@
 void MojoCdm::OnKeyAdded() {
   base::AutoLock auto_lock(lock_);
 
   DCHECK(decryptor_task_runner_);
   DCHECK(decryptor_task_runner_->BelongsToCurrentThread());
   DCHECK(decryptor_);
 
   decryptor_->OnKeyAdded();
 }
 
+void MojoCdm::OnSimpleCdmPromiseResult(
+    std::unique_ptr<SimpleCdmPromise> promise,
+    mojom::CdmPromiseResultPtr result) {
+  if (result->success)
+    promise->resolve();
+  else
+    RejectPromise(std::move(promise), std::move(result));
+}
+
+void MojoCdm::OnNewSessionCdmPromiseResult(
+    std::unique_ptr<NewSessionCdmPromise> promise,
+    mojom::CdmPromiseResultPtr result,
+    const std::string& session_id) {
+  if (result->success)
+    promise->resolve(session_id);
+  else
+    RejectPromise(std::move(promise), std::move(result));
+}
+
 }  // namespace media