EME: Close existing sessions on CDM failure

media/mojo/clients/mojo_cdm.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 "media/mojo/clients/mojo_cdm.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 18 matching lines @@
 static void RejectPromise(std::unique_ptr<PromiseType> promise,
                           mojom::CdmPromiseResultPtr result) {
   promise->reject(result->exception, result->system_code,
                   result->error_message);
 }
 
 // static
 void MojoCdm::Create(
     const std::string& key_system,
     const GURL& security_origin,
-    const media::CdmConfig& cdm_config,
+    const CdmConfig& cdm_config,
     mojom::ContentDecryptionModulePtr remote_cdm,
-    const media::SessionMessageCB& session_message_cb,
-    const media::SessionClosedCB& session_closed_cb,
-    const media::SessionKeysChangeCB& session_keys_change_cb,
-    const media::SessionExpirationUpdateCB& session_expiration_update_cb,
-    const media::CdmCreatedCB& cdm_created_cb) {
+    const SessionMessageCB& session_message_cb,
+    const SessionClosedCB& session_closed_cb,
+    const SessionKeysChangeCB& session_keys_change_cb,
+    const SessionExpirationUpdateCB& session_expiration_update_cb,
+    const CdmCreatedCB& cdm_created_cb) {
   scoped_refptr<MojoCdm> mojo_cdm(
       new MojoCdm(std::move(remote_cdm), session_message_cb, session_closed_cb,
                   session_keys_change_cb, session_expiration_update_cb));
 
   // |mojo_cdm| ownership is passed to the promise.
   std::unique_ptr<CdmInitializedPromise> promise(
       new CdmInitializedPromise(cdm_created_cb, mojo_cdm));
 
   mojo_cdm->InitializeCdm(key_system, security_origin, cdm_config,
                           std::move(promise));
@@ skipping 35 matching lines @@
     decryptor_task_runner_->DeleteSoon(FROM_HERE, decryptor_.release());
   }
 }
 
 // Using base::Unretained(this) below is safe because |this| owns |remote_cdm_|,
 // and if |this| is destroyed, |remote_cdm_| will be destroyed as well. Then the
 // error handler can't be invoked and callbacks won't be dispatched.
 
 void MojoCdm::InitializeCdm(const std::string& key_system,
                             const GURL& security_origin,
-                            const media::CdmConfig& cdm_config,
+                            const CdmConfig& cdm_config,
                             std::unique_ptr<CdmInitializedPromise> promise) {
   DVLOG(1) << __FUNCTION__ << ": " << key_system;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If connection error has happened, fail immediately.
   if (remote_cdm_.encountered_error()) {
     LOG(ERROR) << "Remote CDM encountered error.";
     promise->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0,
                     "Mojo CDM creation failed.");
     return;
   }
 
   // Otherwise, set an error handler to catch the connection error.
   remote_cdm_.set_connection_error_handler(
       base::Bind(&MojoCdm::OnConnectionError, base::Unretained(this)));
 
   pending_init_promise_ = std::move(promise);
 
   remote_cdm_->Initialize(
       key_system, security_origin.spec(), mojom::CdmConfig::From(cdm_config),
       base::Bind(&MojoCdm::OnCdmInitialized, base::Unretained(this)));
 }
 
 void MojoCdm::OnConnectionError() {
   LOG(ERROR) << "Remote CDM connection error.";
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // We only handle initial connection error.
-  if (!pending_init_promise_)
-    return;
+  // Handle initial connection error.
+  if (pending_init_promise_) {
+    pending_init_promise_->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0,
+                                  "Mojo CDM creation failed.");
+    pending_init_promise_.reset();
+  }
 
-  pending_init_promise_->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0,
-                                "Mojo CDM creation failed.");
-  pending_init_promise_.reset();
+  cdm_session_tracker_.CloseRemainingSessions(session_closed_cb_);
 }
 
 void MojoCdm::SetServerCertificate(const std::vector<uint8_t>& certificate,
                                    std::unique_ptr<SimpleCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_cdm_->SetServerCertificate(
       certificate, base::Bind(&MojoCdm::OnSimpleCdmPromiseResult,
                               base::Unretained(this), base::Passed(&promise)));
@@ skipping 55 matching lines @@
   remote_cdm_->RemoveSession(
       session_id, base::Bind(&MojoCdm::OnSimpleCdmPromiseResult,
                              base::Unretained(this), base::Passed(&promise)));
 }
 
 CdmContext* MojoCdm::GetCdmContext() {
   DVLOG(2) << __FUNCTION__;
   return this;
 }
 
-media::Decryptor* MojoCdm::GetDecryptor() {
+Decryptor* MojoCdm::GetDecryptor() {
   base::AutoLock auto_lock(lock_);
 
   if (!decryptor_task_runner_)
     decryptor_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
   DCHECK(decryptor_task_runner_->BelongsToCurrentThread());
 
   // Can be called on a different thread.
   if (decryptor_ptr_info_.is_valid()) {
     DCHECK(!decryptor_);
@@ skipping 18 matching lines @@
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   session_message_cb_.Run(session_id, message_type, message);
 }
 
 void MojoCdm::OnSessionClosed(const std::string& session_id) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  cdm_session_tracker_.RemoveSession(session_id);
   session_closed_cb_.Run(session_id);
 }
 
 void MojoCdm::OnSessionKeysChange(
     const std::string& session_id,
     bool has_additional_usable_key,
     std::vector<mojom::CdmKeyInformationPtr> keys_info) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(jrummell): Handling resume playback should be done in the media
   // player, not in the Decryptors. http://crbug.com/413413.
   if (has_additional_usable_key) {
     base::AutoLock auto_lock(lock_);
     if (decryptor_) {
       DCHECK(decryptor_task_runner_);
       decryptor_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&MojoCdm::OnKeyAdded, weak_factory_.GetWeakPtr()));
     }
   }
 
-  media::CdmKeysInfo key_data;
+  CdmKeysInfo key_data;
   key_data.reserve(keys_info.size());
   for (size_t i = 0; i < keys_info.size(); ++i) {
     key_data.push_back(
-        keys_info[i].To<std::unique_ptr<media::CdmKeyInformation>>().release());
+        keys_info[i].To<std::unique_ptr<CdmKeyInformation>>().release());
   }
   session_keys_change_cb_.Run(session_id, has_additional_usable_key,
                               std::move(key_data));
 }
 
 void MojoCdm::OnSessionExpirationUpdate(const std::string& session_id,
                                         double new_expiry_time_sec) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 40 matching lines @@
   if (result->success)
     promise->resolve();
   else
     RejectPromise(std::move(promise), std::move(result));
 }
 
 void MojoCdm::OnNewSessionCdmPromiseResult(
     std::unique_ptr<NewSessionCdmPromise> promise,
     mojom::CdmPromiseResultPtr result,
     const std::string& session_id) {
-  if (result->success)
+  if (result->success) {
+    cdm_session_tracker_.AddSession(session_id);
     promise->resolve(session_id);
-  else
+  } else
     RejectPromise(std::move(promise), std::move(result));
 }
 
 }  // namespace media