Allows support for persistent session types in BrowserCdm.

content/browser/media/cdm/browser_cdm_manager.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/browser/media/cdm/browser_cdm_manager.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 159 matching lines @@
 }
 
 bool BrowserCdmManager::OnMessageReceived(const IPC::Message& msg) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BrowserCdmManager, msg)
     IPC_MESSAGE_HANDLER(CdmHostMsg_InitializeCdm, OnInitializeCdm)
     IPC_MESSAGE_HANDLER(CdmHostMsg_SetServerCertificate, OnSetServerCertificate)
     IPC_MESSAGE_HANDLER(CdmHostMsg_CreateSessionAndGenerateRequest,
                         OnCreateSessionAndGenerateRequest)
+    IPC_MESSAGE_HANDLER(CdmHostMsg_LoadSession, OnLoadSession)
     IPC_MESSAGE_HANDLER(CdmHostMsg_UpdateSession, OnUpdateSession)
     IPC_MESSAGE_HANDLER(CdmHostMsg_CloseSession, OnCloseSession)
+    IPC_MESSAGE_HANDLER(CdmHostMsg_RemoveSession, OnRemoveSession)
     IPC_MESSAGE_HANDLER(CdmHostMsg_DestroyCdm, OnDestroyCdm)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 media::BrowserCdm* BrowserCdmManager::GetCdm(int render_frame_id,
                                              int cdm_id) const {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   return cdm_map_.get(GetId(render_frame_id, cdm_id));
@@ skipping 135 matching lines @@
 
   if (certificate.empty()) {
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0, "Empty certificate.");
     return;
   }
 
   cdm->SetServerCertificate(certificate, promise.Pass());
 }
 
 void BrowserCdmManager::OnCreateSessionAndGenerateRequest(
-    int render_frame_id,
-    int cdm_id,
-    uint32_t promise_id,
-    CdmHostMsg_CreateSession_InitDataType init_data_type,
-    const std::vector<uint8>& init_data) {
+    const CdmHostMsg_CreateSessionAndGenerateRequest_Params& params) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
+  int render_frame_id = params.render_frame_id;
+  int cdm_id = params.cdm_id;
+  const std::vector<uint8>& init_data = params.init_data;
   scoped_ptr<NewSessionPromise> promise(
-      new NewSessionPromise(this, render_frame_id, cdm_id, promise_id));
+      new NewSessionPromise(this, render_frame_id, cdm_id, params.promise_id));
 
   if (init_data.size() > media::limits::kMaxInitDataLength) {
     LOG(WARNING) << "InitData for ID: " << cdm_id
                  << " too long: " << init_data.size();
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0, "Init data too long.");
     return;
   }
 #if defined(OS_ANDROID)
   // 'webm' initData is a single key ID. On Android the length is restricted.
-  if (init_data_type == INIT_DATA_TYPE_WEBM &&
+  if (params.init_data_type == INIT_DATA_TYPE_WEBM &&
       init_data.size() != kAndroidKeyIdBytes) {
     promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0,
                     "'webm' initData is not the correct length.");
     return;
   }
 #endif
 
   media::EmeInitDataType eme_init_data_type;
-  switch (init_data_type) {
+  switch (params.init_data_type) {
     case INIT_DATA_TYPE_WEBM:
       eme_init_data_type = media::EmeInitDataType::WEBM;
       break;
 #if defined(USE_PROPRIETARY_CODECS)
     case INIT_DATA_TYPE_CENC:
       eme_init_data_type = media::EmeInitDataType::CENC;
       break;
 #endif
     default:
       NOTREACHED();
       promise->reject(MediaKeys::INVALID_ACCESS_ERROR, 0,
                       "Invalid init data type.");
       return;
   }
 
   BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     DLOG(WARNING) << "No CDM found for: " << render_frame_id << ", " << cdm_id;
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   CheckPermissionStatus(
       render_frame_id, cdm_id,
       base::Bind(&BrowserCdmManager::CreateSessionAndGenerateRequestIfPermitted,
-                 this, render_frame_id, cdm_id, eme_init_data_type, init_data,
-                 base::Passed(&promise)));
+                 this, render_frame_id, cdm_id, params.session_type,
+                 eme_init_data_type, init_data, base::Passed(&promise)));
+}
+
+void BrowserCdmManager::OnLoadSession(
+    int render_frame_id,
+    int cdm_id,
+    uint32_t promise_id,
+    media::MediaKeys::SessionType session_type,
+    const std::string& session_id) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
+  scoped_ptr<NewSessionPromise> promise(
+      new NewSessionPromise(this, render_frame_id, cdm_id, promise_id));
+
+  BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
+  if (!cdm) {
+    DLOG(WARNING) << "No CDM found for: " << render_frame_id << ", " << cdm_id;
+    promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
+    return;
+  }
+
+  CheckPermissionStatus(
+      render_frame_id, cdm_id,
+      base::Bind(&BrowserCdmManager::LoadSessionIfPermitted,
+                 this, render_frame_id, cdm_id, session_type,
+                 session_id, base::Passed(&promise)));
 }
 
 void BrowserCdmManager::OnUpdateSession(int render_frame_id,
                                         int cdm_id,
                                         uint32_t promise_id,
                                         const std::string& session_id,
                                         const std::vector<uint8>& response) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   scoped_ptr<SimplePromise> promise(
@@ skipping 31 matching lines @@
 
   BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
   cdm->CloseSession(session_id, promise.Pass());
 }
 
