media: Add MockCdmClient

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 "media/cdm/aes_decryptor.h"
 
 #include <stdint.h>
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 20 matching lines @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest-param-test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using ::testing::_;
 using ::testing::Gt;
 using ::testing::IsNull;
 using ::testing::NotNull;
 using ::testing::SaveArg;
+using ::testing::StrictMock;
 using ::testing::StrNe;
 using ::testing::Unused;
 
 MATCHER(IsEmpty, "") { return arg.empty(); }
-MATCHER(IsNotEmpty, "") { return !arg.empty(); }
+MATCHER(NotEmpty, "") {

[xhwang, 2016/12/06 20:51:49]

IsEmpty/NotEmpty is consistent with IsNull/NotNull, and saves us 2 chars :)

+  return !arg.empty();
+}
 MATCHER(IsJSONDictionary, "") {
   std::string result(arg.begin(), arg.end());
   std::unique_ptr<base::Value> root(base::JSONReader().ReadToValue(result));
   return (root.get() && root->GetType() == base::Value::TYPE_DICTIONARY);
 }
 
 namespace media {
 
 const uint8_t kOriginalData[] = "Original subsample data.";
 const int kOriginalDataSize = 24;
@@ skipping 175 matching lines @@
         iv_(kIv, kIv + arraysize(kIv)),
         normal_subsample_entries_(
             kSubsampleEntriesNormal,
             kSubsampleEntriesNormal + arraysize(kSubsampleEntriesNormal)) {}
 
  protected:
   void SetUp() override {
     if (GetParam() == "AesDecryptor") {
       OnCdmCreated(
           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))),
+                           base::Bind(&MockCdmClient::OnSessionMessage,
+                                      base::Unretained(&cdm_client_)),
+                           base::Bind(&MockCdmClient::OnSessionClosed,
+                                      base::Unretained(&cdm_client_)),
+                           base::Bind(&MockCdmClient::OnSessionKeysChange,
+                                      base::Unretained(&cdm_client_))),
           std::string());
     } else if (GetParam() == "CdmAdapter") {
       CdmConfig cdm_config;  // default settings of false are sufficient.
 
       helper_.reset(new ExternalClearKeyTestHelper());
       std::unique_ptr<CdmAllocator> allocator(new SimpleCdmAllocator());
       CdmAdapter::Create(
           helper_->KeySystemName(), helper_->LibraryPath(), cdm_config,
           std::move(allocator), base::Bind(&AesDecryptorTest::CreateCdmFileIO,
                                            base::Unretained(this)),
-          base::Bind(&AesDecryptorTest::OnSessionMessage,
-                     base::Unretained(this)),
-          base::Bind(&AesDecryptorTest::OnSessionClosed,
-                     base::Unretained(this)),
-          base::Bind(&AesDecryptorTest::OnSessionKeysChange,
-                     base::Unretained(this)),
-          base::Bind(&AesDecryptorTest::OnSessionExpirationUpdate,
-                     base::Unretained(this)),
+          base::Bind(&MockCdmClient::OnSessionMessage,
+                     base::Unretained(&cdm_client_)),
+          base::Bind(&MockCdmClient::OnSessionClosed,
+                     base::Unretained(&cdm_client_)),
+          base::Bind(&MockCdmClient::OnSessionKeysChange,
+                     base::Unretained(&cdm_client_)),
+          base::Bind(&MockCdmClient::OnSessionExpirationUpdate,
+                     base::Unretained(&cdm_client_)),
           base::Bind(&AesDecryptorTest::OnCdmCreated, base::Unretained(this)));
 
       base::RunLoop().RunUntilIdle();
     }
   }
 
   void TearDown() override {
     if (GetParam() == "CdmAdapter")
       helper_.reset();
   }
@@ skipping 41 matching lines @@
             base::Bind(&AesDecryptorTest::OnResolveWithSession,
                        base::Unretained(this), expected_result),
             base::Bind(&AesDecryptorTest::OnReject, base::Unretained(this),
                        expected_result)));
     return promise;
   }
 
   // Creates a new session using |key_id|. Returns the session ID.
   std::string CreateSession(const std::vector<uint8_t>& key_id) {
     DCHECK(!key_id.empty());
-    EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsJSONDictionary()));
+    EXPECT_CALL(cdm_client_,
+                OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
     cdm_->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));
+    EXPECT_CALL(cdm_client_, OnSessionClosed(session_id));
     cdm_->CloseSession(session_id, CreatePromise(RESOLVED));
   }
 
   // Only persistent sessions can be removed.
   void RemoveSession(const std::string& session_id) {
     // TODO(ddorwin): This should be RESOLVED after https://crbug.com/616166.
     cdm_->RemoveSession(session_id, CreatePromise(REJECTED));
   }
 
