media: Make MediaKeys ref-counted.

media/cdm/aes_decryptor_unittest.cc

 // Copyright 2013 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 "base/json/json_reader.h"
@@ skipping 196 matching lines @@
   encrypted_buffer->set_decrypt_config(scoped_ptr<DecryptConfig>(
       new DecryptConfig(key_id_string, iv_string, subsample_entries)));
   return encrypted_buffer;
 }
 
 enum PromiseResult { RESOLVED, REJECTED };
 
 class AesDecryptorTest : public testing::Test {
  public:
   AesDecryptorTest()
-      : decryptor_(GURL::EmptyGURL(),
-                   base::Bind(&AesDecryptorTest::OnSessionMessage,
-                              base::Unretained(this)),
-                   base::Bind(&AesDecryptorTest::OnSessionClosed,
-                              base::Unretained(this)),
-                   base::Bind(&AesDecryptorTest::OnSessionKeysChange,
-                              base::Unretained(this))),
+      : decryptor_(
+            new AesDecryptor(GURL::EmptyGURL(),
+                             base::Bind(&AesDecryptorTest::OnSessionMessage,
+                                        base::Unretained(this)),
+                             base::Bind(&AesDecryptorTest::OnSessionClosed,
+                                        base::Unretained(this)),
+                             base::Bind(&AesDecryptorTest::OnSessionKeysChange,
+                                        base::Unretained(this)))),
         decrypt_cb_(base::Bind(&AesDecryptorTest::BufferDecrypted,
                                base::Unretained(this))),
         original_data_(kOriginalData, kOriginalData + kOriginalDataSize),
         encrypted_data_(kEncryptedData,
                         kEncryptedData + arraysize(kEncryptedData)),
         subsample_encrypted_data_(
             kSubsampleEncryptedData,
             kSubsampleEncryptedData + arraysize(kSubsampleEncryptedData)),
         key_id_(kKeyId, kKeyId + arraysize(kKeyId)),
         iv_(kIv, kIv + arraysize(kIv)),
         normal_subsample_entries_(
             kSubsampleEntriesNormal,
-            kSubsampleEntriesNormal + arraysize(kSubsampleEntriesNormal)) {
-  }
+            kSubsampleEntriesNormal + arraysize(kSubsampleEntriesNormal)) {}
 
  protected:
   void OnResolveWithSession(PromiseResult expected_result,
                             const std::string& session_id) {
     EXPECT_EQ(expected_result, RESOLVED) << "Unexpectedly resolved.";
     EXPECT_GT(session_id.length(), 0ul);
     session_id_ = session_id;
   }
 
   void OnResolve(PromiseResult expected_result) {
@@ skipping 30 matching lines @@
                        base::Unretained(this),
                        expected_result)));
     return promise.Pass();
   }
 
   // Creates a new session using |key_id|. Returns the session ID.
   std::string CreateSession(const std::vector<uint8>& key_id) {
     DCHECK(!key_id.empty());
     EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsJSONDictionary(),
                                         GURL::EmptyGURL()));
