OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2013 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/base/android/media_drm_proxy.h" |
| 6 |
| 7 #include "base/bind.h" |
| 8 #include "base/thread_task_runner_handle.h" |
| 9 |
| 10 #include "media/base/android/media_codec_player.h" // for GetMediaTaskRunner() |
| 11 #include "media/base/android/media_drm_bridge.h" |
| 12 #include "media/base/cdm_key_information.h" |
| 13 |
| 14 #include "third_party/widevine/cdm/widevine_cdm_common.h" |
| 15 |
| 16 #define RUN_ON_MEDIA_THREAD(METHOD, ...) \ |
| 17 do { \ |
| 18 if (!GetMediaTaskRunner()->BelongsToCurrentThread()) { \ |
| 19 /*DCHECK(ui_task_runner_->BelongsToCurrentThread());*/ \ |
| 20 GetMediaTaskRunner()->PostTask( \ |
| 21 FROM_HERE, base::Bind(&MediaDrmProxy::METHOD, media_weak_this_, \ |
| 22 ##__VA_ARGS__)); \ |
| 23 return; \ |
| 24 } \ |
| 25 } while (0) |
| 26 |
| 27 namespace media { |
| 28 |
| 29 // static |
| 30 scoped_ptr<MediaDrmProxy, BrowserCdmDeleter> MediaDrmProxy::Create( |
| 31 const std::string& key_system, |
| 32 MediaDrmBridge::SecurityLevel widevine_security_level, |
| 33 const SessionMessageCB& session_message_cb, |
| 34 const SessionClosedCB& session_closed_cb, |
| 35 const LegacySessionErrorCB& legacy_session_error_cb, |
| 36 const SessionKeysChangeCB& session_keys_change_cb, |
| 37 const SessionExpirationUpdateCB& session_expiration_update_cb) { |
| 38 scoped_ptr<MediaDrmProxy, BrowserCdmDeleter> media_drm_proxy; |
| 39 |
| 40 // Perform as many checks as we can on the UI thread before we do |
| 41 // the creation asynchronously on Media thread. |
| 42 if (!MediaDrmBridge::CanCreate(key_system, widevine_security_level)) |
| 43 return media_drm_proxy.Pass(); |
| 44 |
| 45 media_drm_proxy.reset( |
| 46 new MediaDrmProxy(key_system, widevine_security_level, session_message_cb, |
| 47 session_closed_cb, legacy_session_error_cb, |
| 48 session_keys_change_cb, session_expiration_update_cb)); |
| 49 |
| 50 // The actual work is done on the Media thread and there the creation |
| 51 // might fail, but we are still passing a valid pointer. |
| 52 return media_drm_proxy.Pass(); |
| 53 } |
| 54 |
| 55 MediaDrmProxy::MediaDrmProxy( |
| 56 const std::string& key_system, |
| 57 MediaDrmBridge::SecurityLevel widevine_security_level, |
| 58 const SessionMessageCB& session_message_cb, |
| 59 const SessionClosedCB& session_closed_cb, |
| 60 const LegacySessionErrorCB& legacy_session_error_cb, |
| 61 const SessionKeysChangeCB& session_keys_change_cb, |
| 62 const SessionExpirationUpdateCB& session_expiration_update_cb) |
| 63 : ui_task_runner_(base::ThreadTaskRunnerHandle::Get()), |
| 64 key_system_(key_system), |
| 65 widevine_security_level_(widevine_security_level), |
| 66 session_message_cb_(session_message_cb), |
| 67 session_closed_cb_(session_closed_cb), |
| 68 legacy_session_error_cb_(legacy_session_error_cb), |
| 69 session_keys_change_cb_(session_keys_change_cb), |
| 70 session_expiration_update_cb_(session_expiration_update_cb), |
| 71 media_weak_factory_(this) { |
| 72 media_weak_this_ = media_weak_factory_.GetWeakPtr(); |
| 73 |
| 74 // Perform MediaDrmBridge creation on the Media thread. |
| 75 GetMediaTaskRunner()->PostTask( |
| 76 FROM_HERE, base::Bind(&MediaDrmProxy::Initialize, media_weak_this_)); |
| 77 } |
| 78 |
| 79 MediaDrmProxy::~MediaDrmProxy() { |
| 80 DVLOG(1) << "MediaDrmProxy::" << __FUNCTION__; |
| 81 DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread()); |
| 82 } |
| 83 |
| 84 void MediaDrmProxy::DeleteOnCorrectThread() { |
| 85 DVLOG(1) << "MediaDrmProxy::" << __FUNCTION__; |
| 86 |
| 87 // Post deletion onto Media thread |
| 88 GetMediaTaskRunner()->DeleteSoon(FROM_HERE, this); |
| 89 } |
| 90 |
| 91 void MediaDrmProxy::Initialize() { |
| 92 DVLOG(1) << "MediaDrmProxy::" << __FUNCTION__; |
| 93 |
| 94 // Pass the original callbacks, those that should be called on UI thread. |
| 95 media_drm_bridge_ = |
| 96 scoped_ptr<MediaDrmBridge, BrowserCdmDeleter>(MediaDrmBridge::Create( |
| 97 key_system_, |
| 98 widevine_security_level_, |
| 99 session_message_cb_, |
| 100 session_closed_cb_, |
| 101 legacy_session_error_cb_, |
| 102 session_keys_change_cb_, |
| 103 session_expiration_update_cb_)); |
| 104 |
| 105 if (!media_drm_bridge_) |
| 106 DVLOG(1) << __FUNCTION__ << ": MediaDrmBridge::Create() failed"; |
| 107 } |
| 108 |
| 109 void MediaDrmProxy::SetServerCertificate( |
| 110 const std::vector<uint8_t>& certificate, |
| 111 scoped_ptr<media::SimpleCdmPromise> promise) { |
| 112 RUN_ON_MEDIA_THREAD(SetServerCertificate, certificate, |
| 113 base::Passed(&promise)); |
| 114 |
| 115 DVLOG(1) << "MediaDrmProxy::" << __FUNCTION__; |
| 116 |
| 117 media_drm_bridge_->SetServerCertificate(certificate, promise.Pass()); |
| 118 } |
| 119 |
| 120 void MediaDrmProxy::CreateSessionAndGenerateRequest( |
| 121 SessionType session_type, |
| 122 media::EmeInitDataType init_data_type, |
| 123 const std::vector<uint8_t>& init_data, |
| 124 scoped_ptr<media::NewSessionCdmPromise> promise) { |
| 125 RUN_ON_MEDIA_THREAD(CreateSessionAndGenerateRequest, session_type, |
| 126 init_data_type, init_data, base::Passed(&promise)); |
| 127 |
| 128 DVLOG(1) << "MediaDrmProxy::" << __FUNCTION__; |
| 129 |
| 130 media_drm_bridge_->CreateSessionAndGenerateRequest( |
| 131 session_type, init_data_type, init_data, promise.Pass()); |
| 132 } |
| 133 |
| 134 void MediaDrmProxy::LoadSession( |
| 135 SessionType session_type, |
| 136 const std::string& session_id, |
| 137 scoped_ptr<media::NewSessionCdmPromise> promise) { |
| 138 RUN_ON_MEDIA_THREAD(LoadSession, session_type, session_id, |
| 139 base::Passed(&promise)); |
| 140 |
| 141 DVLOG(1) << "MediaDrmProxy::" << __FUNCTION__; |
| 142 |
| 143 media_drm_bridge_->LoadSession(session_type, session_id, promise.Pass()); |
| 144 } |
| 145 |
| 146 void MediaDrmProxy::UpdateSession(const std::string& session_id, |
| 147 const std::vector<uint8_t>& response, |
| 148 scoped_ptr<media::SimpleCdmPromise> promise) { |
| 149 RUN_ON_MEDIA_THREAD(UpdateSession, session_id, response, |
| 150 base::Passed(&promise)); |
| 151 |
| 152 DVLOG(1) << "MediaDrmProxy::" << __FUNCTION__; |
| 153 |
| 154 media_drm_bridge_->UpdateSession(session_id, response, promise.Pass()); |
| 155 } |
| 156 |
| 157 void MediaDrmProxy::CloseSession(const std::string& session_id, |
| 158 scoped_ptr<media::SimpleCdmPromise> promise) { |
| 159 RUN_ON_MEDIA_THREAD(CloseSession, session_id, base::Passed(&promise)); |
| 160 |
| 161 DVLOG(1) << "MediaDrmProxy::" << __FUNCTION__; |
| 162 |
| 163 media_drm_bridge_->CloseSession(session_id, promise.Pass()); |
| 164 } |
| 165 |
| 166 void MediaDrmProxy::RemoveSession(const std::string& session_id, |
| 167 scoped_ptr<media::SimpleCdmPromise> promise) { |
| 168 RUN_ON_MEDIA_THREAD(RemoveSession, session_id, base::Passed(&promise)); |
| 169 |
| 170 DVLOG(1) << "MediaDrmProxy::" << __FUNCTION__; |
| 171 |
| 172 media_drm_bridge_->RemoveSession(session_id, promise.Pass()); |
| 173 } |
| 174 |
| 175 CdmContext* MediaDrmProxy::GetCdmContext() { |
| 176 NOTREACHED(); |
| 177 return nullptr; |
| 178 } |
| 179 |
| 180 int MediaDrmProxy::RegisterPlayer(const base::Closure& new_key_cb, |
| 181 const base::Closure& cdm_unset_cb) { |
| 182 // Synchronous? |
| 183 DVLOG(1) << "MediaDrmProxy::" << __FUNCTION__; |
| 184 return media_drm_bridge_->RegisterPlayer(new_key_cb, cdm_unset_cb); |
| 185 } |
| 186 |
| 187 void MediaDrmProxy::UnregisterPlayer(int registration_id) { |
| 188 // Synchronous? |
| 189 DVLOG(1) << "MediaDrmProxy::" << __FUNCTION__; |
| 190 media_drm_bridge_->UnregisterPlayer(registration_id); |
| 191 } |
| 192 |
| 193 MediaDrmBridge* MediaDrmProxy::GetDrmBridge() { |
| 194 DCHECK(GetMediaTaskRunner()->BelongsToCurrentThread()); |
| 195 |
| 196 return media_drm_bridge_.get(); |
| 197 } |
| 198 |
| 199 } // namespace media |
OLD | NEW |