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

media/cdm/aes_decryptor_unittest.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 <stdint.h>
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 234 matching lines @@
  protected:
   void SetUp() override {
     if (GetParam() == "AesDecryptor") {
       OnCdmCreated(
           new AesDecryptor(GURL::EmptyGURL(),
                            base::Bind(&MockCdmClient::OnSessionMessage,
                                       base::Unretained(&cdm_client_)),
                            base::Bind(&MockCdmClient::OnSessionClosed,
                                       base::Unretained(&cdm_client_)),
                            base::Bind(&MockCdmClient::OnSessionKeysChange,
+                                      base::Unretained(&cdm_client_)),
+                           base::Bind(&MockCdmClient::OnSessionExpirationUpdate,
                                       base::Unretained(&cdm_client_))),
           std::string());
     } else if (GetParam() == "CdmAdapter") {
       CdmConfig cdm_config;  // default settings of false are sufficient.
 
       helper_.reset(new ExternalClearKeyTestHelper());
       std::unique_ptr<CdmAllocator> allocator(new SimpleCdmAllocator());
       CdmAdapter::Create(
           helper_->KeySystemName(), helper_->LibraryPath(), cdm_config,
           std::move(allocator), base::Bind(&AesDecryptorTest::CreateCdmFileIO,
@@ skipping 76 matching lines @@
     // for AesDecryptor.
     return session_id_;
   }
 
   // Closes the session specified by |session_id|.
   void CloseSession(const std::string& session_id) {
     EXPECT_CALL(cdm_client_, OnSessionClosed(session_id));
     cdm_->CloseSession(session_id, CreatePromise(RESOLVED));
   }
 
-  // Only persistent sessions can be removed.
+  // Removes the session specified by |session_id|.
   void RemoveSession(const std::string& session_id) {
-    // TODO(ddorwin): This should be RESOLVED after https://crbug.com/616166.
-    cdm_->RemoveSession(session_id, CreatePromise(REJECTED));
+    EXPECT_CALL(cdm_client_, OnSessionKeysChangeCalled(session_id, false));
+    EXPECT_CALL(cdm_client_,
+                OnSessionExpirationUpdate(session_id, IsNullTime()));
+    cdm_->RemoveSession(session_id, CreatePromise(RESOLVED));
   }
 
   // Updates the session specified by |session_id| with |key|. |result|
   // tests that the update succeeds or generates an error.
   void UpdateSessionAndExpect(std::string session_id,
                               const std::string& key,
                               ExpectedResult expected_result,
                               bool new_key_expected) {
     DCHECK(!key.empty());
 
     if (expected_result == RESOLVED) {
       EXPECT_CALL(cdm_client_,
                   OnSessionKeysChangeCalled(session_id, new_key_expected));
     } else {
       EXPECT_CALL(cdm_client_, OnSessionKeysChangeCalled(_, _)).Times(0);
     }
 
     // AesDecryptor never calls OnSessionExpirationUpdate() since Clear Key key
     // system doesn't need it. But ClearKeyCdm does call it for testing purpose.
     EXPECT_CALL(cdm_client_,
                 OnSessionExpirationUpdate(session_id, IsNullTime()))
         .Times(AtMost(1));
 
     cdm_->UpdateSession(session_id,
                         std::vector<uint8_t>(key.begin(), key.end()),
                         CreatePromise(expected_result));
   }
 
-  bool KeysInfoContains(const std::vector<uint8_t>& expected) {
+  bool KeysInfoContains(const std::vector<uint8_t>& expected_key_id,
+                        CdmKeyInformation::KeyStatus expected_status =
+                            CdmKeyInformation::USABLE) {
     for (auto* key_id : cdm_client_.keys_info()) {
-      if (key_id->key_id == expected)
+      if (key_id->key_id == expected_key_id &&
+          key_id->status == expected_status) {
         return true;
+      }
     }
     return false;
   }
 
   MOCK_METHOD2(BufferDecrypted, void(Decryptor::Status,
                                      const scoped_refptr<DecoderBuffer>&));
 
   enum DecryptExpectation {
     SUCCESS,
     DATA_MISMATCH,
@@ skipping 377 matching lines @@
 TEST_P(AesDecryptorTest, RemoveSession) {
   std::string session_id = CreateSession(key_id_);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, no_subsample_entries_);
 
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, true);
   ASSERT_NO_FATAL_FAILURE(
       DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
 
   RemoveSession(session_id);
+  ASSERT_NO_FATAL_FAILURE(
+      DecryptAndExpect(encrypted_buffer, original_data_, NO_KEY));
+}
+
+TEST_P(AesDecryptorTest, RemoveThenCloseSession) {
+  std::string session_id = CreateSession(key_id_);
+  scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
+      encrypted_data_, key_id_, iv_, no_subsample_entries_);
+
+  UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, true);
+  EXPECT_TRUE(KeysInfoContains(key_id_, CdmKeyInformation::USABLE));
+  ASSERT_NO_FATAL_FAILURE(
+      DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
+
+  RemoveSession(session_id);
+  EXPECT_TRUE(KeysInfoContains(key_id_, CdmKeyInformation::RELEASED));
+  ASSERT_NO_FATAL_FAILURE(
+      DecryptAndExpect(encrypted_buffer, original_data_, NO_KEY));
+
+  CloseSession(session_id);
 }
 
 TEST_P(AesDecryptorTest, NoKeyAfterCloseSession) {
   std::string session_id = CreateSession(key_id_);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, no_subsample_entries_);
 
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, true);
   ASSERT_NO_FATAL_FAILURE(
       DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
@@ skipping 230 matching lines @@
 INSTANTIATE_TEST_CASE_P(CdmAdapter,
                         AesDecryptorTest,
                         testing::Values("CdmAdapter"));
 #endif
 
 // TODO(jrummell): Once MojoCdm/MojoCdmService/MojoDecryptor/
 // MojoDecryptorService are implemented, add a third version that tests the
 // CDM via mojo.
 
 }  // namespace media