Implement "Key Presence" step in "Encrypted Block Encounted" algorithm in EME.

webkit/media/crypto/proxy_decryptor_unittest.cc

Index: webkit/media/crypto/proxy_decryptor_unittest.cc
diff --git a/webkit/media/crypto/proxy_decryptor_unittest.cc b/webkit/media/crypto/proxy_decryptor_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6aa53628dd8d36c142304549a58ab1ee27d9eac5
--- /dev/null
+++ b/webkit/media/crypto/proxy_decryptor_unittest.cc
@@ -0,0 +1,201 @@
+// 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/memory/ref_counted.h"
+#include "base/message_loop.h"
+#include "media/base/decoder_buffer.h"
+#include "media/base/decrypt_config.h"
+#include "media/base/mock_filters.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::_;
+using ::testing::AtLeast;
+using ::testing::InvokeWithoutArgs;
+using ::testing::IsNull;
+using ::testing::NotNull;
+
+using media::DecoderBuffer;
+using media::DecryptConfig;
+using media::Decryptor;
+
+namespace webkit_media {
+
+static const uint8 kFakeKeyId[] = { 0x4b, 0x65, 0x79, 0x20, 0x49, 0x44 };
+static const uint8 kFakeIv[DecryptConfig::kDecryptionKeySize] = { 0 };
+static const uint8 kFakeCheckSum[] = { 0, 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(kFakeKeyId, arraysize(kFakeKeyId),
+                        kFakeIv, DecryptConfig::kDecryptionKeySize,
+                        kFakeCheckSum, arraysize(kFakeCheckSum),
+                        encrypted_frame_offset)));
+  return encrypted_buffer;
+}
+
+ACTION_P2(RunDecryptCB, status, buffer) {
+  arg1.Run(status, buffer);
+}
+
+// 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()
+      : decryptor_(&client_, NULL, NULL),
+        real_decryptor_(new media::MockDecryptor()),
+        encrypted_buffer_(CreateFakeEncryptedBuffer()),
+        decrypted_buffer_(DecoderBuffer::CopyFrom(kDecryptedData,
+                                                  arraysize(kDecryptedData))),
+        null_buffer_(scoped_refptr<DecoderBuffer>()),
+        decrypt_cb_(base::Bind(&ProxyDecryptorTest::BufferDecrypted,
+                               base::Unretained(this))) {
+  }
+
+  // Instead of calling ProxyDecryptor::GenerateKeyRequest() here to create a
+  // real Decryptor, inject a MockDecryptor for testing purpose.
+  void GenerateKeyRequest() {
+    decryptor_.set_decryptor(scoped_ptr<Decryptor>(real_decryptor_));
+  }
+
+  // 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),
+                                         kFakeKey, arraysize(kFakeKey),
+                                         kFakeSessionId));
+    decryptor_.AddKey(kFakeKeySystem,
+                      kFakeKeyId, arraysize(kFakeKeyId),
+                      kFakeKey, arraysize(kFakeKey),
+                      kFakeSessionId);
+  }
+
+  void StopMessageLoop() {
+    message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
+  }
+
+  MOCK_METHOD2(BufferDecrypted, void(Decryptor::DecryptStatus,
+                                     const scoped_refptr<DecoderBuffer>&));
+
+ protected:
+  MessageLoop message_loop_;
+  media::MockDecryptorClient client_;
+  ProxyDecryptor decryptor_;
+  media::MockDecryptor* real_decryptor_;
+  scoped_refptr<DecoderBuffer> encrypted_buffer_;
+  scoped_refptr<DecoderBuffer> decrypted_buffer_;
+  scoped_refptr<DecoderBuffer> null_buffer_;
+  Decryptor::DecryptCB decrypt_cb_;
+};

[scherkus (not reviewing), 2012/07/28 23:07:19]

DISALLLOW etc

[xhwang, 2012/07/30 19:58:10]

Done.

+
+// Tests a typical use case: GKR(), AddKey() and Decrypt() succeeds.
+TEST_F(ProxyDecryptorTest, NormalDecryption_Success) {
+  GenerateKeyRequest();
+  AddKey();
+
+  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+      .WillOnce(RunDecryptCB(Decryptor::kSuccess, decrypted_buffer_));
+  EXPECT_CALL(*this, BufferDecrypted(Decryptor::kSuccess, decrypted_buffer_));
+  decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+}
+
+// Tests the case where Decrypt() fails.
+TEST_F(ProxyDecryptorTest, NormalDecryption_Error) {
+  GenerateKeyRequest();
+  AddKey();
+
+  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+      .WillOnce(RunDecryptCB(Decryptor::kError, null_buffer_));
+  EXPECT_CALL(*this, BufferDecrypted(Decryptor::kError, IsNull()));
+  decryptor_.Decrypt(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_, _))
+      .WillOnce(RunDecryptCB(Decryptor::kNoKey, null_buffer_));
+  EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId)));
+  decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+}
+
+// Tests the case where Decrypt() is called before GKR() is called and the right
+// key is added.
+TEST_F(ProxyDecryptorTest, DecryptBeforeGenerateKeyRequest) {
+  EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId)));
+  decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+
+  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+      .WillOnce(RunDecryptCB(Decryptor::kSuccess, decrypted_buffer_));
+  EXPECT_CALL(*this, BufferDecrypted(Decryptor::kSuccess, decrypted_buffer_))
+      .WillOnce(InvokeWithoutArgs(this, &ProxyDecryptorTest::StopMessageLoop));
+  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));
+  decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+
+  EXPECT_CALL(*real_decryptor_, Decrypt(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_, _))
+      .WillOnce(RunDecryptCB(Decryptor::kSuccess, decrypted_buffer_));
+  EXPECT_CALL(*this, BufferDecrypted(Decryptor::kSuccess, decrypted_buffer_))
+      .WillOnce(InvokeWithoutArgs(this, &ProxyDecryptorTest::StopMessageLoop));
+  AddKey();  // Correct key added.
+  message_loop_.Run();
+}
+
+// Tests the case where Decrypt() is called multiple times (e.g. from multiple
+// stream) before the right key is added via AddKey().
+TEST_F(ProxyDecryptorTest, MultiplePendingDecryptions) {
+  EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId)))
+      .Times(AtLeast(1));
+  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+      .WillRepeatedly(RunDecryptCB(Decryptor::kNoKey, null_buffer_));
+  decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  GenerateKeyRequest();
+  decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+  AddKey();  // An irrelevant key is added.
+  decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_);
+
+  EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _))
+      .WillRepeatedly(RunDecryptCB(Decryptor::kSuccess, decrypted_buffer_));
+  EXPECT_CALL(*this, BufferDecrypted(Decryptor::kSuccess, decrypted_buffer_))
+      .Times(3);
+  AddKey();  // Correct key added.
+
+  StopMessageLoop();

[scherkus (not reviewing), 2012/07/28 23:08:03]

this method name is misleading as it only posts a quit closure but doesn't
actually stop the message loop

[xhwang, 2012/07/30 19:58:10]

Renamed to ScheduleMessageLoopToStop().

+  message_loop_.Run();
+}
+
+}  // namespace webkit_media