Update Decryptor interface to support audio decoding.

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 35 matching lines @@
           std::string(reinterpret_cast<const char*>(kFakeKeyId),
                       arraysize(kFakeKeyId)),
           std::string(reinterpret_cast<const char*>(kFakeIv),
                       DecryptConfig::kDecryptionKeySize),
           encrypted_frame_offset,
           std::vector<media::SubsampleEntry>())));
   return encrypted_buffer;
 }
 
 ACTION_P2(RunDecryptCB, status, buffer) {
-  arg1.Run(status, buffer);
+  arg2.Run(status, buffer);
 }
 
 ACTION_P3(ResetAndRunDecryptCB, decrypt_cb, status, buffer) {
   base::ResetAndReturn(decrypt_cb).Run(status, buffer);
 }
 
 ACTION_P(ScheduleMessageLoopToStop, message_loop) {
   message_loop->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 // Tests the interaction between external Decryptor calls and concrete Decryptor
 // implementations. This test is not interested in any specific Decryptor
 // implementation. A MockDecryptor is used here to serve this purpose.
 class ProxyDecryptorTest : public testing::Test {
  public:
   ProxyDecryptorTest()
       : proxy_decryptor_(message_loop_.message_loop_proxy(),
                          &client_, NULL, NULL),
         real_decryptor_(new media::MockDecryptor()),
         scoped_real_decryptor_(real_decryptor_),
+        stream_type_(media::Decryptor::kVideo),
         decrypt_cb_(base::Bind(&ProxyDecryptorTest::DeliverBuffer,
                                base::Unretained(this))),
         encrypted_buffer_(CreateFakeEncryptedBuffer()),
         decrypted_buffer_(DecoderBuffer::CopyFrom(kDecryptedData,
                                                   arraysize(kDecryptedData))),
         null_buffer_(scoped_refptr<DecoderBuffer>()) {
   }
 
   // Instead of calling ProxyDecryptor::GenerateKeyRequest() here to create a
   // real Decryptor, inject a MockDecryptor for testing purpose.
@@ skipping 28 matching lines @@
   // mock decryptor.
   media::MockDecryptor* real_decryptor_;
 
   // Scoped pointer that takes ownership of |real_decryptor_|. When
   // GenerateKeyRequest() is called, the ownership of |real_decryptor_| is
   // passed from |scoped_real_decryptor_| to |proxy_decryptor_|. We need this
   // to manage life time of |real_decryptor_| because not all tests call
   // GenerateKeyRequest().
   scoped_ptr<Decryptor> scoped_real_decryptor_;
 
+  media::Decryptor::StreamType stream_type_;
+
   Decryptor::DecryptCB decrypt_cb_;
 
   scoped_refptr<DecoderBuffer> encrypted_buffer_;
   scoped_refptr<DecoderBuffer> decrypted_buffer_;
   scoped_refptr<DecoderBuffer> null_buffer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProxyDecryptorTest);
 };
 
 // Tests a typical use case: GKR(), AddKey() and Decrypt() succeeds.
 TEST_F(ProxyDecryptorTest, NormalDecryption_Success) {
   GenerateKeyRequest();
   AddKey();
 
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+  EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillOnce(RunDecryptCB(Decryptor::kSuccess, decrypted_buffer_));
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, decrypted_buffer_));
-  proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 }
 
 // Tests the case where Decrypt() fails.
 TEST_F(ProxyDecryptorTest, NormalDecryption_Error) {
   GenerateKeyRequest();
   AddKey();
 
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+  EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillOnce(RunDecryptCB(Decryptor::kError, null_buffer_));
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kError, IsNull()));
-  proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  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(encrypted_buffer_, _))
+  EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillOnce(RunDecryptCB(Decryptor::kNoKey, null_buffer_));
   EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId)));
-  proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, null_buffer_));
-  proxy_decryptor_.CancelDecrypt();
+  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)));
   GenerateKeyRequest();
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+  EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillOnce(RunDecryptCB(Decryptor::kNoKey, null_buffer_));
-  proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+  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)));
-  proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+  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)))
       .Times(AtLeast(1));
-  proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+  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.
 
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+  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();  // Correct key added.
 
   message_loop_.Run();
 }
 
 // Test the case where a new key is added before the |real_decryptor_| returns
 // kNoKey. The exact call sequence is:
 // 1, Decrypt an encrypted buffer.
 // 2, The correct key is added.
 // 3, The previously decrypt call returned kNoKey.
 // In this case, the ProxyDecryptor is smart enough to try the decryption again
 // and get the buffer decrypted!
 TEST_F(ProxyDecryptorTest, AddKeyAfterDecryptButBeforeNoKeyReturned) {
   Decryptor::DecryptCB decrypt_cb;
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
-      .WillOnce(SaveArg<1>(&decrypt_cb));
+  EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
+      .WillOnce(SaveArg<2>(&decrypt_cb));
 
   GenerateKeyRequest();
-  proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
   EXPECT_FALSE(decrypt_cb.is_null());
 
   AddKey();
 
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+  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_));
   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)))
       .Times(AtLeast(1));
-  proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, null_buffer_))
       .WillOnce(ScheduleMessageLoopToStop(&message_loop_));
-  proxy_decryptor_.CancelDecrypt();
+  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)))
       .Times(AtLeast(1));
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+  EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillRepeatedly(RunDecryptCB(Decryptor::kNoKey, null_buffer_));
   GenerateKeyRequest();
-  proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, null_buffer_))
       .WillOnce(ScheduleMessageLoopToStop(&message_loop_));
-  proxy_decryptor_.CancelDecrypt();
+  proxy_decryptor_.CancelDecrypt(stream_type_);
 
   message_loop_.Run();
 }
 
 // Test the case where we cancel the pending decryption callback when it's
 // pending at the |real_decryptor_|.
 TEST_F(ProxyDecryptorTest, CancelDecryptWhenDecryptPendingInRealDecryptor) {
   Decryptor::DecryptCB decrypt_cb;
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
-      .WillOnce(SaveArg<1>(&decrypt_cb));
+  EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
+      .WillOnce(SaveArg<2>(&decrypt_cb));
   GenerateKeyRequest();
-  proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
   EXPECT_FALSE(decrypt_cb.is_null());
 
   // Even though the real decryptor returns kError, DeliverBuffer() should
   // still be called with kSuccess and NULL because we are canceling the
   // decryption.
-  EXPECT_CALL(*real_decryptor_, CancelDecrypt())
+  EXPECT_CALL(*real_decryptor_, CancelDecrypt(stream_type_))
       .WillOnce(ResetAndRunDecryptCB(&decrypt_cb,
                                      Decryptor::kError, null_buffer_));
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, null_buffer_))
       .WillOnce(ScheduleMessageLoopToStop(&message_loop_));
-  proxy_decryptor_.CancelDecrypt();
+  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)))
       .Times(AtLeast(1));
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+  EXPECT_CALL(*real_decryptor_, Decrypt(stream_type_, encrypted_buffer_, _))
       .WillRepeatedly(RunDecryptCB(Decryptor::kNoKey, null_buffer_));
-  proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
   GenerateKeyRequest();
 
   EXPECT_CALL(*this, DeliverBuffer(Decryptor::kSuccess, null_buffer_));
-  proxy_decryptor_.CancelDecrypt();
+  proxy_decryptor_.CancelDecrypt(stream_type_);
 
   AddKey();
 
-  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+  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(encrypted_buffer_, decrypt_cb_);
+  proxy_decryptor_.Decrypt(stream_type_, encrypted_buffer_, decrypt_cb_);
 
   message_loop_.Run();
 }
 
 }  // namespace webkit_media