+void BrowserCdmManager::OnRemoveSession(int render_frame_id,
+                                        int cdm_id,
+                                        uint32_t promise_id,
+                                        const std::string& session_id) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
+  scoped_ptr<SimplePromise> promise(
+      new SimplePromise(this, render_frame_id, cdm_id, promise_id));
+
+  BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
+  if (!cdm) {
+    promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
+    return;
+  }
+
+  cdm->RemoveSession(session_id, promise.Pass());
+}
+
 void BrowserCdmManager::OnDestroyCdm(int render_frame_id, int cdm_id) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   RemoveCdm(GetId(render_frame_id, cdm_id));
 }
 
 // Use a weak pointer here instead of |this| to avoid circular references.
 #define BROWSER_CDM_MANAGER_CB(func)                                   \
   base::Bind(&BrowserCdmManager::func, weak_ptr_factory_.GetWeakPtr(), \
              render_frame_id, cdm_id)
 
@@ skipping 102 matching lines @@
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(permission_status_cb, allowed));
   } else {
     permission_status_cb.Run(allowed);
   }
 }
 
 void BrowserCdmManager::CreateSessionAndGenerateRequestIfPermitted(
     int render_frame_id,
     int cdm_id,
+    media::MediaKeys::SessionType session_type,
     media::EmeInitDataType init_data_type,
     const std::vector<uint8>& init_data,
     scoped_ptr<media::NewSessionCdmPromise> promise,
     bool permission_was_allowed) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   if (!permission_was_allowed) {
     promise->reject(MediaKeys::NOT_SUPPORTED_ERROR, 0, "Permission denied.");
     return;
   }
 
   BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
   if (!cdm) {
     promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
     return;
   }
 
-  // Only the temporary session type is supported in browser CDM path.
-  // TODO(xhwang): Add SessionType support if needed.
-  cdm->CreateSessionAndGenerateRequest(media::MediaKeys::TEMPORARY_SESSION,
-                                       init_data_type, init_data,
-                                       promise.Pass());
+  cdm->CreateSessionAndGenerateRequest(session_type, init_data_type,
+                                       init_data, promise.Pass());
+}
+
+void BrowserCdmManager::LoadSessionIfPermitted(
+    int render_frame_id,
+    int cdm_id,
+    media::MediaKeys::SessionType session_type,
+    const std::string& session_id,
+    scoped_ptr<media::NewSessionCdmPromise> promise,
+    bool permission_was_allowed) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+

[ddorwin, 2015/05/28 23:51:50]

Should we DCHECK session_type != temporary?
Or, DCHECK(IsPersistentSessionType(session_type).

[gunsch, 2015/05/28 23:59:12]

Done.

+  if (!permission_was_allowed) {
+    promise->reject(MediaKeys::NOT_SUPPORTED_ERROR, 0, "Permission denied.");
+    return;
+  }
+
+  BrowserCdm* cdm = GetCdm(render_frame_id, cdm_id);
+  if (!cdm) {
+    promise->reject(MediaKeys::INVALID_STATE_ERROR, 0, "CDM not found.");
+    return;
+  }
+
+  cdm->LoadSession(session_type, session_id, promise.Pass());

[ddorwin, 2015/05/28 23:51:50]

Blink checks the session type, right?

MediaDrmBridge::LoadSession(), etc. should probably have NOTREACHED() (or at
least NOTIMPLEMENTED) because they should not be reached without a change to the
Android KeySystems code. The message could even mention this.

Ditto for session_type in MediaDrmBridge::CreateSessionAndGenerateRequest()

[gunsch, 2015/05/28 23:59:12]

Sure, promises were already rejected but NOTREACHED seems reasonable now that
the configuration code is in place.

 }
 
 }  // namespace content