EME: Allow temporary sessions to be removed for ClearKey only.

media/cdm/aes_decryptor.cc

 // Copyright 2013 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/cdm/aes_decryptor.h"
 
 #include <stddef.h>
 #include <list>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "crypto/encryptor.h"
 #include "crypto/symmetric_key.h"
 #include "media/base/audio_decoder_config.h"
-#include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/limits.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/cdm/json_web_key.h"
 #include "media/media_features.h"
 
 #if BUILDFLAG(USE_PROPRIETARY_CODECS)
@@ skipping 195 matching lines @@
   DCHECK_EQ(decrypted_text.size(), encrypted_text.size());
 
   scoped_refptr<DecoderBuffer> output = DecoderBuffer::CopyFrom(
       reinterpret_cast<const uint8_t*>(sample), sample_size);
   CopySubsamples(subsamples, kDstContainsClearBytes,
                  reinterpret_cast<const uint8_t*>(decrypted_text.data()),
                  output->writable_data());
   return output;
 }
 
-AesDecryptor::AesDecryptor(const GURL& /* security_origin */,
-                           const SessionMessageCB& session_message_cb,
-                           const SessionClosedCB& session_closed_cb,
-                           const SessionKeysChangeCB& session_keys_change_cb)
+AesDecryptor::AesDecryptor(
+    const GURL& /* security_origin */,
+    const SessionMessageCB& session_message_cb,
+    const SessionClosedCB& session_closed_cb,
+    const SessionKeysChangeCB& session_keys_change_cb,
+    const SessionExpirationUpdateCB& session_expiration_update_cb)
     : session_message_cb_(session_message_cb),
       session_closed_cb_(session_closed_cb),
-      session_keys_change_cb_(session_keys_change_cb) {
+      session_keys_change_cb_(session_keys_change_cb),
+      session_expiration_update_cb_(session_expiration_update_cb) {
   // AesDecryptor doesn't keep any persistent data, so no need to do anything
   // with |security_origin|.
   DCHECK(!session_message_cb_.is_null());
   DCHECK(!session_closed_cb_.is_null());
   DCHECK(!session_keys_change_cb_.is_null());
 }
 
 AesDecryptor::~AesDecryptor() {
   key_map_.clear();
 }
@@ skipping 133 matching lines @@
 
     if (!new_audio_key_cb_.is_null())
       new_audio_key_cb_.Run();
 
     if (!new_video_key_cb_.is_null())
       new_video_key_cb_.Run();
   }
 
   promise->resolve();
 
-  // Create the list of all available keys for this session.
-  CdmKeysInfo keys_info;
-  {
-    base::AutoLock auto_lock(key_map_lock_);
-    for (const auto& item : key_map_) {
-      if (item.second->Contains(session_id)) {
-        keys_info.push_back(
-            new CdmKeyInformation(item.first, CdmKeyInformation::USABLE, 0));
-      }
-    }
-  }
-
-  session_keys_change_cb_.Run(session_id, key_added, std::move(keys_info));
+  session_keys_change_cb_.Run(
+      session_id, key_added,
+      GenerateKeysInfoList(session_id, CdmKeyInformation::USABLE));
 }
 
 // Runs the parallel steps from https://w3c.github.io/encrypted-media/#close.
 void AesDecryptor::CloseSession(const std::string& session_id,
                                 std::unique_ptr<SimpleCdmPromise> promise) {
   // Validate that this is a reference to an open session. close() shouldn't
   // be called if the session is already closed. However, the operation is
   // asynchronous, so there is a window where close() was called a second time
   // just before the closed event arrives. As a result it is possible that the
   // session is already closed, so assume that the session is closed if it
@@ skipping 13 matching lines @@
   open_sessions_.erase(it);
   DeleteKeysForSession(session_id);
 
   // 5.3. Queue a task to run the following steps:
   // 5.3.1. Run the Session Closed algorithm on the session.
   session_closed_cb_.Run(session_id);
   // 5.3.2. Resolve promise.
   promise->resolve();
 }
 
