Pass key_information on SessionKeysChange message

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"
 #include "base/values.h"
 #include "media/base/cdm_callback_promise.h"
+#include "media/base/cdm_key_information.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/mock_filters.h"
 #include "media/cdm/aes_decryptor.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::Gt;
 using ::testing::IsNull;
 using ::testing::NotNull;
 using ::testing::SaveArg;
 using ::testing::StrNe;
+using ::testing::Unused;
 
 MATCHER(IsEmpty, "") { return arg.empty(); }
 MATCHER(IsNotEmpty, "") { return !arg.empty(); }
 MATCHER(IsJSONDictionary, "") {
   std::string result(arg.begin(), arg.end());
   scoped_ptr<base::Value> root(base::JSONReader().ReadToValue(result));
   return (root.get() && root->GetType() == base::Value::TYPE_DICTIONARY);
 }
 
 class GURL;
@@ skipping 265 matching lines @@
 
   // 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));
   }
 
+  // Helper method to make a local copy of |usable_key_ids|.
+  void SaveUsableKeys(Unused, Unused, const CdmKeysInfo& usable_key_ids) {

[xhwang, 2015/01/05 22:53:15]

If you pass CdmKeysInfo by value, you can probably just use Pass() and transfer
the ownership over. Will that be simpler?

[jrummell, 2015/01/06 02:36:25]

MOCK functions don't like ScopedVector, so changed to have a proper method for
OnSessionKeysChange() and a mock'd method OnSessionKeysChangeCalled().

+    usable_key_ids_.clear();
+    for (const auto& key_id : usable_key_ids) {
+      scoped_ptr<CdmKeyInformation> new_key_id(new CdmKeyInformation);
+      new_key_id->key_id = key_id->key_id;
+      new_key_id->status = key_id->status;
+      new_key_id->system_code = key_id->system_code;
+      usable_key_ids_.push_back(new_key_id.release());

[xhwang, 2015/01/05 22:53:15]

It seems here we save ALL key IDs regardless of it's status, i.e. even for
non-usable key IDs. So "Usable" in the function name doesn't seem accurate.

How about we rename SaveUsableKeys to something like SaveKeysInfo?

[jrummell, 2015/01/06 02:36:25]

Removed.

+    }
+  }
+
   // 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 expected_result) {
     DCHECK(!key.empty());
 
     if (expected_result == RESOLVED) {
-      EXPECT_CALL(*this, OnSessionKeysChange(session_id, true));
+      EXPECT_CALL(*this, OnSessionKeysChange(session_id, true, _))
+          .WillOnce(Invoke(this, &AesDecryptorTest::SaveUsableKeys));
     } else {
-      EXPECT_CALL(*this, OnSessionKeysChange(_, _)).Times(0);
+      EXPECT_CALL(*this, OnSessionKeysChange(_, _, _)).Times(0);
     }
 
     decryptor_.UpdateSession(session_id,
                              reinterpret_cast<const uint8*>(key.c_str()),
                              key.length(),
                              CreatePromise(expected_result));
   }
 
+  bool UsableKeyIdsContains(std::vector<uint8> expected) {

[xhwang, 2015/01/05 22:53:15]

Ditto about "Usable".

[jrummell, 2015/01/06 02:36:25]

Done.

+    for (const auto& key_id : usable_key_ids_) {
+      if (key_id->key_id == 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 43 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,
+  MOCK_METHOD3(OnSessionKeysChange,
                void(const std::string& web_session_id,
-                    bool has_additional_usable_key));
+                    bool has_additional_usable_key,
+                    const CdmKeysInfo& keys_info));
   MOCK_METHOD1(OnSessionClosed, void(const std::string& web_session_id));
 
   AesDecryptor decryptor_;
   AesDecryptor::DecryptCB decrypt_cb_;
   std::string web_session_id_;
+  CdmKeysInfo usable_key_ids_;

[xhwang, 2015/01/05 22:53:15]

ditto about "usable".

[jrummell, 2015/01/06 02:36:25]

Done.

 
   // 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 431 matching lines @@
       "      \"alg\": \"A128KW\","
       "      \"kid\": \"\","
       "      \"k\": \"BAUGBwgJCgsMDQ4PEBESEw\""
       "    }"
       "  ]"
       "}";
   UpdateSessionAndExpect(session_id, kJwksWithEmptyKeyId, REJECTED);
   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_);
+  EXPECT_FALSE(UsableKeyIdsContains(key_id1));
+  EXPECT_FALSE(UsableKeyIdsContains(key_id2));
+
+  // Add 1 key, verify it is returned.
+  UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED);
+  EXPECT_TRUE(UsableKeyIdsContains(key_id1));
+  EXPECT_FALSE(UsableKeyIdsContains(key_id2));
+
+  // Add second key, verify both IDs returned.
+  UpdateSessionAndExpect(session_id, kKey2AsJWK, RESOLVED);
+  EXPECT_TRUE(UsableKeyIdsContains(key_id1));
+  EXPECT_TRUE(UsableKeyIdsContains(key_id2));
+}
+
 }  // namespace media