Add "type" in GenerateKeyRequest() and OnNeedKey().

webkit/media/crypto/proxy_decryptor_unittest.cc

 // Copyright (c) 2012 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 "webkit/media/crypto/proxy_decryptor.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ref_counted.h"
@@ skipping 11 matching lines @@
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 using media::DecoderBuffer;
 using media::DecryptConfig;
 using media::Decryptor;
 
 namespace webkit_media {
 
 static const uint8 kFakeKeyId[] = { 0x4b, 0x65, 0x79, 0x20, 0x49, 0x44 };
+static const int kFakeKeyIdSize = arraysize(kFakeKeyId);
 static const uint8 kFakeIv[DecryptConfig::kDecryptionKeySize] = { 0 };
 static const char kFakeKeySystem[] = "system.key.fake";
 static const char kFakeSessionId[] = "FakeSessionId";
 static const uint8 kFakeKey[] = { 0x4b, 0x65, 0x79 };
 static const uint8 kEncryptedData[] = { 0x65, 0x6E, 0x63, 0x72, 0x79 };
 static const uint8 kDecryptedData[] = { 0x64, 0x65, 0x63, 0x72, 0x79 };
 
 // Creates a fake non-empty encrypted buffer.
 static scoped_refptr<DecoderBuffer> CreateFakeEncryptedBuffer() {
   const int encrypted_frame_offset = 1;  // This should be non-zero.
   scoped_refptr<DecoderBuffer> encrypted_buffer =
       DecoderBuffer::CopyFrom(kEncryptedData, arraysize(kEncryptedData));
   encrypted_buffer->SetDecryptConfig(scoped_ptr<DecryptConfig>(
       new DecryptConfig(
           std::string(reinterpret_cast<const char*>(kFakeKeyId),
-                      arraysize(kFakeKeyId)),
+                      kFakeKeyIdSize),
           std::string(reinterpret_cast<const char*>(kFakeIv),
                       DecryptConfig::kDecryptionKeySize),
           encrypted_frame_offset,
           std::vector<media::SubsampleEntry>())));
   return encrypted_buffer;
 }
 
 ACTION_P2(RunDecryptCB, status, buffer) {
   arg2.Run(status, buffer);
 }
@@ skipping 29 matching lines @@
   // real Decryptor, inject a MockDecryptor for testing purpose.
   void GenerateKeyRequest() {
     proxy_decryptor_.set_decryptor_for_testing(scoped_real_decryptor_.Pass());
   }
 
   // Since we are using the MockDecryptor, we can simulate any decryption
   // behavior we want. Therefore, we do not care which key is really added,
   // hence always use fake key IDs and keys.
   void AddKey() {
     EXPECT_CALL(*real_decryptor_, AddKey(kFakeKeySystem,
-                                         kFakeKeyId, arraysize(kFakeKeyId),
+                                         kFakeKeyId, kFakeKeyIdSize,
                                          kFakeKey, arraysize(kFakeKey),
                                          kFakeSessionId));
     proxy_decryptor_.AddKey(kFakeKeySystem,
-                            kFakeKeyId, arraysize(kFakeKeyId),
+                            kFakeKeyId, kFakeKeyIdSize,
                             kFakeKey, arraysize(kFakeKey),
                             kFakeSessionId);
   }
 
   // The DecryptCB passed to proxy_decryptor_.Decrypt().
   MOCK_METHOD2(DeliverBuffer, void(Decryptor::Status,
                                    const scoped_refptr<DecoderBuffer>&));
 
  protected:
   MessageLoop message_loop_;
