Update ClearKey to support CDM_6

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 "media/base/cdm_promise.h"
@@ skipping 202 matching lines @@
             kSubsampleEncryptedData,
             kSubsampleEncryptedData + arraysize(kSubsampleEncryptedData)),
         key_id_(kKeyId, kKeyId + arraysize(kKeyId)),
         iv_(kIv, kIv + arraysize(kIv)),
         normal_subsample_entries_(
             kSubsampleEntriesNormal,
             kSubsampleEntriesNormal + arraysize(kSubsampleEntriesNormal)) {
   }
 
  protected:
-  void OnResolveWithSession(PromiseResult expected,
+  void OnResolveWithSession(PromiseResult expected_result,
                             const std::string& web_session_id) {
-    EXPECT_EQ(expected, RESOLVED);
+    EXPECT_EQ(expected_result, RESOLVED) << "Unexpectedly resolved.";
     EXPECT_GT(web_session_id.length(), 0ul);
     web_session_id_ = web_session_id;
   }
 
-  void OnResolve(PromiseResult expected) {
-    EXPECT_EQ(expected, RESOLVED);
+  void OnResolve(PromiseResult expected_result) {
+    EXPECT_EQ(expected_result, RESOLVED) << "Unexpectedly resolved.";
   }
 
-  void OnReject(PromiseResult expected,
+  void OnResolveWithUsableKeyIds(PromiseResult expected_result,
+                                 uint32 expected_count,
+                                 const KeyIdsVector& useable_key_ids) {
+    EXPECT_EQ(expected_result, RESOLVED) << "Unexpectedly resolved.";
+    EXPECT_EQ(expected_count, useable_key_ids.size());
+    useable_key_ids_ = useable_key_ids;
+  }
+
+  void OnReject(PromiseResult expected_result,
                 MediaKeys::Exception exception_code,
                 uint32 system_code,
                 const std::string& error_message) {
-    EXPECT_EQ(expected, REJECTED);
+    EXPECT_EQ(expected_result, REJECTED) << "Unexpectedly rejected.";
   }
 
-  scoped_ptr<SimpleCdmPromise> CreatePromise(PromiseResult expected) {
-    scoped_ptr<SimpleCdmPromise> promise(new SimpleCdmPromise(
-        base::Bind(
-            &AesDecryptorTest::OnResolve, base::Unretained(this), expected),
-        base::Bind(
-            &AesDecryptorTest::OnReject, base::Unretained(this), expected)));
+  scoped_ptr<SimpleCdmPromise> CreatePromise(PromiseResult expected_result) {
+    scoped_ptr<SimpleCdmPromise> promise(
+        new SimpleCdmPromise(base::Bind(&AesDecryptorTest::OnResolve,
+                                        base::Unretained(this),
+                                        expected_result),
+                             base::Bind(&AesDecryptorTest::OnReject,
+                                        base::Unretained(this),
+                                        expected_result)));
     return promise.Pass();
   }
 
   scoped_ptr<NewSessionCdmPromise> CreateSessionPromise(
-      PromiseResult expected) {
+      PromiseResult expected_result) {
     scoped_ptr<NewSessionCdmPromise> promise(new NewSessionCdmPromise(
         base::Bind(&AesDecryptorTest::OnResolveWithSession,
                    base::Unretained(this),
-                   expected),
-        base::Bind(
-            &AesDecryptorTest::OnReject, base::Unretained(this), expected)));
+                   expected_result),
+        base::Bind(&AesDecryptorTest::OnReject,
+                   base::Unretained(this),
+                   expected_result)));
     return promise.Pass();
   }
 
+  scoped_ptr<KeyIdsPromise> CreateUsableKeyIdsPromise(
+      PromiseResult expected_result,
+      uint32 expected_count) {
+    scoped_ptr<KeyIdsPromise> promise(new KeyIdsPromise(
+        base::Bind(&AesDecryptorTest::OnResolveWithUsableKeyIds,
+                   base::Unretained(this),
+                   expected_result,
+                   expected_count),
+        base::Bind(&AesDecryptorTest::OnReject,
+                   base::Unretained(this),
+                   expected_result)));
+    return promise.Pass();
+  }
+
   // Creates a new session using |key_id|. Returns the session ID.
   std::string CreateSession(const std::vector<uint8>& key_id) {
     DCHECK(!key_id.empty());
     EXPECT_CALL(*this,
                 OnSessionMessage(IsNotEmpty(), key_id, GURL::EmptyGURL()));
     decryptor_.CreateSession(std::string(),
                              &key_id[0],
                              key_id.size(),
                              MediaKeys::TEMPORARY_SESSION,
                              CreateSessionPromise(RESOLVED));
@@ skipping 14 matching lines @@
                               const std::string& key,
                               PromiseResult result) {
     DCHECK(!key.empty());
 
     decryptor_.UpdateSession(session_id,
                              reinterpret_cast<const uint8*>(key.c_str()),
                              key.length(),
                              CreatePromise(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) {
+    for (KeyIdsVector::iterator it = useable_key_ids_.begin();
+         it != useable_key_ids_.end();
+         ++it) {
+      if (*it == expected)
+        return true;
+    }
+    return false;
+  }
+
   MOCK_METHOD2(BufferDecrypted, void(Decryptor::Status,
                                      const scoped_refptr<DecoderBuffer>&));
 
   enum DecryptExpectation {
     SUCCESS,
     DATA_MISMATCH,
     DATA_AND_SIZE_MISMATCH,
     DECRYPT_ERROR,
     NO_KEY
   };
@@ skipping 49 matching lines @@
   MOCK_METHOD3(OnSessionMessage,
                void(const std::string& web_session_id,
                     const std::vector<uint8>& message,
                     const GURL& destination_url));
   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_;
+
   // Constants for testing.
   const std::vector<uint8> original_data_;
   const std::vector<uint8> encrypted_data_;
   const std::vector<uint8> subsample_encrypted_data_;
   const std::vector<uint8> key_id_;
   const std::vector<uint8> iv_;
   const std::vector<SubsampleEntry> normal_subsample_entries_;
   const std::vector<SubsampleEntry> no_subsample_entries_;
 };
 
@@ skipping 408 matching lines @@
       "      \"kty\": \"oct\","
       "      \"kid\": \"\","
       "      \"k\": \"BAUGBwgJCgsMDQ4PEBESEw\""
       "    }"
       "  ]"
       "}";
   UpdateSessionAndExpect(session_id, kJwksWithEmptyKeyId, REJECTED);
   ReleaseSession(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