-  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,
                               ExpectedResult expected_result,
                               bool new_key_expected) {
     DCHECK(!key.empty());
 
     if (expected_result == RESOLVED) {
-      EXPECT_CALL(*this,
+      EXPECT_CALL(cdm_client_,
                   OnSessionKeysChangeCalled(session_id, new_key_expected));
     } else {
-      EXPECT_CALL(*this, OnSessionKeysChangeCalled(_, _)).Times(0);
+      EXPECT_CALL(cdm_client_, OnSessionKeysChangeCalled(_, _)).Times(0);
     }
 
     cdm_->UpdateSession(session_id,
                         std::vector<uint8_t>(key.begin(), key.end()),
                         CreatePromise(expected_result));
   }
 
-  bool KeysInfoContains(std::vector<uint8_t> expected) {
-    for (auto* key_id : keys_info_) {
+  bool KeysInfoContains(const std::vector<uint8_t>& expected) {
+    for (auto* key_id : cdm_client_.keys_info()) {
       if (key_id->key_id == expected)
         return true;
     }
     return false;
   }
 
   MOCK_METHOD2(BufferDecrypted, void(Decryptor::Status,
                                      const scoped_refptr<DecoderBuffer>&));
 
   enum DecryptExpectation {
@@ skipping 55 matching lines @@
         EXPECT_TRUE(decrypted_text.empty());
         break;
     }
   }
 
   std::unique_ptr<CdmFileIO> CreateCdmFileIO(cdm::FileIOClient* client) {
     ADD_FAILURE() << "Should never be called";
     return nullptr;
   }
 
-  MOCK_METHOD3(OnSessionMessage,
-               void(const std::string& session_id,
-                    MediaKeys::MessageType message_type,
-                    const std::vector<uint8_t>& message));
-  MOCK_METHOD1(OnSessionClosed, void(const std::string& session_id));
-  MOCK_METHOD2(OnSessionExpirationUpdate,
-               void(const std::string& session_id, base::Time new_expiry_time));
-
+  StrictMock<MockCdmClient> cdm_client_;
   scoped_refptr<MediaKeys> cdm_;
   Decryptor* decryptor_;
   Decryptor::DecryptCB decrypt_cb_;
   std::string session_id_;
-  CdmKeysInfo keys_info_;
 
   // Helper class to load/unload External Clear Key Library, if necessary.
   std::unique_ptr<ExternalClearKeyTestHelper> helper_;
 
   base::MessageLoop message_loop_;
 
   // Constants for testing.
   const std::vector<uint8_t> original_data_;
   const std::vector<uint8_t> encrypted_data_;
   const std::vector<uint8_t> subsample_encrypted_data_;
@@ skipping 11 matching lines @@
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::CENC,
       std::vector<uint8_t>(), CreateSessionPromise(REJECTED));
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::KEYIDS,
       std::vector<uint8_t>(), CreateSessionPromise(REJECTED));
 }
 
 TEST_P(AesDecryptorTest, CreateSessionWithVariousLengthInitData_WebM) {
   std::vector<uint8_t> init_data;
   init_data.resize(1);
+  EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
       std::vector<uint8_t>(init_data), CreateSessionPromise(RESOLVED));
 
   init_data.resize(16);  // The expected size.
+  EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
       std::vector<uint8_t>(init_data), CreateSessionPromise(RESOLVED));
 
   init_data.resize(512);
+  EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
       std::vector<uint8_t>(init_data), CreateSessionPromise(RESOLVED));
 
   init_data.resize(513);
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
       std::vector<uint8_t>(init_data), CreateSessionPromise(REJECTED));
 }
 
 TEST_P(AesDecryptorTest, MultipleCreateSession) {
-  EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsNotEmpty()));
+  EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
       std::vector<uint8_t>(1), CreateSessionPromise(RESOLVED));
 
-  EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsNotEmpty()));
+  EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
       std::vector<uint8_t>(1), CreateSessionPromise(RESOLVED));
 
-  EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsNotEmpty()));
+  EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
       std::vector<uint8_t>(1), CreateSessionPromise(RESOLVED));
 }
 
 TEST_P(AesDecryptorTest, CreateSessionWithCencInitData) {
   const uint8_t 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()));
+  EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::CENC,
       std::vector<uint8_t>(init_data, init_data + arraysize(init_data)),
       CreateSessionPromise(RESOLVED));
 #else
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::CENC,
       std::vector<uint8_t>(init_data, init_data + arraysize(init_data)),
       CreateSessionPromise(REJECTED));
 #endif
 }
 
 TEST_P(AesDecryptorTest, CreateSessionWithKeyIdsInitData) {
   const char init_data[] =
       "{\"kids\":[\"AQI\",\"AQIDBA\",\"AQIDBAUGBwgJCgsMDQ4PEA\"]}";
 
-  EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsJSONDictionary()));
+  EXPECT_CALL(cdm_client_, OnSessionMessage(NotEmpty(), _, IsJSONDictionary()));
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::KEYIDS,
       std::vector<uint8_t>(init_data, init_data + arraysize(init_data) - 1),
       CreateSessionPromise(RESOLVED));
 }
 
 TEST_P(AesDecryptorTest, NormalDecryption) {
   std::string session_id = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, true);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
@@ skipping 443 matching lines @@
 INSTANTIATE_TEST_CASE_P(CdmAdapter,
                         AesDecryptorTest,
                         testing::Values("CdmAdapter"));
 #endif
 
 // TODO(jrummell): Once MojoCdm/MojoCdmService/MojoDecryptor/
 // MojoDecryptorService are implemented, add a third version that tests the
 // CDM via mojo.
 
 }  // namespace media