Update MediaKeys interface for EME

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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/json/json_reader.h"
@@ skipping 193 matching lines @@
 }
 
 enum PromiseResult { RESOLVED, REJECTED };
 
 class AesDecryptorTest : public testing::Test {
  public:
   AesDecryptorTest()
       : decryptor_(base::Bind(&AesDecryptorTest::OnSessionMessage,
                               base::Unretained(this)),
                    base::Bind(&AesDecryptorTest::OnSessionClosed,
+                              base::Unretained(this)),
+                   base::Bind(&AesDecryptorTest::OnSessionKeysChange,
                               base::Unretained(this))),
         decrypt_cb_(base::Bind(&AesDecryptorTest::BufferDecrypted,
                                base::Unretained(this))),
         original_data_(kOriginalData, kOriginalData + kOriginalDataSize),
         encrypted_data_(kEncryptedData,
                         kEncryptedData + arraysize(kEncryptedData)),
         subsample_encrypted_data_(
             kSubsampleEncryptedData,
             kSubsampleEncryptedData + arraysize(kSubsampleEncryptedData)),
         key_id_(kKeyId, kKeyId + arraysize(kKeyId)),
@@ skipping 76 matching lines @@
     decryptor_.CreateSession(std::string(),
                              &key_id[0],
                              key_id.size(),
                              MediaKeys::TEMPORARY_SESSION,
                              CreateSessionPromise(RESOLVED));
     // This expects the promise to be called synchronously, which is the case
     // for AesDecryptor.
     return web_session_id_;
   }
 
-  // Releases the session specified by |session_id|.
-  void ReleaseSession(const std::string& session_id) {
+  // Closes the session specified by |session_id|.
+  void CloseSession(const std::string& session_id) {
     EXPECT_CALL(*this, OnSessionClosed(session_id));
-    decryptor_.ReleaseSession(session_id, CreatePromise(RESOLVED));
+    decryptor_.CloseSession(session_id, CreatePromise(RESOLVED));
+  }
+
+  // Removes the session specified by |session_id|. This should simply do a
+  // CloseSession().
+  // TODO(jrummell): Clean this up when the prefixed API is removed.
+  // http://crbug.com/249976.
+  void RemoveSession(const std::string& session_id) {
+    EXPECT_CALL(*this, OnSessionClosed(session_id));
+    decryptor_.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,
-                              PromiseResult result) {
+                              PromiseResult expected_result) {
     DCHECK(!key.empty());
 
+    if (expected_result == RESOLVED) {
+      EXPECT_CALL(*this, OnSessionKeysChange(session_id, true));
+    } else {
+      EXPECT_CALL(*this, OnSessionKeysChange(_, _)).Times(0);
+    }
+
     decryptor_.UpdateSession(session_id,
                              reinterpret_cast<const uint8*>(key.c_str()),
                              key.length(),
-                             CreatePromise(result));
+                             CreatePromise(expected_result));
   }
 
   void GetUsableKeyIdsAndExpect(const std::string& session_id,
                                 PromiseResult expected_result,
                                 uint32 expected_count) {
     decryptor_.GetUsableKeyIds(
         session_id, CreateUsableKeyIdsPromise(expected_result, expected_count));
   }
 
   bool UsableKeyIdsContains(std::vector<uint8> expected) {
@@ skipping 62 matching lines @@
       case NO_KEY:
         EXPECT_TRUE(decrypted_text.empty());
         break;
     }
   }
 
   MOCK_METHOD3(OnSessionMessage,
                void(const std::string& web_session_id,
                     const std::vector<uint8>& message,
                     const GURL& destination_url));
+  MOCK_METHOD2(OnSessionKeysChange,
+               void(const std::string& web_session_id,
+                    bool has_additional_usable_key));
   MOCK_METHOD1(OnSessionClosed, void(const std::string& web_session_id));
 
   AesDecryptor decryptor_;
   AesDecryptor::DecryptCB decrypt_cb_;
   std::string web_session_id_;
 
   // Copy of the vector from the last successful call to
   // OnResolveWithUsableKeyIds().
   KeyIdsVector useable_key_ids_;
 
@@ skipping 221 matching lines @@
 
   std::vector<SubsampleEntry> cypher_only_subsample_entries(
       kSubsampleEntriesCypherOnly,
       kSubsampleEntriesCypherOnly + arraysize(kSubsampleEntriesCypherOnly));
 
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, cypher_only_subsample_entries);
   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 }
 