-    decryptor_.CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
-                                               EmeInitDataType::WEBM, key_id,
-                                               CreateSessionPromise(RESOLVED));
+    decryptor_->CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
+                                                EmeInitDataType::WEBM, key_id,
+                                                CreateSessionPromise(RESOLVED));
     // This expects the promise to be called synchronously, which is the case
     // for AesDecryptor.
     return session_id_;
   }
 
   // Closes the session specified by |session_id|.
   void CloseSession(const std::string& session_id) {
     EXPECT_CALL(*this, OnSessionClosed(session_id));
-    decryptor_.CloseSession(session_id, CreatePromise(RESOLVED));
+    decryptor_->CloseSession(session_id, CreatePromise(RESOLVED));
   }
 
   // Removes the session specified by |session_id|. This should simply do a
   // CloseSession().
   // TODO(jrummell): Clean this up when the prefixed API is removed.
   // http://crbug.com/249976.
   void RemoveSession(const std::string& session_id) {
     EXPECT_CALL(*this, OnSessionClosed(session_id));
-    decryptor_.RemoveSession(session_id, CreatePromise(RESOLVED));
+    decryptor_->RemoveSession(session_id, CreatePromise(RESOLVED));
   }
 
   MOCK_METHOD2(OnSessionKeysChangeCalled,
                void(const std::string& session_id,
                     bool has_additional_usable_key));
 
   void OnSessionKeysChange(const std::string& session_id,
                            bool has_additional_usable_key,
                            CdmKeysInfo keys_info) {
     keys_info_.swap(keys_info);
     OnSessionKeysChangeCalled(session_id, has_additional_usable_key);
   }
 
   // Updates the session specified by |session_id| with |key|. |result|
   // tests that the update succeeds or generates an error.
   void UpdateSessionAndExpect(std::string session_id,
                               const std::string& key,
                               PromiseResult expected_result,
                               bool new_key_expected) {
     DCHECK(!key.empty());
 
     if (expected_result == RESOLVED) {
       EXPECT_CALL(*this,
                   OnSessionKeysChangeCalled(session_id, new_key_expected));
     } else {
       EXPECT_CALL(*this, OnSessionKeysChangeCalled(_, _)).Times(0);
     }
 
-    decryptor_.UpdateSession(session_id,
-                             std::vector<uint8>(key.begin(), key.end()),
-                             CreatePromise(expected_result));
+    decryptor_->UpdateSession(session_id,
+                              std::vector<uint8>(key.begin(), key.end()),
+                              CreatePromise(expected_result));
   }
 
   bool KeysInfoContains(std::vector<uint8> expected) {
     for (const auto& key_id : keys_info_) {
       if (key_id->key_id == expected)
         return true;
     }
     return false;
   }
 
@@ skipping 23 matching lines @@
       case DECRYPT_ERROR:
         EXPECT_CALL(*this, BufferDecrypted(Decryptor::kError, IsNull()))
             .WillOnce(SaveArg<1>(&decrypted));
         break;
       case NO_KEY:
         EXPECT_CALL(*this, BufferDecrypted(Decryptor::kNoKey, IsNull()))
             .WillOnce(SaveArg<1>(&decrypted));
         break;
     }
 
-    decryptor_.Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
+    decryptor_->Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
 
     std::vector<uint8> decrypted_text;
     if (decrypted.get() && decrypted->data_size()) {
       decrypted_text.assign(
         decrypted->data(), decrypted->data() + decrypted->data_size());
     }
 
     switch (result) {
       case SUCCESS:
         EXPECT_EQ(plain_text, decrypted_text);
@@ skipping 12 matching lines @@
     }
   }
 
   MOCK_METHOD4(OnSessionMessage,
                void(const std::string& session_id,
                     MediaKeys::MessageType message_type,
                     const std::vector<uint8>& message,
                     const GURL& legacy_destination_url));
   MOCK_METHOD1(OnSessionClosed, void(const std::string& session_id));
 
-  AesDecryptor decryptor_;
+  scoped_refptr<AesDecryptor> decryptor_;
   AesDecryptor::DecryptCB decrypt_cb_;
   std::string session_id_;
   CdmKeysInfo keys_info_;
 
   // Constants for testing.
   const std::vector<uint8> original_data_;
   const std::vector<uint8> encrypted_data_;
   const std::vector<uint8> subsample_encrypted_data_;
   const std::vector<uint8> key_id_;
   const std::vector<uint8> iv_;
   const std::vector<SubsampleEntry> normal_subsample_entries_;
   const std::vector<SubsampleEntry> no_subsample_entries_;
 };
 
 TEST_F(AesDecryptorTest, CreateSessionWithNullInitData) {
   EXPECT_CALL(*this,
               OnSessionMessage(IsNotEmpty(), _, IsEmpty(), GURL::EmptyGURL()));
-  decryptor_.CreateSessionAndGenerateRequest(
+  decryptor_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM, std::vector<uint8>(),
       CreateSessionPromise(RESOLVED));
 }
 
 TEST_F(AesDecryptorTest, MultipleCreateSession) {
   EXPECT_CALL(*this,
               OnSessionMessage(IsNotEmpty(), _, IsEmpty(), GURL::EmptyGURL()));
-  decryptor_.CreateSessionAndGenerateRequest(
+  decryptor_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM, std::vector<uint8>(),
       CreateSessionPromise(RESOLVED));
 
   EXPECT_CALL(*this,
               OnSessionMessage(IsNotEmpty(), _, IsEmpty(), GURL::EmptyGURL()));
-  decryptor_.CreateSessionAndGenerateRequest(
+  decryptor_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM, std::vector<uint8>(),
       CreateSessionPromise(RESOLVED));
 
   EXPECT_CALL(*this,
               OnSessionMessage(IsNotEmpty(), _, IsEmpty(), GURL::EmptyGURL()));
-  decryptor_.CreateSessionAndGenerateRequest(
+  decryptor_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM, std::vector<uint8>(),
       CreateSessionPromise(RESOLVED));
 }
 
 TEST_F(AesDecryptorTest, CreateSessionWithCencInitData) {
   const uint8 init_data[] = {
       0x00, 0x00, 0x00, 0x44,                          // size = 68
       0x70, 0x73, 0x73, 0x68,                          // 'pssh'
       0x01,                                            // version
       0x00, 0x00, 0x00,                                // flags
       0x10, 0x77, 0xEF, 0xEC, 0xC0, 0xB2, 0x4D, 0x02,  // SystemID
       0xAC, 0xE3, 0x3C, 0x1E, 0x52, 0xE2, 0xFB, 0x4B,
       0x00, 0x00, 0x00, 0x02,                          // key count
       0x7E, 0x57, 0x1D, 0x03, 0x7E, 0x57, 0x1D, 0x03,  // key1
       0x7E, 0x57, 0x1D, 0x03, 0x7E, 0x57, 0x1D, 0x03,
       0x7E, 0x57, 0x1D, 0x04, 0x7E, 0x57, 0x1D, 0x04,  // key2
       0x7E, 0x57, 0x1D, 0x04, 0x7E, 0x57, 0x1D, 0x04,
       0x00, 0x00, 0x00, 0x00  // datasize
   };
 #if defined(USE_PROPRIETARY_CODECS)
   EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsJSONDictionary(),
                                       GURL::EmptyGURL()));