+// Runs the parallel steps from https://w3c.github.io/encrypted-media/#remove.
 void AesDecryptor::RemoveSession(const std::string& session_id,
                                  std::unique_ptr<SimpleCdmPromise> promise) {
-  NOTIMPLEMENTED() << "Need to address https://crbug.com/616166.";
-  promise->reject(CdmPromise::INVALID_ACCESS_ERROR, 0,
-                  "Session does not exist.");
+  std::set<std::string>::iterator it = open_sessions_.find(session_id);
+  if (it == open_sessions_.end()) {
+    // Session doesn't exist. Since this should only be called if the session
+    // existed at one time, this must mean the session has been closed.
+    promise->reject(CdmPromise::INVALID_STATE_ERROR, 0,
+                    "The session is already closed.");
+    return;
+  }
+
+  // Create the list of all existing keys for this session. They will be
+  // removed, so set the status to "released".
+  CdmKeysInfo keys_info =
+      GenerateKeysInfoList(session_id, CdmKeyInformation::RELEASED);
+
+  // 4.1. Let cdm be the CDM instance represented by session's cdm instance
+  //      value.
+  // 4.2 Let message be null.
+  // 4.3 Let message type be null.
+  // 4.4 Use the cdm to execute the following steps:
+  // 4.4.1.1 Destroy the license(s) and/or key(s) associated with the session.
+  DeleteKeysForSession(session_id);
+
+  // 4.4.1.2 Follow the steps for the value of this object's session type
+  //         from the following list:
+  //           "temporary"
+  //              Continue with the following steps.
+  //           "persistent-license"
+  //              (Not supported, so no need to do anything.)
+
+  // 4.5. Queue a task to run the following steps:
+  // 4.5.1 Run the Update Key Statuses algorithm on the session, providing
+  //       all key ID(s) in the session along with the "released"
+  //       MediaKeyStatus value for each.
+  session_keys_change_cb_.Run(session_id, false, std::move(keys_info));
+
+  // 4.5.2 Run the Update Expiration algorithm on the session, providing NaN.
+  session_expiration_update_cb_.Run(session_id, base::Time());
+
+  // 4.5.3 If any of the preceding steps failed, reject promise with a new
+  //       DOMException whose name is the appropriate error name.
+  // 4.5.4 Let message type be "license-release".
+  // 4.5.5 If message is not null, run the Queue a "message" Event algorithm
+  //       on the session, providing message type and message.
+  // (Not needed as message is only set for persistent licenses, and they're
+  //  not supported here.)
+
+  // 4.5.6. Resolve promise.
+  promise->resolve();
 }
 
 CdmContext* AesDecryptor::GetCdmContext() {
   return this;
 }
 
 Decryptor* AesDecryptor::GetDecryptor() {
   return this;
 }
 
@@ skipping 146 matching lines @@
       // iterator, so we need to increment it first.
       KeyIdToSessionKeysMap::iterator current = it;
       ++it;
       key_map_.erase(current);
     } else {
       ++it;
     }
   }
 }
 
+CdmKeysInfo AesDecryptor::GenerateKeysInfoList(
+    const std::string& session_id,
+    CdmKeyInformation::KeyStatus status) {
+  // Create the list of all available keys for this session.
+  CdmKeysInfo keys_info;
+  {
+    base::AutoLock auto_lock(key_map_lock_);
+    for (const auto& item : key_map_) {
+      if (item.second->Contains(session_id)) {
+        keys_info.push_back(new CdmKeyInformation(item.first, status, 0));
+      }
+    }
+  }
+  return keys_info;
+}
+
 AesDecryptor::DecryptionKey::DecryptionKey(const std::string& secret)
     : secret_(secret) {
 }
 
 AesDecryptor::DecryptionKey::~DecryptionKey() {}
 
 bool AesDecryptor::DecryptionKey::Init() {
   CHECK(!secret_.empty());
   decryption_key_ =
       crypto::SymmetricKey::Import(crypto::SymmetricKey::AES, secret_);
   if (!decryption_key_)
     return false;
   return true;
 }
 
 }  // namespace media