Encrypted Media: Replace DecryptorClient with key event callbacks.

media/crypto/aes_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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "media/base/decoder_buffer.h"
@@ skipping 209 matching lines @@
           std::string(reinterpret_cast<const char*>(key_id), key_id_size),
           std::string(reinterpret_cast<const char*>(iv), iv_size),
           data_offset,
           subsample_entries)));
   return encrypted_buffer;
 }
 
 class AesDecryptorTest : public testing::Test {
  public:
   AesDecryptorTest()
-      : decryptor_(&client_),
+      : decryptor_(base::Bind(&AesDecryptorTest::KeyAdded,
+                              base::Unretained(this)),
+                   base::Bind(&AesDecryptorTest::KeyError,
+                              base::Unretained(this)),
+                   base::Bind(&AesDecryptorTest::KeyMessage,
+                              base::Unretained(this)),
+                   NeedKeyCB()),
         decrypt_cb_(base::Bind(&AesDecryptorTest::BufferDecrypted,
                                base::Unretained(this))),
         subsample_entries_(kSubsampleEntries,
                            kSubsampleEntries + arraysize(kSubsampleEntries)) {
   }
 
  protected:
   void GenerateKeyRequest(const uint8* key_id, int key_id_size) {
     std::string key_id_string(reinterpret_cast<const char*>(key_id),
                               key_id_size);
-    EXPECT_CALL(client_, KeyMessage(kClearKeySystem,
-                                    StrNe(""), StrEq(key_id_string), ""))
+    EXPECT_CALL(*this, KeyMessage(kClearKeySystem,
+                                  StrNe(""), StrEq(key_id_string), ""))
         .WillOnce(SaveArg<1>(&session_id_string_));
     EXPECT_TRUE(decryptor_.GenerateKeyRequest(kClearKeySystem, "",
                                               key_id, key_id_size));
   }
 
   void AddKeyAndExpectToSucceed(const uint8* key_id, int key_id_size,
                                 const uint8* key, int key_size) {
-    EXPECT_CALL(client_, KeyAdded(kClearKeySystem, session_id_string_));
+    EXPECT_CALL(*this, KeyAdded(kClearKeySystem, session_id_string_));
     decryptor_.AddKey(kClearKeySystem, key, key_size, key_id, key_id_size,
                       session_id_string_);
   }
 
   void AddKeyAndExpectToFail(const uint8* key_id, int key_id_size,
                              const uint8* key, int key_size) {
-    EXPECT_CALL(client_, KeyError(kClearKeySystem, session_id_string_,
-                                  Decryptor::kUnknownError, 0));
+    EXPECT_CALL(*this, KeyError(kClearKeySystem, session_id_string_,
+                                Decryptor::kUnknownError, 0));
     decryptor_.AddKey(kClearKeySystem, key, key_size, key_id, key_id_size,
                       session_id_string_);
   }
 
   MOCK_METHOD2(BufferDecrypted, void(Decryptor::Status,
                                      const scoped_refptr<DecoderBuffer>&));
 
   void DecryptAndExpectToSucceed(const scoped_refptr<DecoderBuffer>& encrypted,
                                  const uint8* plain_text, int plain_text_size) {
     scoped_refptr<DecoderBuffer> decrypted;
@@ skipping 30 matching lines @@
     ASSERT_TRUE(decrypted);
     EXPECT_NE(plain_text_size, decrypted->GetDataSize());
     EXPECT_NE(0, memcmp(plain_text, decrypted->GetData(), plain_text_size));
   }
 
   void DecryptAndExpectToFail(const scoped_refptr<DecoderBuffer>& encrypted) {
     EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kError, IsNull()));
     decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
   }
 
-  MockDecryptorClient client_;
+  MOCK_METHOD2(KeyAdded, void(const std::string&, const std::string&));
+  MOCK_METHOD4(KeyError, void(const std::string&, const std::string&,
+                              Decryptor::KeyError, int));
+  MOCK_METHOD4(KeyMessage, void(const std::string& key_system,
+                                const std::string& session_id,
+                                const std::string& message,
+                                const std::string& default_url));
+
   AesDecryptor decryptor_;
   std::string session_id_string_;
   AesDecryptor::DecryptCB decrypt_cb_;
   std::vector<SubsampleEntry> subsample_entries_;
 };
 
 TEST_F(AesDecryptorTest, GenerateKeyRequestWithNullInitData) {
-  EXPECT_CALL(client_, KeyMessage(kClearKeySystem, StrNe(""), "", ""));
+  EXPECT_CALL(*this, KeyMessage(kClearKeySystem, StrNe(""), "", ""));
   EXPECT_TRUE(decryptor_.GenerateKeyRequest(kClearKeySystem, "", NULL, 0));
 }
 
 TEST_F(AesDecryptorTest, NormalWebMDecryption) {
   const WebmEncryptedData& frame = kWebmEncryptedFrames[0];
   GenerateKeyRequest(frame.key_id, frame.key_id_size);
   AddKeyAndExpectToSucceed(frame.key_id, frame.key_id_size,
                            frame.key, frame.key_size);
   scoped_refptr<DecoderBuffer> encrypted_data =
       CreateWebMEncryptedBuffer(frame.encrypted_data,
@@ skipping 257 matching lines @@
   scoped_refptr<DecoderBuffer> encrypted_data = CreateSubsampleEncryptedBuffer(
       kSubsampleData, arraysize(kSubsampleData),
       kSubsampleKeyId, arraysize(kSubsampleKeyId),
       kSubsampleIv, arraysize(kSubsampleIv),
       0,
       entries);
   ASSERT_NO_FATAL_FAILURE(DecryptAndExpectToFail(encrypted_data));
 }
 
 }  // namespace media