media: Add MockCdmClient

media/cdm/cdm_adapter_unittest.cc

 // Copyright 2015 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/cdm_adapter.h"
 
 #include <stdint.h>
 #include <memory>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/media_keys.h"
+#include "media/base/mock_filters.h"
 #include "media/cdm/cdm_file_io.h"
 #include "media/cdm/external_clear_key_test_helper.h"
 #include "media/cdm/simple_cdm_allocator.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::SaveArg;
+using ::testing::StrictMock;
+
 MATCHER(IsNotEmpty, "") {
   return !arg.empty();
 }
 
 // TODO(jrummell): These tests are a subset of those in aes_decryptor_unittest.
 // Refactor aes_decryptor_unittest.cc to handle AesDecryptor directly and
 // via CdmAdapter once CdmAdapter supports decrypting functionality. There
 // will also be tests that only CdmAdapter supports, like file IO, which
 // will need to be handled separately.
 
@@ skipping 46 matching lines @@
  protected:
   // Initializes the adapter. |expected_result| tests that the call succeeds
   // or generates an error.
   void InitializeAndExpect(base::FilePath library_path,
                            ExpectedResult expected_result) {
     CdmConfig cdm_config;  // default settings of false are sufficient.
     std::unique_ptr<CdmAllocator> allocator(new SimpleCdmAllocator());
     CdmAdapter::Create(
         helper_.KeySystemName(), library_path, cdm_config, std::move(allocator),
         base::Bind(&CdmAdapterTest::CreateCdmFileIO, base::Unretained(this)),
-        base::Bind(&CdmAdapterTest::OnSessionMessage, base::Unretained(this)),
-        base::Bind(&CdmAdapterTest::OnSessionClosed, base::Unretained(this)),
-        base::Bind(&CdmAdapterTest::OnSessionKeysChange,
-                   base::Unretained(this)),
-        base::Bind(&CdmAdapterTest::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(&CdmAdapterTest::OnCdmCreated, base::Unretained(this),
                    expected_result));
     RunUntilIdle();
   }
 
   // Creates a new session using |key_id|. |session_id_| will be set
   // when the promise is resolved. |expected_result| tests that
   // CreateSessionAndGenerateRequest() succeeds or generates an error.
   void CreateSessionAndExpect(EmeInitDataType data_type,
                               const std::vector<uint8_t>& key_id,
                               ExpectedResult expected_result) {
     DCHECK(!key_id.empty());
 
     if (expected_result == SUCCESS) {
-      EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, _));
+      EXPECT_CALL(cdm_client_, OnSessionMessage(IsNotEmpty(), _, _));
     }
 
     adapter_->CreateSessionAndGenerateRequest(
         MediaKeys::TEMPORARY_SESSION, data_type, key_id,
         CreateSessionPromise(expected_result));
     RunUntilIdle();
   }
 
   // Loads the session specified by |session_id|. |expected_result| tests
   // that LoadSession() succeeds or generates an error.
@@ skipping 10 matching lines @@
   // Updates the session specified by |session_id| with |key|. |expected_result|
   // tests that the update succeeds or generates an error. |new_key_expected|
   // is the expected parameter when the SessionKeysChange event happens.
   void UpdateSessionAndExpect(std::string session_id,
                               const std::string& key,
                               ExpectedResult expected_result,
                               bool new_key_expected) {
     DCHECK(!key.empty());
 
     if (expected_result == SUCCESS) {
-      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);
     }
 
     adapter_->UpdateSession(session_id,
                             std::vector<uint8_t>(key.begin(), key.end()),
                             CreatePromise(expected_result));
     RunUntilIdle();
   }
 
   base::FilePath ExternalClearKeyLibrary() { return helper_.LibraryPath(); }
 
@@ skipping 54 matching lines @@
   }
 
   // Methods used for promise resolved/rejected.
   MOCK_METHOD0(OnResolve, void());
   MOCK_METHOD1(OnResolveWithSession, void(const std::string& session_id));
   MOCK_METHOD3(OnReject,
                void(CdmPromise::Exception exception_code,
                     uint32_t system_code,
                     const std::string& error_message));
 
-  // Methods used for the events possibly generated by CdmAdapater.
-  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(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) {
-    // MOCK methods don't like CdmKeysInfo.
-    OnSessionKeysChangeCalled(session_id, has_additional_usable_key);
-  }
-  MOCK_METHOD2(OnSessionExpirationUpdate,
-               void(const std::string& session_id, base::Time new_expiry_time));
+  StrictMock<MockCdmClient> cdm_client_;
 
   // Helper class to load/unload External Clear Key Library.
   ExternalClearKeyTestHelper helper_;
 
   // Keep track of the loaded CDM.
   scoped_refptr<MediaKeys> adapter_;
 
   // |session_id_| is the latest result of calling CreateSession().
   std::string session_id_;
 
@@ skipping 67 matching lines @@
 TEST_F(CdmAdapterTest, UpdateSessionWithBadData) {
   InitializeAndExpect(ExternalClearKeyLibrary(), SUCCESS);
 
   std::vector<uint8_t> key_id(kKeyId, kKeyId + arraysize(kKeyId));
   CreateSessionAndExpect(EmeInitDataType::WEBM, key_id, SUCCESS);
 
   UpdateSessionAndExpect(SessionId(), "random data", FAILURE, true);
 }
 
 }  // namespace media