OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "webkit/media/crypto/proxy_decryptor.h" |
| 6 |
| 7 #include "base/basictypes.h" |
| 8 #include "base/bind.h" |
| 9 #include "base/memory/ref_counted.h" |
| 10 #include "base/message_loop.h" |
| 11 #include "media/base/decoder_buffer.h" |
| 12 #include "media/base/decrypt_config.h" |
| 13 #include "media/base/mock_filters.h" |
| 14 #include "testing/gmock/include/gmock/gmock.h" |
| 15 #include "testing/gtest/include/gtest/gtest.h" |
| 16 |
| 17 using ::testing::_; |
| 18 using ::testing::AtLeast; |
| 19 using ::testing::IsNull; |
| 20 using ::testing::NotNull; |
| 21 |
| 22 using media::DecoderBuffer; |
| 23 using media::DecryptConfig; |
| 24 using media::Decryptor; |
| 25 |
| 26 namespace webkit_media { |
| 27 |
| 28 static const uint8 kFakeKeyId[] = { 0x4b, 0x65, 0x79, 0x20, 0x49, 0x44 }; |
| 29 static const uint8 kFakeIv[DecryptConfig::kDecryptionKeySize] = { 0 }; |
| 30 static const uint8 kFakeCheckSum[] = { 0, 0 }; |
| 31 static const char kFakeKeySystem[] = "system.key.fake"; |
| 32 static const char kFakeSessionId[] = "FakeSessionId"; |
| 33 static const uint8 kFakeKey[] = { 0x4b, 0x65, 0x79 }; |
| 34 static const uint8 kEncryptedData[] = { 0x65, 0x6E, 0x63, 0x72, 0x79 }; |
| 35 static const uint8 kDecryptedData[] = { 0x64, 0x65, 0x63, 0x72, 0x79 }; |
| 36 |
| 37 // Creates a fake non-empty encrypted buffer. |
| 38 static scoped_refptr<DecoderBuffer> CreateFakeEncryptedBuffer() { |
| 39 const int encrypted_frame_offset = 1; // This should be non-zero. |
| 40 scoped_refptr<DecoderBuffer> encrypted_buffer = |
| 41 DecoderBuffer::CopyFrom(kEncryptedData, arraysize(kEncryptedData)); |
| 42 encrypted_buffer->SetDecryptConfig(scoped_ptr<DecryptConfig>( |
| 43 new DecryptConfig( |
| 44 std::string(reinterpret_cast<const char*>(kFakeKeyId), |
| 45 arraysize(kFakeKeyId)), |
| 46 std::string(reinterpret_cast<const char*>(kFakeIv), |
| 47 DecryptConfig::kDecryptionKeySize), |
| 48 std::string(reinterpret_cast<const char*>(kFakeCheckSum), |
| 49 arraysize(kFakeCheckSum)), |
| 50 encrypted_frame_offset, |
| 51 std::vector<media::SubsampleEntry>()))); |
| 52 return encrypted_buffer; |
| 53 } |
| 54 |
| 55 ACTION_P2(RunDecryptCB, status, buffer) { |
| 56 arg1.Run(status, buffer); |
| 57 } |
| 58 |
| 59 ACTION_P(ScheduleMessageLoopToStop, message_loop) { |
| 60 message_loop->PostTask(FROM_HERE, MessageLoop::QuitClosure()); |
| 61 } |
| 62 |
| 63 // Tests the interaction between external Decryptor calls and concrete Decryptor |
| 64 // implementations. This test is not interested in any specific Decryptor |
| 65 // implementation. A MockDecryptor is used here to serve this purpose. |
| 66 class ProxyDecryptorTest : public testing::Test { |
| 67 public: |
| 68 ProxyDecryptorTest() |
| 69 : proxy_decryptor_(&client_, NULL, NULL), |
| 70 real_decryptor_(new media::MockDecryptor()), |
| 71 encrypted_buffer_(CreateFakeEncryptedBuffer()), |
| 72 decrypted_buffer_(DecoderBuffer::CopyFrom(kDecryptedData, |
| 73 arraysize(kDecryptedData))), |
| 74 null_buffer_(scoped_refptr<DecoderBuffer>()), |
| 75 decrypt_cb_(base::Bind(&ProxyDecryptorTest::BufferDecrypted, |
| 76 base::Unretained(this))) { |
| 77 } |
| 78 |
| 79 // Instead of calling ProxyDecryptor::GenerateKeyRequest() here to create a |
| 80 // real Decryptor, inject a MockDecryptor for testing purpose. |
| 81 void GenerateKeyRequest() { |
| 82 proxy_decryptor_.set_decryptor_for_testing( |
| 83 scoped_ptr<Decryptor>(real_decryptor_)); |
| 84 } |
| 85 |
| 86 // Since we are using the MockDecryptor, we can simulate any decryption |
| 87 // behavior we want. Therefore, we do not care which key is really added, |
| 88 // hence always use fake key IDs and keys. |
| 89 void AddKey() { |
| 90 EXPECT_CALL(*real_decryptor_, AddKey(kFakeKeySystem, |
| 91 kFakeKeyId, arraysize(kFakeKeyId), |
| 92 kFakeKey, arraysize(kFakeKey), |
| 93 kFakeSessionId)); |
| 94 proxy_decryptor_.AddKey(kFakeKeySystem, |
| 95 kFakeKeyId, arraysize(kFakeKeyId), |
| 96 kFakeKey, arraysize(kFakeKey), |
| 97 kFakeSessionId); |
| 98 } |
| 99 |
| 100 MOCK_METHOD2(BufferDecrypted, void(Decryptor::DecryptStatus, |
| 101 const scoped_refptr<DecoderBuffer>&)); |
| 102 |
| 103 protected: |
| 104 MessageLoop message_loop_; |
| 105 media::MockDecryptorClient client_; |
| 106 ProxyDecryptor proxy_decryptor_; |
| 107 media::MockDecryptor* real_decryptor_; |
| 108 scoped_refptr<DecoderBuffer> encrypted_buffer_; |
| 109 scoped_refptr<DecoderBuffer> decrypted_buffer_; |
| 110 scoped_refptr<DecoderBuffer> null_buffer_; |
| 111 Decryptor::DecryptCB decrypt_cb_; |
| 112 |
| 113 private: |
| 114 DISALLOW_COPY_AND_ASSIGN(ProxyDecryptorTest); |
| 115 }; |
| 116 |
| 117 // Tests a typical use case: GKR(), AddKey() and Decrypt() succeeds. |
| 118 TEST_F(ProxyDecryptorTest, NormalDecryption_Success) { |
| 119 GenerateKeyRequest(); |
| 120 AddKey(); |
| 121 |
| 122 EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _)) |
| 123 .WillOnce(RunDecryptCB(Decryptor::kSuccess, decrypted_buffer_)); |
| 124 EXPECT_CALL(*this, BufferDecrypted(Decryptor::kSuccess, decrypted_buffer_)); |
| 125 proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_); |
| 126 } |
| 127 |
| 128 // Tests the case where Decrypt() fails. |
| 129 TEST_F(ProxyDecryptorTest, NormalDecryption_Error) { |
| 130 GenerateKeyRequest(); |
| 131 AddKey(); |
| 132 |
| 133 EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _)) |
| 134 .WillOnce(RunDecryptCB(Decryptor::kError, null_buffer_)); |
| 135 EXPECT_CALL(*this, BufferDecrypted(Decryptor::kError, IsNull())); |
| 136 proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_); |
| 137 } |
| 138 |
| 139 // Tests the case where no key is available for decryption. |
| 140 TEST_F(ProxyDecryptorTest, NormalDecryption_NoKey) { |
| 141 GenerateKeyRequest(); |
| 142 |
| 143 EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _)) |
| 144 .WillOnce(RunDecryptCB(Decryptor::kNoKey, null_buffer_)); |
| 145 EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId))); |
| 146 proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_); |
| 147 } |
| 148 |
| 149 // Tests the case where Decrypt() is called before GKR() is called and the right |
| 150 // key is added. |
| 151 TEST_F(ProxyDecryptorTest, DecryptBeforeGenerateKeyRequest) { |
| 152 EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId))); |
| 153 proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_); |
| 154 |
| 155 EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _)) |
| 156 .WillOnce(RunDecryptCB(Decryptor::kSuccess, decrypted_buffer_)); |
| 157 EXPECT_CALL(*this, BufferDecrypted(Decryptor::kSuccess, decrypted_buffer_)) |
| 158 .WillOnce(ScheduleMessageLoopToStop(&message_loop_)); |
| 159 GenerateKeyRequest(); |
| 160 AddKey(); |
| 161 message_loop_.Run(); |
| 162 } |
| 163 |
| 164 // Tests the case where multiple AddKey() is called to add some irrelevant keys |
| 165 // before the real key that can decrypt |encrypted_buffer_| is added. |
| 166 TEST_F(ProxyDecryptorTest, MultipleAddKeys) { |
| 167 EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId))) |
| 168 .Times(AtLeast(1)); |
| 169 proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_); |
| 170 |
| 171 EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _)) |
| 172 .WillRepeatedly(RunDecryptCB(Decryptor::kNoKey, null_buffer_)); |
| 173 GenerateKeyRequest(); |
| 174 const int number_of_irrelevant_addkey = 5; |
| 175 for (int i = 0; i < number_of_irrelevant_addkey; ++i) |
| 176 AddKey(); // Some irrelevant keys are added. |
| 177 |
| 178 EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _)) |
| 179 .WillOnce(RunDecryptCB(Decryptor::kSuccess, decrypted_buffer_)); |
| 180 EXPECT_CALL(*this, BufferDecrypted(Decryptor::kSuccess, decrypted_buffer_)) |
| 181 .WillOnce(ScheduleMessageLoopToStop(&message_loop_)); |
| 182 AddKey(); // Correct key added. |
| 183 message_loop_.Run(); |
| 184 } |
| 185 |
| 186 // Tests the case where Decrypt() is called multiple times (e.g. from multiple |
| 187 // stream) before the right key is added via AddKey(). |
| 188 TEST_F(ProxyDecryptorTest, MultiplePendingDecryptions) { |
| 189 EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId))) |
| 190 .Times(AtLeast(1)); |
| 191 EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _)) |
| 192 .WillRepeatedly(RunDecryptCB(Decryptor::kNoKey, null_buffer_)); |
| 193 proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_); |
| 194 GenerateKeyRequest(); |
| 195 proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_); |
| 196 AddKey(); // An irrelevant key is added. |
| 197 proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_); |
| 198 |
| 199 EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _)) |
| 200 .WillRepeatedly(RunDecryptCB(Decryptor::kSuccess, decrypted_buffer_)); |
| 201 EXPECT_CALL(*this, BufferDecrypted(Decryptor::kSuccess, decrypted_buffer_)) |
| 202 .Times(3); |
| 203 AddKey(); // Correct key added. |
| 204 |
| 205 message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure()); |
| 206 message_loop_.Run(); |
| 207 } |
| 208 |
| 209 TEST_F(ProxyDecryptorTest, StopWhenDecryptionsPending) { |
| 210 EXPECT_CALL(client_, NeedKeyMock("", "", NotNull(), arraysize(kFakeKeyId))) |
| 211 .Times(AtLeast(1)); |
| 212 EXPECT_CALL(*real_decryptor_, Decrypt(encrypted_buffer_, _)) |
| 213 .WillRepeatedly(RunDecryptCB(Decryptor::kNoKey, null_buffer_)); |
| 214 proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_); |
| 215 GenerateKeyRequest(); |
| 216 proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_); |
| 217 AddKey(); // An irrelevant key is added. |
| 218 proxy_decryptor_.Decrypt(encrypted_buffer_, decrypt_cb_); |
| 219 |
| 220 EXPECT_CALL(*real_decryptor_, Stop()); |
| 221 EXPECT_CALL(*this, BufferDecrypted(Decryptor::kError, null_buffer_)) |
| 222 .Times(3); |
| 223 proxy_decryptor_.Stop(); |
| 224 |
| 225 message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure()); |
| 226 message_loop_.Run(); |
| 227 } |
| 228 |
| 229 } // namespace webkit_media |
OLD | NEW |