src/content/renderer/media/crypto/proxy_media_keys.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 "content/renderer/media/crypto/proxy_media_keys.h"
   6
   7 #include <vector>
   8
   9 #include "base/basictypes.h"
  10 #include "base/logging.h"
  11 #include "base/stl_util.h"
  12 #include "content/renderer/media/crypto/key_systems.h"
  13 #include "content/renderer/media/crypto/renderer_cdm_manager.h"
  14 #include "media/base/cdm_promise.h"
  15
  16 namespace content {
  17
  18 scoped_ptr<ProxyMediaKeys> ProxyMediaKeys::Create(
  19     const std::string& key_system,
  20     const GURL& security_origin,
  21     RendererCdmManager* manager,
  22     const media::SessionMessageCB& session_message_cb,
  23     const media::SessionReadyCB& session_ready_cb,
  24     const media::SessionClosedCB& session_closed_cb,
  25     const media::SessionErrorCB& session_error_cb,
  26     const media::SessionKeysChangeCB& session_keys_change_cb,
  27     const media::SessionExpirationUpdateCB& session_expiration_update_cb) {
  28   DCHECK(manager);
  29
  30   // TODO(jrummell): Add support for SessionKeysChangeCB and
  31   // SessionExpirationUpdateCB.
  32   scoped_ptr<ProxyMediaKeys> proxy_media_keys(
  33       new ProxyMediaKeys(manager,
  34                          session_message_cb,
  35                          session_ready_cb,
  36                          session_closed_cb,
  37                          session_error_cb));
  38   proxy_media_keys->InitializeCdm(key_system, security_origin);
  39   return proxy_media_keys.Pass();
  40 }
  41
  42 ProxyMediaKeys::~ProxyMediaKeys() {
  43   manager_->DestroyCdm(cdm_id_);
  44   manager_->UnregisterMediaKeys(cdm_id_);
  45
  46   // Reject any outstanding promises.
  47   for (PromiseMap::iterator it = session_id_to_promise_map_.begin();
  48        it != session_id_to_promise_map_.end();
  49        ++it) {
  50     it->second->reject(
  51         media::MediaKeys::NOT_SUPPORTED_ERROR, 0, "The operation was aborted.");
  52   }
  53   session_id_to_promise_map_.clear();
  54 }
  55
  56 void ProxyMediaKeys::SetServerCertificate(
  57     const uint8* certificate_data,
  58     int certificate_data_length,
  59     scoped_ptr<media::SimpleCdmPromise> promise) {
  60   promise->reject(NOT_SUPPORTED_ERROR, 0, "Not yet implemented.");
  61 }
  62
  63 void ProxyMediaKeys::CreateSession(
  64     const std::string& init_data_type,
  65     const uint8* init_data,
  66     int init_data_length,
  67     SessionType session_type,
  68     scoped_ptr<media::NewSessionCdmPromise> promise) {
  69   // TODO(xhwang): Move these checks up to blink and DCHECK here.
  70   // See http://crbug.com/342510
  71   CdmHostMsg_CreateSession_ContentType create_session_content_type;
  72   if (init_data_type == "cenc") {
  73     create_session_content_type = CREATE_SESSION_TYPE_MP4;
  74   } else if (init_data_type == "webm") {
  75     create_session_content_type = CREATE_SESSION_TYPE_WEBM;
  76   } else {
  77     DLOG(ERROR) << "Unsupported EME CreateSession content type of "
  78                 << init_data_type;
  79     promise->reject(
  80         NOT_SUPPORTED_ERROR,
  81         0,
  82         "Unsupported EME CreateSession init data type of " + init_data_type);
  83     return;
  84   }
  85
  86   uint32 session_id = CreateSessionId();
  87   SavePromise(session_id, promise.Pass());
  88   manager_->CreateSession(
  89       cdm_id_,
  90       session_id,
  91       create_session_content_type,
  92       std::vector<uint8>(init_data, init_data + init_data_length));
  93 }
  94
  95 void ProxyMediaKeys::LoadSession(
  96     const std::string& web_session_id,
  97     scoped_ptr<media::NewSessionCdmPromise> promise) {
  98   // TODO(xhwang): Check key system and platform support for LoadSession in
  99   // blink and add NOTREACHED() here.
 100   DLOG(ERROR) << "ProxyMediaKeys doesn't support session loading.";
 101   promise->reject(NOT_SUPPORTED_ERROR, 0, "LoadSession() is not supported.");
 102 }
 103
 104 void ProxyMediaKeys::UpdateSession(
 105     const std::string& web_session_id,
 106     const uint8* response,
 107     int response_length,
 108     scoped_ptr<media::SimpleCdmPromise> promise) {
 109   uint32 session_id = LookupSessionId(web_session_id);
 110   if (!session_id) {
 111     promise->reject(INVALID_ACCESS_ERROR, 0, "Session does not exist.");
 112     return;
 113   }
 114
 115   SavePromise(session_id, promise.Pass());
 116   manager_->UpdateSession(
 117       cdm_id_,
 118       session_id,
 119       std::vector<uint8>(response, response + response_length));
 120 }
 121
 122 void ProxyMediaKeys::CloseSession(const std::string& web_session_id,
 123                                   scoped_ptr<media::SimpleCdmPromise> promise) {
 124   uint32 session_id = LookupSessionId(web_session_id);
 125   if (!session_id) {
 126     promise->reject(INVALID_ACCESS_ERROR, 0, "Session does not exist.");
 127     return;
 128   }
 129
 130   SavePromise(session_id, promise.Pass());
 131   manager_->ReleaseSession(cdm_id_, session_id);
 132 }
 133
 134 void ProxyMediaKeys::RemoveSession(
 135     const std::string& web_session_id,
 136     scoped_ptr<media::SimpleCdmPromise> promise) {
 137   promise->reject(NOT_SUPPORTED_ERROR, 0, "Not yet implemented.");
 138 }
 139
 140 void ProxyMediaKeys::GetUsableKeyIds(const std::string& web_session_id,
 141                                      scoped_ptr<media::KeyIdsPromise> promise) {
 142   promise->reject(NOT_SUPPORTED_ERROR, 0, "Not yet implemented.");
 143 }
 144
 145 int ProxyMediaKeys::GetCdmId() const {
 146   return cdm_id_;
 147 }
 148
 149 void ProxyMediaKeys::OnSessionCreated(uint32 session_id,
 150                                       const std::string& web_session_id) {
 151   AssignWebSessionId(session_id, web_session_id);
 152   scoped_ptr<media::CdmPromise> promise = TakePromise(session_id);
 153   if (promise) {
 154     media::NewSessionCdmPromise* session_promise(
 155         static_cast<media::NewSessionCdmPromise*>(promise.get()));
 156     session_promise->resolve(web_session_id);
 157   }
 158 }
 159
 160 void ProxyMediaKeys::OnSessionMessage(uint32 session_id,
 161                                       const std::vector<uint8>& message,
 162                                       const GURL& destination_url) {
 163   session_message_cb_.Run(
 164       LookupWebSessionId(session_id), message, destination_url);
 165 }
 166
 167 void ProxyMediaKeys::OnSessionReady(uint32 session_id) {
 168   scoped_ptr<media::CdmPromise> promise = TakePromise(session_id);
 169   if (promise) {
 170     media::SimpleCdmPromise* simple_promise(
 171         static_cast<media::SimpleCdmPromise*>(promise.get()));
 172     simple_promise->resolve();
 173   } else {
 174     // Still needed for keyadded.
 175     const std::string web_session_id = LookupWebSessionId(session_id);
 176     session_ready_cb_.Run(web_session_id);
 177   }
 178 }
 179
 180 void ProxyMediaKeys::OnSessionClosed(uint32 session_id) {
 181   const std::string web_session_id = LookupWebSessionId(session_id);
 182   DropWebSessionId(web_session_id);
 183   scoped_ptr<media::CdmPromise> promise = TakePromise(session_id);
 184   if (promise) {
 185     media::SimpleCdmPromise* simple_promise(
 186         static_cast<media::SimpleCdmPromise*>(promise.get()));
 187     simple_promise->resolve();
 188   } else {
 189     // It is possible for the CDM to close a session independent of a
 190     // Release() request.
 191     session_closed_cb_.Run(web_session_id);
 192   }
 193 }
 194
 195 void ProxyMediaKeys::OnSessionError(uint32 session_id,
 196                                     media::MediaKeys::KeyError error_code,
 197                                     uint32 system_code) {
 198   const std::string web_session_id = LookupWebSessionId(session_id);
 199   media::MediaKeys::Exception exception_code;
 200   switch (error_code) {
 201     case media::MediaKeys::kClientError:
 202       exception_code = media::MediaKeys::CLIENT_ERROR;
 203       break;
 204     case media::MediaKeys::kOutputError:
 205       exception_code = media::MediaKeys::OUTPUT_ERROR;
 206       break;
 207     case media::MediaKeys::kUnknownError:
 208     default:
 209       exception_code = media::MediaKeys::UNKNOWN_ERROR;
 210       break;
 211   }
 212
 213   scoped_ptr<media::CdmPromise> promise = TakePromise(session_id);
 214   if (promise) {
 215     promise->reject(exception_code, system_code, std::string());
 216     return;
 217   }
 218
 219   // Errors generally happen in response to a request, but it is possible
 220   // for something bad to happen in the CDM and it needs to tell the client.
 221   session_error_cb_.Run(
 222       web_session_id, exception_code, system_code, std::string());
 223 }
 224
 225 ProxyMediaKeys::ProxyMediaKeys(
 226     RendererCdmManager* manager,
 227     const media::SessionMessageCB& session_message_cb,
 228     const media::SessionReadyCB& session_ready_cb,
 229     const media::SessionClosedCB& session_closed_cb,
 230     const media::SessionErrorCB& session_error_cb)
 231     : manager_(manager),
 232       session_message_cb_(session_message_cb),
 233       session_ready_cb_(session_ready_cb),
 234       session_closed_cb_(session_closed_cb),
 235       session_error_cb_(session_error_cb),
 236       next_session_id_(1) {
 237   cdm_id_ = manager->RegisterMediaKeys(this);
 238 }
 239
 240 void ProxyMediaKeys::InitializeCdm(const std::string& key_system,
 241                                    const GURL& security_origin) {
 242   manager_->InitializeCdm(cdm_id_, this, key_system, security_origin);
 243 }
 244
 245 uint32_t ProxyMediaKeys::CreateSessionId() {
 246   return next_session_id_++;
 247 }
 248
 249 void ProxyMediaKeys::AssignWebSessionId(uint32_t session_id,
 250                                         const std::string& web_session_id) {
 251   DCHECK(!ContainsKey(web_session_to_session_id_map_, web_session_id));
 252   DCHECK(session_id);
 253   web_session_to_session_id_map_.insert(
 254       std::make_pair(web_session_id, session_id));
 255 }
 256
 257 uint32_t ProxyMediaKeys::LookupSessionId(
 258     const std::string& web_session_id) const {
 259   SessionIdMap::const_iterator it =
 260       web_session_to_session_id_map_.find(web_session_id);
 261   return (it != web_session_to_session_id_map_.end()) ? it->second : 0;
 262 }
 263
 264 std::string ProxyMediaKeys::LookupWebSessionId(uint32_t session_id) const {
 265   for (SessionIdMap::const_iterator it = web_session_to_session_id_map_.begin();
 266        it != web_session_to_session_id_map_.end();
 267        ++it) {
 268     if (it->second == session_id)
 269       return it->first;
 270   }
 271   // Possible to get an error creating a session, so no |web_session_id|
 272   // available.
 273   return std::string();
 274 }
 275
 276 void ProxyMediaKeys::DropWebSessionId(const std::string& web_session_id) {
 277   web_session_to_session_id_map_.erase(web_session_id);
 278 }
 279
 280 void ProxyMediaKeys::SavePromise(uint32_t session_id,
 281                                  scoped_ptr<media::CdmPromise> promise) {
 282   // Should only be one promise outstanding for any |session_id|.
 283   DCHECK(!ContainsKey(session_id_to_promise_map_, session_id));
 284   session_id_to_promise_map_.add(session_id, promise.Pass());
 285 }
 286
 287 scoped_ptr<media::CdmPromise> ProxyMediaKeys::TakePromise(uint32_t session_id) {
 288   PromiseMap::iterator it = session_id_to_promise_map_.find(session_id);
 289   // May not be a promise associated with this session for asynchronous events.
 290   if (it == session_id_to_promise_map_.end())
 291     return scoped_ptr<media::CdmPromise>();
 292   return session_id_to_promise_map_.take_and_erase(it);
 293 }
 294
 295 }  // namespace content