[eme] Handle multiple calls to MediaKeySession.close()

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>
@@ skipping 243 matching lines @@
   promise->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0,
                   "SetServerCertificate() is not supported.");
 }
 
 void AesDecryptor::CreateSessionAndGenerateRequest(
     SessionType session_type,
     EmeInitDataType init_data_type,
     const std::vector<uint8_t>& init_data,
     std::unique_ptr<NewSessionCdmPromise> promise) {
   std::string session_id(base::UintToString(next_session_id_++));
-  valid_sessions_.insert(session_id);
+  open_sessions_.insert(session_id);
 
   // For now, the AesDecryptor does not care about |session_type|.
   // TODO(jrummell): Validate |session_type|.
 
   std::vector<uint8_t> message;
   std::vector<std::vector<uint8_t>> keys;
   switch (init_data_type) {
     case EmeInitDataType::WEBM:
       // |init_data| is simply the key needed.
       if (init_data.size() < limits::kMinKeyIdLength ||
@@ skipping 47 matching lines @@
   // that do not support loadSession. See http://crbug.com/342481
   promise->reject(CdmPromise::NOT_SUPPORTED_ERROR, 0,
                   "LoadSession() is not supported.");
 }
 
 void AesDecryptor::UpdateSession(const std::string& session_id,
                                  const std::vector<uint8_t>& response,
                                  std::unique_ptr<SimpleCdmPromise> promise) {
   CHECK(!response.empty());
 
-  // TODO(jrummell): Convert back to a DCHECK once prefixed EME is removed.
-  if (valid_sessions_.find(session_id) == valid_sessions_.end()) {
+  // Currently the EME spec has blink check for session closed synchronously,
+  // but then this is called asynchronously. So it is possible that update()
+  // could get called on a closed session.
+  // https://github.com/w3c/encrypted-media/issues/365
+  if (open_sessions_.find(session_id) == open_sessions_.end()) {
     promise->reject(CdmPromise::INVALID_ACCESS_ERROR, 0,
                     "Session does not exist.");
     return;
   }
 
   std::string key_string(response.begin(), response.end());
 
   KeyIdAndKeyPairs keys;
   SessionType session_type = ContentDecryptionModule::TEMPORARY_SESSION;
   if (!ExtractKeysFromJWKSet(key_string, &keys, &session_type)) {
@@ skipping 54 matching lines @@
       }
     }
   }
 
   session_keys_change_cb_.Run(session_id, key_added, std::move(keys_info));
 }
 
 // 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 active session and then forget it.
-  std::set<std::string>::iterator it = valid_sessions_.find(session_id);
-  DCHECK(it != valid_sessions_.end());
+  // 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
+  // doesn't exist. https://github.com/w3c/encrypted-media/issues/365.
+  //
+  // close() is called from a MediaKeySession object, so it is unlikely that
+  // this method will be called with a previously unseen |session_id|.
+  std::set<std::string>::iterator it = open_sessions_.find(session_id);
+  if (it == open_sessions_.end()) {
+    promise->resolve();
+    return;
+  }
 
   // 5.1. Let cdm be the CDM instance represented by session's cdm instance
   //      value.
   // 5.2. Use cdm to close the session associated with session.
-  valid_sessions_.erase(it);
+  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();
 }
 
 void AesDecryptor::RemoveSession(const std::string& session_id,
@@ skipping 176 matching lines @@
 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