media/mojo/services/mojo_cdm.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.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "media/base/cdm_key_information.h"
  10 #include "media/base/cdm_promise.h"
  11 #include "media/mojo/services/media_type_converters.h"
  12 #include "third_party/mojo/src/mojo/public/cpp/application/connect.h"
  13 #include "third_party/mojo/src/mojo/public/cpp/bindings/interface_impl.h"
  14 #include "third_party/mojo/src/mojo/public/interfaces/application/service_provider.mojom.h"
  15 #include "url/gurl.h"
  16
  17 namespace media {
  18
  19 template <typename PromiseType>
  20 static void RejectPromise(scoped_ptr<PromiseType> promise,
  21                           mojo::CdmPromiseResultPtr result) {
  22   promise->reject(static_cast<MediaKeys::Exception>(result->exception),
  23                   result->system_code, result->error_message);
  24 }
  25
  26 MojoCdm::MojoCdm(mojo::ContentDecryptionModulePtr remote_cdm,
  27                  const SessionMessageCB& session_message_cb,
  28                  const SessionClosedCB& session_closed_cb,
  29                  const LegacySessionErrorCB& legacy_session_error_cb,
  30                  const SessionKeysChangeCB& session_keys_change_cb,
  31                  const SessionExpirationUpdateCB& session_expiration_update_cb)
  32     : remote_cdm_(remote_cdm.Pass()),
  33       binding_(this),
  34       session_message_cb_(session_message_cb),
  35       session_closed_cb_(session_closed_cb),
  36       legacy_session_error_cb_(legacy_session_error_cb),
  37       session_keys_change_cb_(session_keys_change_cb),
  38       session_expiration_update_cb_(session_expiration_update_cb),
  39       weak_factory_(this) {
  40   DVLOG(1) << __FUNCTION__;
  41   DCHECK(!session_message_cb_.is_null());
  42   DCHECK(!session_closed_cb_.is_null());
  43   DCHECK(!legacy_session_error_cb_.is_null());
  44   DCHECK(!session_keys_change_cb_.is_null());
  45   DCHECK(!session_expiration_update_cb_.is_null());
  46
  47   mojo::ContentDecryptionModuleClientPtr client_ptr;
  48   binding_.Bind(GetProxy(&client_ptr));
  49   remote_cdm_->SetClient(client_ptr.Pass());
  50 }
  51
  52 MojoCdm::~MojoCdm() {
  53   DVLOG(1) << __FUNCTION__;
  54 }
  55
  56 void MojoCdm::SetServerCertificate(const std::vector<uint8_t>& certificate,
  57                                    scoped_ptr<SimpleCdmPromise> promise) {
  58   remote_cdm_->SetServerCertificate(
  59       mojo::Array<uint8_t>::From(certificate),
  60       base::Bind(&MojoCdm::OnPromiseResult<>, weak_factory_.GetWeakPtr(),
  61                  base::Passed(&promise)));
  62 }
  63
  64 void MojoCdm::CreateSessionAndGenerateRequest(
  65     SessionType session_type,
  66     EmeInitDataType init_data_type,
  67     const std::vector<uint8_t>& init_data,
  68     scoped_ptr<NewSessionCdmPromise> promise) {
  69   remote_cdm_->CreateSessionAndGenerateRequest(
  70       static_cast<mojo::ContentDecryptionModule::SessionType>(session_type),
  71       static_cast<mojo::ContentDecryptionModule::InitDataType>(init_data_type),
  72       mojo::Array<uint8_t>::From(init_data),
  73       base::Bind(&MojoCdm::OnPromiseResult<std::string>,
  74                  weak_factory_.GetWeakPtr(), base::Passed(&promise)));
  75 }
  76
  77 void MojoCdm::LoadSession(SessionType session_type,
  78                           const std::string& session_id,
  79                           scoped_ptr<NewSessionCdmPromise> promise) {
  80   remote_cdm_->LoadSession(
  81       static_cast<mojo::ContentDecryptionModule::SessionType>(session_type),
  82       session_id,
  83       base::Bind(&MojoCdm::OnPromiseResult<std::string>,
  84                  weak_factory_.GetWeakPtr(), base::Passed(&promise)));
  85 }
  86
  87 void MojoCdm::UpdateSession(const std::string& session_id,
  88                             const std::vector<uint8_t>& response,
  89                             scoped_ptr<SimpleCdmPromise> promise) {
  90   remote_cdm_->UpdateSession(
  91       session_id, mojo::Array<uint8_t>::From(response),
  92       base::Bind(&MojoCdm::OnPromiseResult<>, weak_factory_.GetWeakPtr(),
  93                  base::Passed(&promise)));
  94 }
  95
  96 void MojoCdm::CloseSession(const std::string& session_id,
  97                            scoped_ptr<SimpleCdmPromise> promise) {
  98   remote_cdm_->CloseSession(session_id, base::Bind(&MojoCdm::OnPromiseResult<>,
  99                                                    weak_factory_.GetWeakPtr(),
 100                                                    base::Passed(&promise)));
 101 }
 102
 103 void MojoCdm::RemoveSession(const std::string& session_id,
 104                             scoped_ptr<SimpleCdmPromise> promise) {
 105   remote_cdm_->RemoveSession(session_id, base::Bind(&MojoCdm::OnPromiseResult<>,
 106                                                     weak_factory_.GetWeakPtr(),
 107                                                     base::Passed(&promise)));
 108 }
 109
 110 CdmContext* MojoCdm::GetCdmContext() {
 111   NOTIMPLEMENTED();
 112   return nullptr;
 113 }
 114
 115 void MojoCdm::OnSessionMessage(const mojo::String& session_id,
 116                                mojo::CdmMessageType message_type,
 117                                mojo::Array<uint8_t> message,
 118                                const mojo::String& legacy_destination_url) {
 119   GURL verified_gurl = GURL(legacy_destination_url);
 120   if (!verified_gurl.is_valid() && !verified_gurl.is_empty()) {
 121     DLOG(WARNING) << "SessionMessage destination_url is invalid : "
 122                   << verified_gurl.possibly_invalid_spec();
 123     verified_gurl = GURL::EmptyGURL();  // Replace invalid destination_url.
 124   }
 125
 126   session_message_cb_.Run(session_id,
 127                           static_cast<MediaKeys::MessageType>(message_type),
 128                           message.storage(), verified_gurl);
 129 }
 130
 131 void MojoCdm::OnSessionClosed(const mojo::String& session_id) {
 132   session_closed_cb_.Run(session_id);
 133 }
 134
 135 void MojoCdm::OnLegacySessionError(const mojo::String& session_id,
 136                                    mojo::CdmException exception,
 137                                    uint32_t system_code,
 138                                    const mojo::String& error_message) {
 139   legacy_session_error_cb_.Run(session_id,
 140                                static_cast<MediaKeys::Exception>(exception),
 141                                system_code, error_message);
 142 }
 143
 144 void MojoCdm::OnSessionKeysChange(
 145     const mojo::String& session_id,
 146     bool has_additional_usable_key,
 147     mojo::Array<mojo::CdmKeyInformationPtr> keys_info) {
 148   media::CdmKeysInfo key_data;
 149   key_data.reserve(keys_info.size());
 150   for (size_t i = 0; i < keys_info.size(); ++i) {
 151     key_data.push_back(
 152         keys_info[i].To<scoped_ptr<media::CdmKeyInformation>>().release());
 153   }
 154   session_keys_change_cb_.Run(session_id, has_additional_usable_key,
 155                               key_data.Pass());
 156 }
 157
 158 void MojoCdm::OnSessionExpirationUpdate(const mojo::String& session_id,
 159                                         double new_expiry_time_sec) {
 160   session_expiration_update_cb_.Run(
 161       session_id, base::Time::FromDoubleT(new_expiry_time_sec));
 162 }
 163
 164 }  // namespace media