-TEST_F(AesDecryptorTest, ReleaseSession) {
+TEST_F(AesDecryptorTest, CloseSession) {
   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);
+  ASSERT_NO_FATAL_FAILURE(
+      DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
+
+  CloseSession(session_id);
+}
+
+TEST_F(AesDecryptorTest, RemoveSession) {
+  // TODO(jrummell): Clean this up when the prefixed API is removed.
+  // http://crbug.com/249976.
+  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);
   ASSERT_NO_FATAL_FAILURE(
       DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
 
-  ReleaseSession(session_id);
+  RemoveSession(session_id);
 }
 
-TEST_F(AesDecryptorTest, NoKeyAfterReleaseSession) {
+TEST_F(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);
   ASSERT_NO_FATAL_FAILURE(
       DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
 
-  ReleaseSession(session_id);
+  CloseSession(session_id);
   ASSERT_NO_FATAL_FAILURE(
       DecryptAndExpect(encrypted_buffer, original_data_, NO_KEY));
 }
 
 TEST_F(AesDecryptorTest, LatestKeyUsed) {
   std::string session_id1 = CreateSession(key_id_);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, no_subsample_entries_);
 
   // Add alternate key, buffer should not be decoded properly.
   UpdateSessionAndExpect(session_id1, kKeyAlternateAsJWK, RESOLVED);
   ASSERT_NO_FATAL_FAILURE(
       DecryptAndExpect(encrypted_buffer, original_data_, DATA_MISMATCH));
 
   // Create a second session with a correct key value for key_id_.
   std::string session_id2 = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id2, kKeyAsJWK, RESOLVED);
 
   // Should be able to decode with latest key.
   ASSERT_NO_FATAL_FAILURE(
       DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
 }
 
-TEST_F(AesDecryptorTest, LatestKeyUsedAfterReleaseSession) {
+TEST_F(AesDecryptorTest, LatestKeyUsedAfterCloseSession) {
   std::string session_id1 = CreateSession(key_id_);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, no_subsample_entries_);
   UpdateSessionAndExpect(session_id1, kKeyAsJWK, RESOLVED);
   ASSERT_NO_FATAL_FAILURE(
       DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
 
   // Create a second session with a different key value for key_id_.
   std::string session_id2 = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id2, kKeyAlternateAsJWK, RESOLVED);
 
   // Should not be able to decode with new key.
   ASSERT_NO_FATAL_FAILURE(
       DecryptAndExpect(encrypted_buffer, original_data_, DATA_MISMATCH));
 
   // Close second session, should revert to original key.
-  ReleaseSession(session_id2);
+  CloseSession(session_id2);
   ASSERT_NO_FATAL_FAILURE(
       DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
 }
 
 TEST_F(AesDecryptorTest, JWKKey) {
   std::string session_id = CreateSession(key_id_);
 
   // Try a simple JWK key (i.e. not in a set)
   const std::string kJwkSimple =
       "{"
@@ skipping 111 matching lines @@
       "{"
       "  \"keys\": ["
       "    {"
       "      \"kty\": \"oct\","
       "      \"kid\": \"\","
       "      \"k\": \"BAUGBwgJCgsMDQ4PEBESEw\""
       "    }"
       "  ]"
       "}";
   UpdateSessionAndExpect(session_id, kJwksWithEmptyKeyId, REJECTED);
-  ReleaseSession(session_id);
+  CloseSession(session_id);
 }
 
 TEST_F(AesDecryptorTest, GetKeyIds) {
   std::vector<uint8> key_id1(kKeyId, kKeyId + arraysize(kKeyId));
   std::vector<uint8> key_id2(kKeyId2, kKeyId2 + arraysize(kKeyId2));
 
   std::string session_id = CreateSession(key_id_);
   GetUsableKeyIdsAndExpect(session_id, RESOLVED, 0);
   EXPECT_FALSE(UsableKeyIdsContains(key_id1));
   EXPECT_FALSE(UsableKeyIdsContains(key_id2));
 
   // Add 1 key, verify ID is returned.
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED);
   GetUsableKeyIdsAndExpect(session_id, RESOLVED, 1);
   EXPECT_TRUE(UsableKeyIdsContains(key_id1));
   EXPECT_FALSE(UsableKeyIdsContains(key_id2));
 
   // Add second key, verify both IDs returned.
   UpdateSessionAndExpect(session_id, kKey2AsJWK, RESOLVED);
   GetUsableKeyIdsAndExpect(session_id, RESOLVED, 2);
   EXPECT_TRUE(UsableKeyIdsContains(key_id1));
   EXPECT_TRUE(UsableKeyIdsContains(key_id2));
 }
 
 }  // namespace media