namespace content {
-ProxyMediaKeys::ProxyMediaKeys(RendererMediaPlayerManager* manager,
- int media_keys_id,
- const media::KeyAddedCB& key_added_cb,
- const media::KeyErrorCB& key_error_cb,
- const media::KeyMessageCB& key_message_cb)
- : manager_(manager),
- media_keys_id_(media_keys_id),
- key_added_cb_(key_added_cb),
- key_error_cb_(key_error_cb),
- key_message_cb_(key_message_cb) {
- DCHECK(manager_);
+int ProxyMediaKeys::next_cdm_id_ =
+ RendererMediaPlayerManager::kInvalidCdmId + 1;
+
+scoped_ptr<ProxyMediaKeys> ProxyMediaKeys::Create(
+ const std::string& key_system,
+ const GURL& security_origin,
+ RendererMediaPlayerManager* manager,
+ const media::SessionCreatedCB& session_created_cb,
+ const media::SessionMessageCB& session_message_cb,
+ const media::SessionReadyCB& session_ready_cb,
+ const media::SessionClosedCB& session_closed_cb,
+ const media::SessionErrorCB& session_error_cb) {
+ DCHECK(manager);
+ scoped_ptr<ProxyMediaKeys> proxy_media_keys(
+ new ProxyMediaKeys(manager,
+ session_created_cb,
+ session_message_cb,
+ session_ready_cb,
+ session_closed_cb,
+ session_error_cb));
+ proxy_media_keys->InitializeCdm(key_system, security_origin);
+ return proxy_media_keys.Pass();
}
ProxyMediaKeys::~ProxyMediaKeys() {
+ manager_->DestroyCdm(cdm_id_);
}
-void ProxyMediaKeys::InitializeCDM(const std::string& key_system,
- const GURL& frame_url) {
-#if defined(ENABLE_PEPPER_CDMS)
- NOTIMPLEMENTED();
-#elif defined(OS_ANDROID)
- std::vector<uint8> uuid = GetUUID(key_system);
- DCHECK(!uuid.empty());
- manager_->InitializeCDM(media_keys_id_, this, uuid, frame_url);
-#endif
-}
+bool ProxyMediaKeys::CreateSession(uint32 session_id,
+ const std::string& content_type,
+ const uint8* init_data,
+ int init_data_length) {
+ // TODO(xhwang): Move these checks up to blink and DCHECK here.
+ // See http://crbug.com/342510
+ CdmHostMsg_CreateSession_ContentType session_type;
+ if (content_type == "audio/mp4" || content_type == "video/mp4") {
+ session_type = CREATE_SESSION_TYPE_MP4;
+ } else if (content_type == "audio/webm" || content_type == "video/webm") {
+ session_type = CREATE_SESSION_TYPE_WEBM;
+ } else {
+ DLOG(ERROR) << "Unsupported EME CreateSession content type of "
+ << content_type;
+ return false;
+ }
-bool ProxyMediaKeys::GenerateKeyRequest(const std::string& type,
- const uint8* init_data,
- int init_data_length) {
- manager_->GenerateKeyRequest(
- media_keys_id_,
- type,
+ manager_->CreateSession(
+ cdm_id_,
+ session_id,
+ session_type,
std::vector<uint8>(init_data, init_data + init_data_length));
return true;
}
-void ProxyMediaKeys::AddKey(const uint8* key, int key_length,
- const uint8* init_data, int init_data_length,
- const std::string& session_id) {
- manager_->AddKey(media_keys_id_,
- std::vector<uint8>(key, key + key_length),
- std::vector<uint8>(init_data, init_data + init_data_length),
- session_id);
+void ProxyMediaKeys::LoadSession(uint32 session_id,
+ const std::string& web_session_id) {
+ // TODO(xhwang): Check key system and platform support for LoadSession in
+ // blink and add NOTREACHED() here.
+ DLOG(ERROR) << "ProxyMediaKeys doesn't support session loading.";
+ OnSessionError(session_id, media::MediaKeys::kUnknownError, 0);
+}
+
+void ProxyMediaKeys::UpdateSession(uint32 session_id,
+ const uint8* response,
+ int response_length) {
+ manager_->UpdateSession(
+ cdm_id_,
+ session_id,
+ std::vector<uint8>(response, response + response_length));
+}
+
+void ProxyMediaKeys::ReleaseSession(uint32 session_id) {
+ manager_->ReleaseSession(cdm_id_, session_id);
+}
+
+void ProxyMediaKeys::OnSessionCreated(uint32 session_id,
+ const std::string& web_session_id) {
+ session_created_cb_.Run(session_id, web_session_id);
+}
+
+void ProxyMediaKeys::OnSessionMessage(uint32 session_id,
+ const std::vector<uint8>& message,
+ const std::string& destination_url) {
+ session_message_cb_.Run(session_id, message, destination_url);
+}
+
+void ProxyMediaKeys::OnSessionReady(uint32 session_id) {
+ session_ready_cb_.Run(session_id);
+}
+
+void ProxyMediaKeys::OnSessionClosed(uint32 session_id) {
+ session_closed_cb_.Run(session_id);
}
-void ProxyMediaKeys::CancelKeyRequest(const std::string& session_id) {
- manager_->CancelKeyRequest(media_keys_id_, session_id);
+void ProxyMediaKeys::OnSessionError(uint32 session_id,
+ media::MediaKeys::KeyError error_code,
+ uint32 system_code) {
+ session_error_cb_.Run(session_id, error_code, system_code);
}
-void ProxyMediaKeys::OnKeyAdded(const std::string& session_id) {
- key_added_cb_.Run(session_id);
+int ProxyMediaKeys::GetCdmId() const {
+ return cdm_id_;
}
-void ProxyMediaKeys::OnKeyError(const std::string& session_id,
- media::MediaKeys::KeyError error_code,
- int system_code) {
- key_error_cb_.Run(session_id, error_code, system_code);
+ProxyMediaKeys::ProxyMediaKeys(
+ RendererMediaPlayerManager* manager,
+ const media::SessionCreatedCB& session_created_cb,
+ const media::SessionMessageCB& session_message_cb,
+ const media::SessionReadyCB& session_ready_cb,
+ const media::SessionClosedCB& session_closed_cb,
+ const media::SessionErrorCB& session_error_cb)
+ : manager_(manager),
+ cdm_id_(next_cdm_id_++),
+ session_created_cb_(session_created_cb),
+ session_message_cb_(session_message_cb),
+ session_ready_cb_(session_ready_cb),
+ session_closed_cb_(session_closed_cb),
+ session_error_cb_(session_error_cb) {
}
-void ProxyMediaKeys::OnKeyMessage(const std::string& session_id,
- const std::vector<uint8>& message,
- const std::string& destination_url) {
- key_message_cb_.Run(session_id, message, destination_url);
+void ProxyMediaKeys::InitializeCdm(const std::string& key_system,
+ const GURL& security_origin) {
+ manager_->InitializeCdm(cdm_id_, this, key_system, security_origin);
}
} // namespace content
projects / platform / framework / web / crosswalk.git / blobdiff