media/mojo/services/mojo_cdm_service.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/mojo/services/mojo_cdm_service.h"
   6
   7 #include "base/bind.h"
   8 #include "media/base/cdm_key_information.h"
   9 #include "media/base/key_systems.h"
  10 #include "media/cdm/aes_decryptor.h"
  11 #include "media/mojo/services/media_type_converters.h"
  12 #include "media/mojo/services/mojo_cdm_promise.h"
  13 #include "mojo/common/common_type_converters.h"
  14
  15 namespace media {
  16
  17 typedef MojoCdmPromise<> SimpleMojoCdmPromise;
  18 typedef MojoCdmPromise<std::string> NewSessionMojoCdmPromise;
  19
  20 MojoCdmService::MojoCdmService(const mojo::String& key_system)
  21     : weak_factory_(this) {
  22   base::WeakPtr<MojoCdmService> weak_this = weak_factory_.GetWeakPtr();
  23   if (CanUseAesDecryptor(key_system)) {
  24     cdm_.reset(new AesDecryptor(
  25         base::Bind(&MojoCdmService::OnSessionMessage, weak_this),
  26         base::Bind(&MojoCdmService::OnSessionClosed, weak_this),
  27         base::Bind(&MojoCdmService::OnSessionKeysChange, weak_this)));
  28   }
  29
  30   // TODO(xhwang): Check key system support in the app.
  31   NOTREACHED();
  32 }
  33
  34 MojoCdmService::~MojoCdmService() {
  35 }
  36
  37 // mojo::MediaRenderer implementation.
  38 void MojoCdmService::SetServerCertificate(
  39     mojo::Array<uint8_t> certificate_data,
  40     const mojo::Callback<void(mojo::CdmPromiseResultPtr)>& callback) {
  41   const std::vector<uint8_t>& certificate_data_vector =
  42       certificate_data.storage();
  43   cdm_->SetServerCertificate(
  44       certificate_data_vector.empty() ? nullptr : &certificate_data_vector[0],
  45       certificate_data_vector.size(),
  46       scoped_ptr<SimpleCdmPromise>(new SimpleMojoCdmPromise(callback)));
  47 }
  48
  49 void MojoCdmService::CreateSessionAndGenerateRequest(
  50     mojo::ContentDecryptionModule::SessionType session_type,
  51     const mojo::String& init_data_type,
  52     mojo::Array<uint8_t> init_data,
  53     const mojo::Callback<void(mojo::CdmPromiseResultPtr, mojo::String)>&
  54         callback) {
  55   const std::vector<uint8_t>& init_data_vector = init_data.storage();
  56   cdm_->CreateSessionAndGenerateRequest(
  57       static_cast<MediaKeys::SessionType>(session_type),
  58       init_data_type.To<std::string>(),
  59       init_data_vector.empty() ? nullptr : &init_data_vector[0],
  60       init_data_vector.size(),
  61       scoped_ptr<NewSessionCdmPromise>(new NewSessionMojoCdmPromise(callback)));
  62 }
  63
  64 void MojoCdmService::LoadSession(
  65     mojo::ContentDecryptionModule::SessionType session_type,
  66     const mojo::String& session_id,
  67     const mojo::Callback<void(mojo::CdmPromiseResultPtr, mojo::String)>&
  68         callback) {
  69   cdm_->LoadSession(
  70       static_cast<MediaKeys::SessionType>(session_type),
  71       session_id.To<std::string>(),
  72       scoped_ptr<NewSessionCdmPromise>(new NewSessionMojoCdmPromise(callback)));
  73 }
  74
  75 void MojoCdmService::UpdateSession(
  76     const mojo::String& session_id,
  77     mojo::Array<uint8_t> response,
  78     const mojo::Callback<void(mojo::CdmPromiseResultPtr)>& callback) {
  79   const std::vector<uint8_t>& response_vector = response.storage();
  80   cdm_->UpdateSession(
  81       session_id.To<std::string>(),
  82       response_vector.empty() ? nullptr : &response_vector[0],
  83       response_vector.size(),
  84       scoped_ptr<SimpleCdmPromise>(new SimpleMojoCdmPromise(callback)));
  85 }
  86
  87 void MojoCdmService::CloseSession(
  88     const mojo::String& session_id,
  89     const mojo::Callback<void(mojo::CdmPromiseResultPtr)>& callback) {
  90   cdm_->CloseSession(
  91       session_id.To<std::string>(),
  92       scoped_ptr<SimpleCdmPromise>(new SimpleMojoCdmPromise(callback)));
  93 }
  94
  95 void MojoCdmService::RemoveSession(
  96     const mojo::String& session_id,
  97     const mojo::Callback<void(mojo::CdmPromiseResultPtr)>& callback) {
  98   cdm_->RemoveSession(
  99       session_id.To<std::string>(),
 100       scoped_ptr<SimpleCdmPromise>(new SimpleMojoCdmPromise(callback)));
 101 }
 102
 103 void MojoCdmService::GetCdmContext(
 104     int32_t cdm_id,
 105     mojo::InterfaceRequest<mojo::Decryptor> decryptor) {
 106   NOTIMPLEMENTED();
 107 }
 108
 109 void MojoCdmService::OnSessionMessage(const std::string& session_id,
 110                                       MediaKeys::MessageType message_type,
 111                                       const std::vector<uint8_t>& message,
 112                                       const GURL& legacy_destination_url) {
 113   client()->OnSessionMessage(session_id,
 114                              static_cast<mojo::CdmMessageType>(message_type),
 115                              mojo::Array<uint8_t>::From(message),
 116                              mojo::String::From(legacy_destination_url));
 117 }
 118
 119 void MojoCdmService::OnSessionKeysChange(const std::string& session_id,
 120                                          bool has_additional_usable_key,
 121                                          CdmKeysInfo keys_info) {
 122   mojo::Array<mojo::CdmKeyInformationPtr> keys_data;
 123   for (const auto& key : keys_info)
 124     keys_data.push_back(mojo::CdmKeyInformation::From(*key));
 125   client()->OnSessionKeysChange(session_id, has_additional_usable_key,
 126                                 keys_data.Pass());
 127 }
 128
 129 void MojoCdmService::OnSessionExpirationUpdate(
 130     const std::string& session_id,
 131     const base::Time& new_expiry_time) {
 132   client()->OnSessionExpirationUpdate(session_id,
 133                                       new_expiry_time.ToInternalValue());
 134 }
 135
 136 void MojoCdmService::OnSessionClosed(const std::string& session_id) {
 137   client()->OnSessionClosed(session_id);
 138 }
 139
 140 void MojoCdmService::OnSessionError(const std::string& session_id,
 141                                     MediaKeys::Exception exception,
 142                                     uint32_t system_code,
 143                                     const std::string& error_message) {
 144   client()->OnSessionError(session_id,
 145                            static_cast<mojo::CdmException>(exception),
 146                            system_code, error_message);
 147 }
 148
 149 }  // namespace media