-  decryptor_.CreateSessionAndGenerateRequest(
+  decryptor_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::CENC,
       std::vector<uint8>(init_data, init_data + arraysize(init_data)),
       CreateSessionPromise(RESOLVED));
 #else
-  decryptor_.CreateSessionAndGenerateRequest(
+  decryptor_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::CENC,
       std::vector<uint8>(init_data, init_data + arraysize(init_data)),
       CreateSessionPromise(REJECTED));
 #endif
 }
 
 TEST_F(AesDecryptorTest, CreateSessionWithKeyIdsInitData) {
   const char init_data[] =
       "{\"kids\":[\"AQI\",\"AQIDBA\",\"AQIDBAUGBwgJCgsMDQ4PEA\"]}";
 
   EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsJSONDictionary(),
                                       GURL::EmptyGURL()));
-  decryptor_.CreateSessionAndGenerateRequest(
+  decryptor_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::KEYIDS,
       std::vector<uint8>(init_data, init_data + arraysize(init_data) - 1),
       CreateSessionPromise(RESOLVED));
 }
 
 TEST_F(AesDecryptorTest, NormalDecryption) {
   std::string session_id = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, true);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, no_subsample_entries_);
@@ skipping 12 matching lines @@
   UpdateSessionAndExpect(session_id, kWrongKeyAsJWK, RESOLVED, true);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, no_subsample_entries_);
   DecryptAndExpect(encrypted_buffer, original_data_, DATA_MISMATCH);
 }
 
 TEST_F(AesDecryptorTest, NoKey) {
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, no_subsample_entries_);
   EXPECT_CALL(*this, BufferDecrypted(AesDecryptor::kNoKey, IsNull()));
-  decryptor_.Decrypt(Decryptor::kVideo, encrypted_buffer, decrypt_cb_);
+  decryptor_->Decrypt(Decryptor::kVideo, encrypted_buffer, decrypt_cb_);
 }
 
 TEST_F(AesDecryptorTest, KeyReplacement) {
   std::string session_id = CreateSession(key_id_);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, no_subsample_entries_);
 
   UpdateSessionAndExpect(session_id, kWrongKeyAsJWK, RESOLVED, true);
   ASSERT_NO_FATAL_FAILURE(DecryptAndExpect(
       encrypted_buffer, original_data_, DATA_MISMATCH));
@@ skipping 397 matching lines @@
   // Add key a second time.
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, false);
   EXPECT_TRUE(KeysInfoContains(key_id));
 
   // Create a new session. Add key, should indicate key added for this session.
   std::string session_id2 = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id2, kKeyAsJWK, RESOLVED, true);
 }
 
 }  // namespace media