@@ skipping 44 matching lines @@
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kError, IsNull()));
   proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 }
 
 // Tests the case where no key is available for decryption.
 TEST_F(ProxyDecryptorTest, NormalDecryption_NoKey) {
   GenerateKeyRequest();
 
   EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillOnce(RunDecryptCB(Decryptor::kNoKey, null_buffer_));
-  EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId)));
+  EXPECT_CALL(client_, NeedKeyMock("", "", "", NotNull(), kFakeKeyIdSize));
   proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, null_buffer_));
   proxy_decryptor_.CancelDecrypt(stream_type_);
 }
 
 // Tests the case where Decrypt() is called after the right key is added.
 TEST_F(ProxyDecryptorTest, DecryptBeforeAddKey) {
-  EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId)));
+  EXPECT_CALL(client_, NeedKeyMock("", "", "", NotNull(), kFakeKeyIdSize));
   GenerateKeyRequest();
   EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillOnce(RunDecryptCB(Decryptor::kNoKey, null_buffer_));
   proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
   EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillOnce(RunDecryptCB(Decryptor::kSuccess, decrypted_buffer_));
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, decrypted_buffer_))
       .WillOnce(ScheduleMessageLoopToStop(&message_loop_));
   AddKey();
 
   message_loop_.Run();
 }
 
 // Tests the case where Decrypt() is called before GKR() and the right key is
 // added.
 TEST_F(ProxyDecryptorTest, DecryptBeforeGenerateKeyRequest) {
-  EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId)));
+  EXPECT_CALL(client_, NeedKeyMock("", "", "", NotNull(), kFakeKeyIdSize));
   proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
   EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillOnce(RunDecryptCB(Decryptor::kSuccess, decrypted_buffer_));
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, decrypted_buffer_))
       .WillOnce(ScheduleMessageLoopToStop(&message_loop_));
   GenerateKeyRequest();
   AddKey();
 
   message_loop_.Run();
 }
 
 // Tests the case where multiple AddKey() is called to add some irrelevant keys
 // before the real key that can decrypt |encrypted_buffer_| is added.
 TEST_F(ProxyDecryptorTest, MultipleAddKeys) {
-  EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId)))
+  EXPECT_CALL(client_, NeedKeyMock("", "", "", NotNull(), kFakeKeyIdSize))
       .Times(AtLeast(1));
   proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
   EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillRepeatedly(RunDecryptCB(Decryptor::kNoKey, null_buffer_));
   GenerateKeyRequest();
   const int number_of_irrelevant_addkey = 5;
   for (int i = 0; i < number_of_irrelevant_addkey; ++i)
     AddKey();  // Some irrelevant keys are added.
 
@@ skipping 30 matching lines @@
       .WillOnce(ScheduleMessageLoopToStop(&message_loop_));
   base::ResetAndReturn(&decrypt_cb).Run(Decryptor::kNoKey, null_buffer_);
 
   message_loop_.Run();
 }
 
 // Test the case where we cancel the pending decryption callback even before
 // GenerateKeyRequest is called. In this case, the decryptor was not even
 // created!
 TEST_F(ProxyDecryptorTest, CancelDecryptWithoutGenerateKeyRequestCalled) {
-  EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId)))
+  EXPECT_CALL(client_, NeedKeyMock("", "", "", NotNull(), kFakeKeyIdSize))
       .Times(AtLeast(1));
   proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, null_buffer_))
       .WillOnce(ScheduleMessageLoopToStop(&message_loop_));
   proxy_decryptor_.CancelDecrypt(stream_type_);
 
   message_loop_.Run();
 }
 
 // Test the case where we cancel the pending decryption callback when it's
 // stored in the ProxyDecryptor.
 TEST_F(ProxyDecryptorTest, CancelDecryptWhenDecryptPendingInProxyDecryptor) {
-  EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId)))
+  EXPECT_CALL(client_, NeedKeyMock("", "", "", NotNull(), kFakeKeyIdSize))
       .Times(AtLeast(1));
   EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillRepeatedly(RunDecryptCB(Decryptor::kNoKey, null_buffer_));
   GenerateKeyRequest();
   proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, null_buffer_))
       .WillOnce(ScheduleMessageLoopToStop(&message_loop_));
   proxy_decryptor_.CancelDecrypt(stream_type_);
 
@@ skipping 19 matching lines @@
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, null_buffer_))
       .WillOnce(ScheduleMessageLoopToStop(&message_loop_));
   proxy_decryptor_.CancelDecrypt(stream_type_);
 
   message_loop_.Run();
 }
 
 // Test the case where we try to decrypt again after the previous decrypt was
 // canceled.
 TEST_F(ProxyDecryptorTest, DecryptAfterCancelDecrypt) {
-  EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId)))
+  EXPECT_CALL(client_, NeedKeyMock("", "", "", NotNull(), kFakeKeyIdSize))
       .Times(AtLeast(1));
   EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillRepeatedly(RunDecryptCB(Decryptor::kNoKey, null_buffer_));
   proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
   GenerateKeyRequest();
 
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, null_buffer_));
   proxy_decryptor_.CancelDecrypt(stream_type_);
 
   AddKey();
 
   EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillOnce(RunDecryptCB(Decryptor::kSuccess, decrypted_buffer_));
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, decrypted_buffer_))
       .WillOnce(ScheduleMessageLoopToStop(&message_loop_));
   proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
   message_loop_.Run();
 }
 
 }  // namespace webkit_media