Allows support for persistent session types in BrowserCdm.

content/renderer/media/crypto/proxy_media_keys.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/crypto/proxy_media_keys.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 42 matching lines @@
     scoped_ptr<media::SimpleCdmPromise> promise) {
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
   manager_->SetServerCertificate(cdm_id_, promise_id, certificate);
 }
 
 void ProxyMediaKeys::CreateSessionAndGenerateRequest(
     SessionType session_type,
     media::EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
     scoped_ptr<media::NewSessionCdmPromise> promise) {
-  if (session_type != media::MediaKeys::TEMPORARY_SESSION) {
-    promise->reject(NOT_SUPPORTED_ERROR, 0,
-                    "Only the temporary session type is supported.");
-    return;
-  }
-
   // TODO(xhwang): Move these checks up to blink and DCHECK here.
   // See http://crbug.com/342510
   CdmHostMsg_CreateSession_InitDataType create_session_init_data_type =
       INIT_DATA_TYPE_WEBM;
   switch (init_data_type) {
     case media::EmeInitDataType::CENC:
       create_session_init_data_type = INIT_DATA_TYPE_CENC;
       break;
     case media::EmeInitDataType::WEBM:
       create_session_init_data_type = INIT_DATA_TYPE_WEBM;
       break;
     case media::EmeInitDataType::KEYIDS:
     case media::EmeInitDataType::UNKNOWN:
       DLOG(ERROR) << "Unsupported EME CreateSession init data type";
       promise->reject(NOT_SUPPORTED_ERROR, 0,
                       "Unsupported EME CreateSession init data type");
       return;
   }
 
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
   manager_->CreateSessionAndGenerateRequest(
-      cdm_id_, promise_id, create_session_init_data_type, init_data);
+      cdm_id_, promise_id, session_type, create_session_init_data_type,
+      init_data);
 }
 
 void ProxyMediaKeys::LoadSession(
     SessionType session_type,
     const std::string& session_id,
     scoped_ptr<media::NewSessionCdmPromise> promise) {
-  NOTREACHED() << "ProxyMediaKeys doesn't support persistent sessions.";
-  promise->reject(NOT_SUPPORTED_ERROR, 0, "LoadSession() is not supported.");
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  manager_->LoadSession(cdm_id_, promise_id, session_type, session_id);
 }
 
 void ProxyMediaKeys::UpdateSession(
     const std::string& session_id,
     const std::vector<uint8_t>& response,
     scoped_ptr<media::SimpleCdmPromise> promise) {
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
   manager_->UpdateSession(cdm_id_, promise_id, session_id, response);
 }
 
 void ProxyMediaKeys::CloseSession(const std::string& session_id,
                                   scoped_ptr<media::SimpleCdmPromise> promise) {
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
   manager_->CloseSession(cdm_id_, promise_id, session_id);
 }
 
 void ProxyMediaKeys::RemoveSession(
     const std::string& session_id,
     scoped_ptr<media::SimpleCdmPromise> promise) {
-  NOTREACHED() << "ProxyMediaKeys doesn't support persistent sessions.";
-  promise->reject(NOT_SUPPORTED_ERROR, 0, "RemoveSession() not supported.");
+  uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
+  manager_->RemoveSession(cdm_id_, promise_id, session_id);
 }
 
 media::CdmContext* ProxyMediaKeys::GetCdmContext() {
   return this;
 }
 
 media::Decryptor* ProxyMediaKeys::GetDecryptor() {
   return nullptr;
 }
 
@@ skipping 73 matching lines @@
     const std::string& key_system,
     const GURL& security_origin,
     bool use_hw_secure_codecs,
     scoped_ptr<media::SimpleCdmPromise> promise) {
   uint32_t promise_id = cdm_promise_adapter_.SavePromise(promise.Pass());
   manager_->InitializeCdm(cdm_id_, promise_id, this, key_system,
                           security_origin, use_hw_secure_codecs);
 }
 
 }  // namespace content