diff --git a/libwvdrmengine/cdm/core/test/cdm_engine_metrics_decorator_unittest.cpp b/libwvdrmengine/cdm/core/test/cdm_engine_metrics_decorator_unittest.cpp
index 1b981cdb..0d79541d 100644
--- a/libwvdrmengine/cdm/core/test/cdm_engine_metrics_decorator_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/cdm_engine_metrics_decorator_unittest.cpp
@@ -31,24 +31,25 @@ namespace wvcdm {
 
 class MockCdmClientPropertySet : public CdmClientPropertySet {
  public:
-  MOCK_CONST_METHOD0(security_level, const std::string&());
-  MOCK_CONST_METHOD0(use_privacy_mode, bool());
-  MOCK_CONST_METHOD0(service_certificate, const std::string&());
-  MOCK_METHOD1(set_service_certificate, void(const std::string&));
-  MOCK_CONST_METHOD0(is_session_sharing_enabled, bool());
-  MOCK_CONST_METHOD0(session_sharing_id, uint32_t());
-  MOCK_METHOD1(set_session_sharing_id, void(uint32_t));
-  MOCK_CONST_METHOD0(use_atsc_mode, bool());
-  MOCK_METHOD1(set_use_atsc_mode, void(bool));
-  MOCK_CONST_METHOD0(app_id, const std::string&());
+  MOCK_METHOD(const std::string&, security_level, (), (const, override));
+  MOCK_METHOD(bool, use_privacy_mode, (), (const, override));
+  MOCK_METHOD(const std::string&, service_certificate, (), (const, override));
+  MOCK_METHOD(void, set_service_certificate, (const std::string&), (override));
+  MOCK_METHOD(bool, is_session_sharing_enabled, (), (const, override));
+  MOCK_METHOD(uint32_t, session_sharing_id, (), (const, override));
+  MOCK_METHOD(void, set_session_sharing_id, (uint32_t), (override));
+  MOCK_METHOD(bool, use_atsc_mode, (), (const, override));
+  MOCK_METHOD(const std::string&, app_id, (), (const, override));
 };
 
 class MockWvCdmEventListener : public WvCdmEventListener {
-  MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId&));
-  MOCK_METHOD3(OnSessionKeysChange,
-               void(const CdmSessionId&, const CdmKeyStatusMap&,
-                    bool has_new_usable_key));
-  MOCK_METHOD2(OnExpirationUpdate, void(const CdmSessionId&, int64_t));
+  MOCK_METHOD(void, OnSessionRenewalNeeded, (const CdmSessionId&), (override));
+  MOCK_METHOD(void, OnSessionKeysChange,
+              (const CdmSessionId&, const CdmKeyStatusMap&,
+               bool has_new_usable_key),
+              (override));
+  MOCK_METHOD(void, OnExpirationUpdate, (const CdmSessionId&, int64_t),
+              (override));
 };
 
 class MockCdmEngineImpl : public CdmEngine {
@@ -56,50 +57,58 @@ class MockCdmEngineImpl : public CdmEngine {
   MockCdmEngineImpl(FileSystem* file_system,
                     std::shared_ptr<EngineMetrics> metrics)
       : CdmEngine(file_system, metrics) {}
-  MOCK_METHOD4(OpenSession,
-               CdmResponseType(const CdmKeySystem&, CdmClientPropertySet*,
-                               const CdmSessionId&, WvCdmEventListener*));
-  MOCK_METHOD4(OpenSession,
-               CdmResponseType(const CdmKeySystem&, CdmClientPropertySet*,
-                               WvCdmEventListener*, CdmSessionId*));
-  MOCK_METHOD1(CloseSession, CdmResponseType(const CdmSessionId&));
-  MOCK_METHOD3(OpenKeySetSession,
-               CdmResponseType(const CdmKeySetId&, CdmClientPropertySet*,
-                               WvCdmEventListener*));
-  MOCK_METHOD6(GenerateKeyRequest,
-               CdmResponseType(const CdmSessionId&, const CdmKeySetId&,
-                               const InitializationData&, const CdmLicenseType,
-                               CdmAppParameterMap&, CdmKeyRequest*));
-  MOCK_METHOD4(AddKey,
-               CdmResponseType(const CdmSessionId&, const CdmKeyResponse&,
-                               CdmLicenseType*, CdmKeySetId*));
-  MOCK_METHOD2(RestoreKey,
-               CdmResponseType(const CdmSessionId&, const CdmKeySetId&));
-  MOCK_METHOD1(RemoveKeys, CdmResponseType(const CdmSessionId&));
-  MOCK_METHOD2(QueryKeyStatus,
-               CdmResponseType(const CdmSessionId&, CdmQueryMap*));
-  MOCK_METHOD6(GetProvisioningRequest,
-               CdmResponseType(CdmCertificateType, const std::string&,
-                               const std::string&, SecurityLevel,
-                               CdmProvisioningRequest*, std::string*));
-  MOCK_METHOD4(HandleProvisioningResponse,
-               CdmResponseType(const CdmProvisioningResponse&, SecurityLevel,
-                               std::string*, std::string*));
-  MOCK_METHOD1(Unprovision, CdmResponseType(CdmSecurityLevel));
-  MOCK_METHOD4(ListUsageIds,
-               CdmResponseType(const std::string&, CdmSecurityLevel,
-                               std::vector<std::string>*,
-                               std::vector<std::string>*));
-  MOCK_METHOD1(RemoveAllUsageInfo, CdmResponseType(const std::string&));
-  MOCK_METHOD2(RemoveAllUsageInfo,
-               CdmResponseType(const std::string&, CdmSecurityLevel));
-  MOCK_METHOD2(RemoveUsageInfo,
-               CdmResponseType(const std::string&, const CdmSecureStopId&));
-  MOCK_METHOD1(ReleaseUsageInfo,
-               CdmResponseType(const CdmUsageInfoReleaseMessage&));
-  MOCK_METHOD2(DecryptV16, CdmResponseType(const CdmSessionId&,
-                                           const CdmDecryptionParametersV16&));
-  MOCK_METHOD2(FindSessionForKey, bool(const KeyId&, CdmSessionId*));
+  MOCK_METHOD(CdmResponseType, OpenSession,
+              (const CdmKeySystem&, CdmClientPropertySet*, const CdmSessionId&,
+               WvCdmEventListener*),
+              (override));
+  MOCK_METHOD(CdmResponseType, OpenSession,
+              (const CdmKeySystem&, CdmClientPropertySet*, WvCdmEventListener*,
+               CdmSessionId*),
+              (override));
+  MOCK_METHOD(CdmResponseType, CloseSession, (const CdmSessionId&), (override));
+  MOCK_METHOD(CdmResponseType, OpenKeySetSession,
+              (const CdmKeySetId&, CdmClientPropertySet*, WvCdmEventListener*),
+              (override));
+  MOCK_METHOD(CdmResponseType, GenerateKeyRequest,
+              (const CdmSessionId&, const CdmKeySetId&,
+               const InitializationData&, const CdmLicenseType,
+               CdmAppParameterMap&, CdmKeyRequest*),
+              (override));
+  MOCK_METHOD(CdmResponseType, AddKey,
+              (const CdmSessionId&, const CdmKeyResponse&, CdmLicenseType*,
+               CdmKeySetId*),
+              (override));
+  MOCK_METHOD(CdmResponseType, RestoreKey,
+              (const CdmSessionId&, const CdmKeySetId&), (override));
+  MOCK_METHOD(CdmResponseType, RemoveKeys, (const CdmSessionId&), (override));
+  MOCK_METHOD(CdmResponseType, QueryKeyStatus,
+              (const CdmSessionId&, CdmQueryMap*), (override));
+  MOCK_METHOD(CdmResponseType, GetProvisioningRequest,
+              (CdmCertificateType, const std::string&, const std::string&,
+               SecurityLevel, CdmProvisioningRequest*, std::string*),
+              (override));
+  MOCK_METHOD(CdmResponseType, HandleProvisioningResponse,
+              (const CdmProvisioningResponse&, SecurityLevel, std::string*,
+               std::string*),
+              (override));
+  MOCK_METHOD(CdmResponseType, Unprovision, (CdmSecurityLevel), (override));
+  MOCK_METHOD(CdmResponseType, ListUsageIds,
+              (const std::string&, CdmSecurityLevel, std::vector<std::string>*,
+               std::vector<std::string>*),
+              (override));
+  MOCK_METHOD(CdmResponseType, RemoveAllUsageInfo, (const std::string&),
+              (override));
+  MOCK_METHOD(CdmResponseType, RemoveAllUsageInfo,
+              (const std::string&, CdmSecurityLevel), (override));
+  MOCK_METHOD(CdmResponseType, RemoveUsageInfo,
+              (const std::string&, const CdmSecureStopId&), (override));
+  MOCK_METHOD(CdmResponseType, ReleaseUsageInfo,
+              (const CdmUsageInfoReleaseMessage&), (override));
+  MOCK_METHOD(CdmResponseType, DecryptV16,
+              (const CdmSessionId&, const CdmDecryptionParametersV16&),
+              (override));
+  MOCK_METHOD(bool, FindSessionForKey, (const KeyId&, CdmSessionId*),
+              (override));
 };
 
 class WvCdmEngineMetricsImplTest : public ::testing::Test {
diff --git a/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp b/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp
index bd6c472f..47d8b10a 100644
--- a/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp
@@ -115,21 +115,21 @@ class MockDeviceFiles : public DeviceFiles {
  public:
   MockDeviceFiles() : DeviceFiles(nullptr) {}
 
-  MOCK_METHOD1(Init, bool(CdmSecurityLevel));
-  MOCK_METHOD5(RetrieveCertificate,
-               DeviceFiles::CertificateState(bool, std::string*,
-                                             CryptoWrappedKey*, std::string*,
-                                             uint32_t*));
-  MOCK_METHOD1(HasCertificate, bool(bool));
+  MOCK_METHOD(bool, Init, (CdmSecurityLevel), (override));
+  MOCK_METHOD(DeviceFiles::CertificateState, RetrieveCertificate,
+              (bool, std::string*, CryptoWrappedKey*, std::string*, uint32_t*),
+              (override));
+  MOCK_METHOD(bool, HasCertificate, (bool), (override));
 };
 
 class MockUsageTableHeader : public UsageTableHeader {
  public:
   MockUsageTableHeader() : UsageTableHeader() {}
 
-  MOCK_METHOD3(UpdateEntry, CdmResponseType(uint32_t usage_entry_number,
-                                            CryptoSession* crypto_session,
-                                            CdmUsageEntry* usage_entry));
+  MOCK_METHOD(CdmResponseType, UpdateEntry,
+              (uint32_t usage_entry_number, CryptoSession* crypto_session,
+               CdmUsageEntry* usage_entry),
+              (override));
 };
 
 class MockCryptoSession : public TestCryptoSession {
@@ -141,17 +141,16 @@ class MockCryptoSession : public TestCryptoSession {
         .WillByDefault(
             Invoke(this, &MockCryptoSession::BaseHasUsageInfoSupport));
   }
-  MOCK_METHOD1(GetClientToken, bool(std::string*));
-  MOCK_METHOD1(GetProvisioningToken, CdmResponseType(std::string*));
-  MOCK_METHOD0(GetPreProvisionTokenType, CdmClientTokenType());
-  MOCK_METHOD0(GetSecurityLevel, CdmSecurityLevel());
-  MOCK_METHOD0(Open, CdmResponseType());
-  MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
-  MOCK_METHOD1(LoadCertificatePrivateKey,
-               CdmResponseType(const CryptoWrappedKey&));
-  MOCK_METHOD0(DeleteAllUsageReports, CdmResponseType());
-  MOCK_METHOD1(HasUsageInfoSupport, bool(bool*));
-  MOCK_METHOD0(GetUsageTableHeader, UsageTableHeader*());
+  MOCK_METHOD(CdmResponseType, GetProvisioningToken, (std::string*),
+              (override));
+  MOCK_METHOD(CdmClientTokenType, GetPreProvisionTokenType, (), (override));
+  MOCK_METHOD(CdmSecurityLevel, GetSecurityLevel, (), (override));
+  MOCK_METHOD(CdmResponseType, Open, (), (override));
+  MOCK_METHOD(CdmResponseType, Open, (SecurityLevel), (override));
+  MOCK_METHOD(CdmResponseType, LoadCertificatePrivateKey,
+              (const CryptoWrappedKey&), (override));
+  MOCK_METHOD(bool, HasUsageInfoSupport, (bool*), (override));
+  MOCK_METHOD(UsageTableHeader*, GetUsageTableHeader, (), (override));
 
   bool BaseHasUsageInfoSupport(bool* has_support) {
     return CryptoSession::HasUsageInfoSupport(has_support);
@@ -170,9 +169,10 @@ class MockCdmLicense : public CdmLicense {
  public:
   MockCdmLicense(const CdmSessionId& session_id) : CdmLicense(session_id) {}
 
-  MOCK_METHOD4(Init,
-               bool(bool, const std::string&, CryptoSession*, PolicyEngine*));
-  MOCK_METHOD0(provider_session_token, std::string());
+  MOCK_METHOD(bool, Init,
+              (bool, const std::string&, CryptoSession*, PolicyEngine*),
+              (override));
+  MOCK_METHOD(std::string, provider_session_token, (), (override));
 };
 
 }  // namespace
diff --git a/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp b/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp
index 3be65f51..5ff9eed8 100644
--- a/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/certificate_provisioning_unittest.cpp
@@ -59,20 +59,21 @@ class MockCryptoSession : public TestCryptoSession {
  public:
   MockCryptoSession(metrics::CryptoMetrics* metrics)
       : TestCryptoSession(metrics) {}
-  MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
+  MOCK_METHOD(CdmResponseType, Open, (SecurityLevel), (override));
   // Usage Table Header.
-  MOCK_METHOD2(CreateUsageTableHeader,
-               CdmResponseType(SecurityLevel, CdmUsageTableHeader*));
-  MOCK_METHOD2(LoadUsageTableHeader,
-               CdmResponseType(SecurityLevel, const CdmUsageTableHeader&));
-  MOCK_METHOD3(ShrinkUsageTableHeader,
-               CdmResponseType(SecurityLevel, uint32_t, CdmUsageTableHeader*));
+  MOCK_METHOD(CdmResponseType, CreateUsageTableHeader,
+              (SecurityLevel, CdmUsageTableHeader*), (override));
+  MOCK_METHOD(CdmResponseType, LoadUsageTableHeader,
+              (SecurityLevel, const CdmUsageTableHeader&), (override));
+  MOCK_METHOD(CdmResponseType, ShrinkUsageTableHeader,
+              (SecurityLevel, uint32_t, CdmUsageTableHeader*), (override));
   // Usage Entry.
-  MOCK_METHOD1(CreateUsageEntry, CdmResponseType(uint32_t*));
-  MOCK_METHOD2(LoadUsageEntry, CdmResponseType(uint32_t, const CdmUsageEntry&));
-  MOCK_METHOD2(UpdateUsageEntry,
-               CdmResponseType(CdmUsageTableHeader*, CdmUsageEntry*));
-  MOCK_METHOD1(MoveUsageEntry, CdmResponseType(uint32_t));
+  MOCK_METHOD(CdmResponseType, CreateUsageEntry, (uint32_t*), (override));
+  MOCK_METHOD(CdmResponseType, LoadUsageEntry, (uint32_t, const CdmUsageEntry&),
+              (override));
+  MOCK_METHOD(CdmResponseType, UpdateUsageEntry,
+              (CdmUsageTableHeader*, CdmUsageEntry*), (override));
+  MOCK_METHOD(CdmResponseType, MoveUsageEntry, (uint32_t), (override));
 };
 
 class TestStubCryptoSessionFactory : public CryptoSessionFactory {
diff --git a/libwvdrmengine/cdm/core/test/device_files_unittest.cpp b/libwvdrmengine/cdm/core/test/device_files_unittest.cpp
index 2d16ac54..bdfbae0a 100644
--- a/libwvdrmengine/cdm/core/test/device_files_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/device_files_unittest.cpp
@@ -3747,8 +3747,8 @@ class MockFile : public File {
   MockFile() {}
   ~MockFile() override {}
 
-  MOCK_METHOD2(Read, ssize_t(char*, size_t));
-  MOCK_METHOD2(Write, ssize_t(const char*, size_t));
+  MOCK_METHOD(ssize_t, Read, (char*, size_t), (override));
+  MOCK_METHOD(ssize_t, Write, (const char*, size_t), (override));
 };
 
 class MockFileSystem : public FileSystem {
@@ -3756,13 +3756,13 @@ class MockFileSystem : public FileSystem {
   MockFileSystem() {}
   ~MockFileSystem() override {}
 
-  MOCK_METHOD2(Open, std::unique_ptr<File>(const std::string&, int flags));
-  MOCK_METHOD0(IsFactoryReset, bool());
-
-  MOCK_METHOD1(Exists, bool(const std::string&));
-  MOCK_METHOD1(Remove, bool(const std::string&));
-  MOCK_METHOD1(FileSize, ssize_t(const std::string&));
-  MOCK_METHOD2(List, bool(const std::string&, std::vector<std::string>*));
+  MOCK_METHOD(std::unique_ptr<File>, Open, (const std::string&, int flags),
+              (override));
+  MOCK_METHOD(bool, Exists, (const std::string&), (override));
+  MOCK_METHOD(bool, Remove, (const std::string&), (override));
+  MOCK_METHOD(ssize_t, FileSize, (const std::string&), (override));
+  MOCK_METHOD(bool, List, (const std::string&, std::vector<std::string>*),
+              (override));
 };
 
 }  // namespace
diff --git a/libwvdrmengine/cdm/core/test/license_unittest.cpp b/libwvdrmengine/cdm/core/test/license_unittest.cpp
index 9c78fb54..4648c3b7 100644
--- a/libwvdrmengine/cdm/core/test/license_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/license_unittest.cpp
@@ -139,36 +139,30 @@ class MockCryptoSession : public TestCryptoSession {
  public:
   MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
       : TestCryptoSession(crypto_metrics) {}
-  MOCK_METHOD0(IsOpen, bool());
-  MOCK_METHOD0(request_id, const std::string&());
-  MOCK_METHOD1(HasUsageInfoSupport, bool(bool*));
-  MOCK_METHOD2(GetHdcpCapabilities,
-               CdmResponseType(HdcpCapability*, HdcpCapability*));
-  MOCK_METHOD1(GetSupportedCertificateTypes, bool(SupportedCertificateTypes*));
-  MOCK_METHOD1(GetApiVersion, bool(uint32_t*));
-  MOCK_METHOD1(GenerateNonce, CdmResponseType(uint32_t*));
-  MOCK_METHOD3(PrepareAndSignLicenseRequest,
-               CdmResponseType(const std::string&, std::string*, std::string*));
-  MOCK_METHOD1(LoadEntitledContentKeys,
-               CdmResponseType(const std::vector<CryptoKey>& key_array));
-  MOCK_METHOD1(GetResourceRatingTier, bool(uint32_t*));
+  MOCK_METHOD(bool, IsOpen, (), (override));
+  MOCK_METHOD(const std::string&, request_id, (), (override));
+  MOCK_METHOD(bool, HasUsageInfoSupport, (bool*), (override));
+  MOCK_METHOD(CdmResponseType, GetHdcpCapabilities,
+              (HdcpCapability*, HdcpCapability*), (override));
+  MOCK_METHOD(bool, GetSupportedCertificateTypes, (SupportedCertificateTypes*),
+              (override));
+  MOCK_METHOD(bool, GetApiVersion, (uint32_t*), (override));
+  MOCK_METHOD(CdmResponseType, GenerateNonce, (uint32_t*), (override));
+  MOCK_METHOD(CdmResponseType, PrepareAndSignLicenseRequest,
+              (const std::string&, std::string*, std::string*), (override));
+  MOCK_METHOD(CdmResponseType, LoadEntitledContentKeys,
+              (const std::vector<CryptoKey>& key_array), (override));
+  MOCK_METHOD(bool, GetResourceRatingTier, (uint32_t*), (override));
 };
 
 class MockPolicyEngine : public PolicyEngine {
  public:
   MockPolicyEngine(CryptoSession* crypto)
       : PolicyEngine("mock_session_id", nullptr, crypto) {}
-  MOCK_METHOD1(
-      SetEntitledLicenseKeys,
-      void(const std::vector<video_widevine::WidevinePsshData_EntitledKey>&));
-};
-
-class MockInitializationData : public InitializationData {
- public:
-  MockInitializationData(const std::string& type, const CdmInitData& data)
-      : InitializationData(type, data) {}
-  MOCK_METHOD0(is_supported, bool());
-  MOCK_METHOD0(is_cenc, bool());
+  MOCK_METHOD(
+      void, SetEntitledLicenseKeys,
+      (const std::vector<video_widevine::WidevinePsshData_EntitledKey>&),
+      (override));
 };
 
 }  // namespace
@@ -216,7 +210,7 @@ class CdmLicenseTest : public WvCdmTestBase {
     WvCdmTestBase::SetUp();
     clock_ = new MockClock();
     crypto_session_ = new MockCryptoSession(&crypto_metrics_);
-    init_data_ = new MockInitializationData(CENC_INIT_DATA_FORMAT, pssh_);
+    init_data_ = new InitializationData(CENC_INIT_DATA_FORMAT, pssh_);
     policy_engine_ = new MockPolicyEngine(crypto_session_);
 
     ON_CALL(*crypto_session_, GetSupportedCertificateTypes(NotNull()))
@@ -241,7 +235,7 @@ class CdmLicenseTest : public WvCdmTestBase {
   MockClock* clock_;
   metrics::CryptoMetrics crypto_metrics_;
   MockCryptoSession* crypto_session_;
-  MockInitializationData* init_data_;
+  InitializationData* init_data_;
   MockPolicyEngine* policy_engine_;
   std::string pssh_;
 };
diff --git a/libwvdrmengine/cdm/core/test/mock_clock.h b/libwvdrmengine/cdm/core/test/mock_clock.h
index b57f1a10..4272b1ab 100644
--- a/libwvdrmengine/cdm/core/test/mock_clock.h
+++ b/libwvdrmengine/cdm/core/test/mock_clock.h
@@ -12,7 +12,7 @@ namespace wvcdm {
 
 class MockClock : public Clock {
  public:
-  MOCK_METHOD0(GetCurrentTime, int64_t());
+  MOCK_METHOD(int64_t, GetCurrentTime, (), (override));
 };
 
 // Frozen clock will always return the same value for the current time.
diff --git a/libwvdrmengine/cdm/core/test/ota_keybox_provisioner_test.cpp b/libwvdrmengine/cdm/core/test/ota_keybox_provisioner_test.cpp
index a102619b..d71336c7 100644
--- a/libwvdrmengine/cdm/core/test/ota_keybox_provisioner_test.cpp
+++ b/libwvdrmengine/cdm/core/test/ota_keybox_provisioner_test.cpp
@@ -52,9 +52,10 @@ class MockCryptoSession : public CryptoSession {
   bool IsOpen() override { return is_open_; }
   void SetIsOpen(bool is_open) { is_open_ = is_open; }
 
-  MOCK_METHOD2(PrepareOtaProvisioningRequest,
-               CdmResponseType(bool, std::string*));
-  MOCK_METHOD2(LoadOtaProvisioning, CdmResponseType(bool, const std::string&));
+  MOCK_METHOD(CdmResponseType, PrepareOtaProvisioningRequest,
+              (bool, std::string*), (override));
+  MOCK_METHOD(CdmResponseType, LoadOtaProvisioning, (bool, const std::string&),
+              (override));
 
   // Client ID
   uint8_t GetSecurityPatchLevel() override { return 0x00; }
diff --git a/libwvdrmengine/cdm/core/test/policy_engine_constraints_unittest.cpp b/libwvdrmengine/cdm/core/test/policy_engine_constraints_unittest.cpp
index c9d3d9b1..726ab3bc 100644
--- a/libwvdrmengine/cdm/core/test/policy_engine_constraints_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/policy_engine_constraints_unittest.cpp
@@ -70,18 +70,21 @@ class HdcpOnlyMockCryptoSession : public TestCryptoSession {
   HdcpOnlyMockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
       : TestCryptoSession(crypto_metrics) {}
 
-  MOCK_METHOD2(GetHdcpCapabilities,
-               CdmResponseType(HdcpCapability*, HdcpCapability*));
+  MOCK_METHOD(CdmResponseType, GetHdcpCapabilities,
+              (HdcpCapability*, HdcpCapability*), (override));
 };
 
 class MockCdmEventListener : public WvCdmEventListener {
  public:
-  MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
-  MOCK_METHOD3(OnSessionKeysChange, void(const CdmSessionId& session_id,
-                                         const CdmKeyStatusMap& keys_status,
-                                         bool has_new_usable_key));
-  MOCK_METHOD2(OnExpirationUpdate, void(const CdmSessionId& session_id,
-                                        int64_t new_expiry_time_seconds));
+  MOCK_METHOD(void, OnSessionRenewalNeeded, (const CdmSessionId& session_id),
+              (override));
+  MOCK_METHOD(void, OnSessionKeysChange,
+              (const CdmSessionId& session_id,
+               const CdmKeyStatusMap& keys_status, bool has_new_usable_key),
+              (override));
+  MOCK_METHOD(void, OnExpirationUpdate,
+              (const CdmSessionId& session_id, int64_t new_expiry_time_seconds),
+              (override));
 };
 
 }  // namespace
diff --git a/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp b/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp
index 08276b5a..c6ebf0ae 100644
--- a/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp
@@ -55,8 +55,8 @@ class HdcpOnlyMockCryptoSession : public TestCryptoSession {
   HdcpOnlyMockCryptoSession(metrics::CryptoMetrics* metrics)
       : TestCryptoSession(metrics) {}
 
-  MOCK_METHOD2(GetHdcpCapabilities,
-               CdmResponseType(HdcpCapability*, HdcpCapability*));
+  MOCK_METHOD(CdmResponseType, GetHdcpCapabilities,
+              (HdcpCapability*, HdcpCapability*), (override));
   CdmResponseType DoRealGetHdcpCapabilities(HdcpCapability* current,
                                             HdcpCapability* max) {
     return CryptoSession::GetHdcpCapabilities(current, max);
@@ -65,12 +65,15 @@ class HdcpOnlyMockCryptoSession : public TestCryptoSession {
 
 class MockCdmEventListener : public WvCdmEventListener {
  public:
-  MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
-  MOCK_METHOD3(OnSessionKeysChange, void(const CdmSessionId& session_id,
-                                         const CdmKeyStatusMap& keys_status,
-                                         bool has_new_usable_key));
-  MOCK_METHOD2(OnExpirationUpdate, void(const CdmSessionId& session_id,
-                                        int64_t new_expiry_time_seconds));
+  MOCK_METHOD(void, OnSessionRenewalNeeded, (const CdmSessionId& session_id),
+              (override));
+  MOCK_METHOD(void, OnSessionKeysChange,
+              (const CdmSessionId& session_id,
+               const CdmKeyStatusMap& keys_status, bool has_new_usable_key),
+              (override));
+  MOCK_METHOD(void, OnExpirationUpdate,
+              (const CdmSessionId& session_id, int64_t new_expiry_time_seconds),
+              (override));
 };
 
 }  // namespace
diff --git a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp
index 304c46cb..f561415d 100644
--- a/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp
@@ -379,9 +379,10 @@ class MockDeviceFiles : public DeviceFiles {
  public:
   MockDeviceFiles() : DeviceFiles(&file_system_) { Init(kSecurityLevelL1); }
 
-  MOCK_METHOD3(RetrieveLicense,
-               bool(const std::string&, DeviceFiles::CdmLicenseData*,
-                    DeviceFiles::ResponseType*));
+  MOCK_METHOD(bool, RetrieveLicense,
+              (const std::string&, DeviceFiles::CdmLicenseData*,
+               DeviceFiles::ResponseType*),
+              (override));
   // Used for calling the non-mocked method.
   bool RealRetrieveLicense(const std::string& key_set_id,
                            DeviceFiles::CdmLicenseData* license_data,
@@ -389,34 +390,41 @@ class MockDeviceFiles : public DeviceFiles {
     return DeviceFiles::RetrieveLicense(key_set_id, license_data, response);
   }
 
-  MOCK_METHOD3(RetrieveUsageTableInfo,
-               bool(CdmUsageTableHeader*, std::vector<CdmUsageEntryInfo>*,
-                    bool* lru_upgrade));
-  MOCK_METHOD2(StoreUsageTableInfo,
-               bool(const CdmUsageTableHeader&,
-                    const std::vector<CdmUsageEntryInfo>&));
-  MOCK_METHOD2(DeleteUsageInfo, bool(const std::string&, const std::string&));
-  MOCK_METHOD2(DeleteMultipleUsageInfoByKeySetIds,
-               bool(const std::string&, const std::vector<std::string>&));
-  MOCK_METHOD9(RetrieveUsageInfoByKeySetId,
-               bool(const std::string&, const std::string&, std::string*,
-                    CdmKeyMessage*, CdmKeyResponse*, CdmUsageEntry*, uint32_t*,
-                    std::string*, CryptoWrappedKey*));
-  MOCK_METHOD2(StoreLicense, bool(const CdmLicenseData&, ResponseType*));
-  MOCK_METHOD1(DeleteLicense, bool(const std::string&));
-  MOCK_METHOD0(DeleteAllLicenses, bool());
-  MOCK_METHOD0(DeleteAllUsageInfo, bool());
-  MOCK_METHOD0(DeleteUsageTableInfo, bool());
-  MOCK_METHOD9(StoreUsageInfo,
-               bool(const std::string&, const CdmKeyMessage&,
-                    const CdmKeyResponse&, const std::string&,
-                    const std::string&, const CdmUsageEntry&, uint32_t,
-                    const std::string&, const CryptoWrappedKey&));
-  MOCK_METHOD2(RetrieveUsageInfo,
-               bool(const std::string&, std::vector<CdmUsageData>*));
-  MOCK_METHOD1(ListLicenses, bool(std::vector<std::string>* key_set_ids));
-  MOCK_METHOD1(ListUsageInfoFiles,
-               bool(std::vector<std::string>* usage_info_files));
+  MOCK_METHOD(bool, RetrieveUsageTableInfo,
+              (CdmUsageTableHeader*, std::vector<CdmUsageEntryInfo>*,
+               bool* lru_upgrade),
+              (override));
+  MOCK_METHOD(bool, StoreUsageTableInfo,
+              (const CdmUsageTableHeader&,
+               const std::vector<CdmUsageEntryInfo>&),
+              (override));
+  MOCK_METHOD(bool, DeleteUsageInfo, (const std::string&, const std::string&),
+              (override));
+  MOCK_METHOD(bool, DeleteMultipleUsageInfoByKeySetIds,
+              (const std::string&, const std::vector<std::string>&),
+              (override));
+  MOCK_METHOD(bool, RetrieveUsageInfoByKeySetId,
+              (const std::string&, const std::string&, std::string*,
+               CdmKeyMessage*, CdmKeyResponse*, CdmUsageEntry*, uint32_t*,
+               std::string*, CryptoWrappedKey*),
+              (override));
+  MOCK_METHOD(bool, StoreLicense, (const CdmLicenseData&, ResponseType*),
+              (override));
+  MOCK_METHOD(bool, DeleteLicense, (const std::string&), (override));
+  MOCK_METHOD(bool, DeleteAllLicenses, (), (override));
+  MOCK_METHOD(bool, DeleteAllUsageInfo, (), (override));
+  MOCK_METHOD(bool, DeleteUsageTableInfo, (), (override));
+  MOCK_METHOD(bool, StoreUsageInfo,
+              (const std::string&, const CdmKeyMessage&, const CdmKeyResponse&,
+               const std::string&, const std::string&, const CdmUsageEntry&,
+               uint32_t, const std::string&, const CryptoWrappedKey&),
+              (override));
+  MOCK_METHOD(bool, RetrieveUsageInfo,
+              (const std::string&, std::vector<CdmUsageData>*), (override));
+  MOCK_METHOD(bool, ListLicenses, (std::vector<std::string> * key_set_ids),
+              (override));
+  MOCK_METHOD(bool, ListUsageInfoFiles,
+              (std::vector<std::string> * usage_info_files), (override));
 
  private:
   FileSystem file_system_;
@@ -426,22 +434,23 @@ class MockCryptoSession : public TestCryptoSession {
  public:
   MockCryptoSession(metrics::CryptoMetrics* metrics)
       : TestCryptoSession(metrics) {}
-  MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
+  MOCK_METHOD(CdmResponseType, Open, (SecurityLevel), (override));
   // Usage Table Header.
-  MOCK_METHOD2(CreateUsageTableHeader,
-               CdmResponseType(SecurityLevel, CdmUsageTableHeader*));
-  MOCK_METHOD2(LoadUsageTableHeader,
-               CdmResponseType(SecurityLevel, const CdmUsageTableHeader&));
-  MOCK_METHOD3(ShrinkUsageTableHeader,
-               CdmResponseType(SecurityLevel, uint32_t, CdmUsageTableHeader*));
+  MOCK_METHOD(CdmResponseType, CreateUsageTableHeader,
+              (SecurityLevel, CdmUsageTableHeader*), (override));
+  MOCK_METHOD(CdmResponseType, LoadUsageTableHeader,
+              (SecurityLevel, const CdmUsageTableHeader&), (override));
+  MOCK_METHOD(CdmResponseType, ShrinkUsageTableHeader,
+              (SecurityLevel, uint32_t, CdmUsageTableHeader*), (override));
   // Usage Entry.
-  MOCK_METHOD1(CreateUsageEntry, CdmResponseType(uint32_t*));
-  MOCK_METHOD2(LoadUsageEntry, CdmResponseType(uint32_t, const CdmUsageEntry&));
-  MOCK_METHOD2(UpdateUsageEntry,
-               CdmResponseType(CdmUsageTableHeader*, CdmUsageEntry*));
-  MOCK_METHOD1(MoveUsageEntry, CdmResponseType(uint32_t));
-  MOCK_METHOD2(GetNumberOfOpenSessions,
-               CdmResponseType(SecurityLevel, size_t*));
+  MOCK_METHOD(CdmResponseType, CreateUsageEntry, (uint32_t*), (override));
+  MOCK_METHOD(CdmResponseType, LoadUsageEntry, (uint32_t, const CdmUsageEntry&),
+              (override));
+  MOCK_METHOD(CdmResponseType, UpdateUsageEntry,
+              (CdmUsageTableHeader*, CdmUsageEntry*), (override));
+  MOCK_METHOD(CdmResponseType, MoveUsageEntry, (uint32_t), (override));
+  MOCK_METHOD(CdmResponseType, GetNumberOfOpenSessions,
+              (SecurityLevel, size_t*), (override));
 
   // Fake method for testing.  Having an EXPECT_CALL causes complexities
   // for getting table capacity during initialization.
@@ -470,12 +479,13 @@ class MockCryptoSession : public TestCryptoSession {
 class MockUsageTableHeader : public UsageTableHeader {
  public:
   MockUsageTableHeader() : UsageTableHeader() {}
-  MOCK_METHOD4(InvalidateEntryInternal,
-               CdmResponseType(uint32_t, bool, DeviceFiles*,
-                               metrics::CryptoMetrics*));
-  MOCK_METHOD6(AddEntry, CdmResponseType(CryptoSession*, bool,
-                                         const CdmKeySetId&, const std::string&,
-                                         const CdmKeyResponse&, uint32_t*));
+  MOCK_METHOD(CdmResponseType, InvalidateEntryInternal,
+              (uint32_t, bool, DeviceFiles*, metrics::CryptoMetrics*),
+              (override));
+  MOCK_METHOD(CdmResponseType, AddEntry,
+              (CryptoSession*, bool, const CdmKeySetId&, const std::string&,
+               const CdmKeyResponse&, uint32_t*),
+              (override));
 
   CdmResponseType SuperAddEntry(CryptoSession* crypto_session,
                                 bool persistent_license,
diff --git a/libwvdrmengine/cdm/test/cdm_feature_test.cpp b/libwvdrmengine/cdm/test/cdm_feature_test.cpp
index e6a7a3d0..1dec96f8 100644
--- a/libwvdrmengine/cdm/test/cdm_feature_test.cpp
+++ b/libwvdrmengine/cdm/test/cdm_feature_test.cpp
@@ -197,12 +197,15 @@ using video_widevine::SignedProvisioningMessage;
 class TestWvCdmEventListener : public WvCdmEventListener {
  public:
   TestWvCdmEventListener() : WvCdmEventListener() {}
-  MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
-  MOCK_METHOD3(OnSessionKeysChange, void(const CdmSessionId& session_id,
-                                         const CdmKeyStatusMap& keys_status,
-                                         bool has_new_usable_key));
-  MOCK_METHOD2(OnExpirationUpdate, void(const CdmSessionId& session_id,
-                                        int64_t new_expiry_time_seconds));
+  MOCK_METHOD(void, OnSessionRenewalNeeded, (const CdmSessionId& session_id),
+              (override));
+  MOCK_METHOD(void, OnSessionKeysChange,
+              (const CdmSessionId& session_id,
+               const CdmKeyStatusMap& keys_status, bool has_new_usable_key),
+              (override));
+  MOCK_METHOD(void, OnExpirationUpdate,
+              (const CdmSessionId& session_id, int64_t new_expiry_time_seconds),
+              (override));
 };
 
 class TestKeyVerifier {
diff --git a/libwvdrmengine/cdm/test/request_license_test.cpp b/libwvdrmengine/cdm/test/request_license_test.cpp
index 7597a79d..19c91951 100644
--- a/libwvdrmengine/cdm/test/request_license_test.cpp
+++ b/libwvdrmengine/cdm/test/request_license_test.cpp
@@ -1599,12 +1599,15 @@ class TestWvCdmClientPropertySet : public CdmClientPropertySet {
 class TestWvCdmEventListener : public WvCdmEventListener {
  public:
   TestWvCdmEventListener() : WvCdmEventListener() {}
-  MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
-  MOCK_METHOD3(OnSessionKeysChange, void(const CdmSessionId& session_id,
-                                         const CdmKeyStatusMap& keys_status,
-                                         bool has_new_usable_key));
-  MOCK_METHOD2(OnExpirationUpdate, void(const CdmSessionId& session_id,
-                                        int64_t new_expiry_time_seconds));
+  MOCK_METHOD(void, OnSessionRenewalNeeded, (const CdmSessionId& session_id),
+              (override));
+  MOCK_METHOD(void, OnSessionKeysChange,
+              (const CdmSessionId& session_id,
+               const CdmKeyStatusMap& keys_status, bool has_new_usable_key),
+              (override));
+  MOCK_METHOD(void, OnExpirationUpdate,
+              (const CdmSessionId& session_id, int64_t new_expiry_time_seconds),
+              (override));
 };
 
 class DecryptCallbackTester {
diff --git a/libwvdrmengine/mediacrypto/test/WVCryptoPlugin_test.cpp b/libwvdrmengine/mediacrypto/test/WVCryptoPlugin_test.cpp
index e388e5f0..15a048f4 100644
--- a/libwvdrmengine/mediacrypto/test/WVCryptoPlugin_test.cpp
+++ b/libwvdrmengine/mediacrypto/test/WVCryptoPlugin_test.cpp
@@ -67,13 +67,13 @@ using wvcdm::QUERY_VALUE_SECURITY_LEVEL_L3;
 
 class MockCDM : public wvcdm::WvContentDecryptionModule {
  public:
-  MOCK_METHOD1(IsOpenSession, bool(const CdmSessionId&));
+  MOCK_METHOD(bool, IsOpenSession, (const CdmSessionId&), (override));
 
-  MOCK_METHOD3(DecryptV16, CdmResponseType(const CdmSessionId&, bool,
-                                           const CdmDecryptionParametersV16&));
+  MOCK_METHOD(CdmResponseType, DecryptV16, (const CdmSessionId&, bool,
+                                           const CdmDecryptionParametersV16&), (override));
 
-  MOCK_METHOD2(QuerySessionStatus, CdmResponseType(const CdmSessionId&,
-                                                   CdmQueryMap*));
+  MOCK_METHOD(CdmResponseType, QuerySessionStatus, (const CdmSessionId&,
+                                                   CdmQueryMap*), (override));
 };
 
 class WVCryptoPluginTest : public Test {
diff --git a/libwvdrmengine/mediadrm/test/WVDrmPlugin_test.cpp b/libwvdrmengine/mediadrm/test/WVDrmPlugin_test.cpp
index 0bff4ae7..0c7e69a5 100644
--- a/libwvdrmengine/mediadrm/test/WVDrmPlugin_test.cpp
+++ b/libwvdrmengine/mediadrm/test/WVDrmPlugin_test.cpp
@@ -138,146 +138,146 @@ const char kSerializedMetricsHex[] =
 
 class MockCDM : public WvContentDecryptionModule {
  public:
-  MOCK_METHOD5(OpenSession, CdmResponseType(const CdmKeySystem&,
+  MOCK_METHOD(CdmResponseType, OpenSession, (const CdmKeySystem&,
                                             CdmClientPropertySet*,
                                             const CdmIdentifier&,
                                             WvCdmEventListener*,
-                                            CdmSessionId*));
+                                            CdmSessionId*), (override));
 
-  MOCK_METHOD1(CloseSession, CdmResponseType(const CdmSessionId&));
+  MOCK_METHOD(CdmResponseType, CloseSession, (const CdmSessionId&), (override));
 
-  MOCK_METHOD9(GenerateKeyRequest,
-                CdmResponseType(const CdmSessionId&, const CdmKeySetId&,
+  MOCK_METHOD(CdmResponseType, GenerateKeyRequest,
+                (const CdmSessionId&, const CdmKeySetId&,
                                 const std::string&, const CdmInitData&,
                                 const CdmLicenseType, CdmAppParameterMap&,
                                 CdmClientPropertySet*, const CdmIdentifier&,
-                                CdmKeyRequest*));
+                                CdmKeyRequest*), (override));
 
-  MOCK_METHOD3(AddKey, CdmResponseType(const CdmSessionId&,
+  MOCK_METHOD(CdmResponseType, AddKey, (const CdmSessionId&,
                                        const CdmKeyResponse&,
-                                       CdmKeySetId*));
+                                       CdmKeySetId*), (override));
 
-  MOCK_METHOD1(RemoveKeys, CdmResponseType(const CdmSessionId&));
+  MOCK_METHOD(CdmResponseType, RemoveKeys, (const CdmSessionId&), (override));
 
-  MOCK_METHOD2(RestoreKey, CdmResponseType(const CdmSessionId&,
-                                           const CdmKeySetId&));
+  MOCK_METHOD(CdmResponseType, RestoreKey, (const CdmSessionId&,
+                                           const CdmKeySetId&), (override));
 
-  MOCK_METHOD3(QueryStatus, CdmResponseType(wvcdm::SecurityLevel,
+  MOCK_METHOD(CdmResponseType, QueryStatus, (wvcdm::SecurityLevel,
                                             const std::string&,
-                                            std::string*));
+                                            std::string*), (override));
 
-  MOCK_METHOD2(QuerySessionStatus, CdmResponseType(const CdmSessionId&,
-                                                   CdmQueryMap*));
+  MOCK_METHOD(CdmResponseType, QuerySessionStatus, (const CdmSessionId&,
+                                                   CdmQueryMap*), (override));
 
-  MOCK_METHOD2(QueryKeyStatus, CdmResponseType(const CdmSessionId&,
-                                               CdmQueryMap*));
+  MOCK_METHOD(CdmResponseType, QueryKeyStatus, (const CdmSessionId&,
+                                               CdmQueryMap*), (override));
 
-  MOCK_METHOD2(QueryOemCryptoSessionId, CdmResponseType(const CdmSessionId&,
-                                                        CdmQueryMap*));
+  MOCK_METHOD(CdmResponseType, QueryOemCryptoSessionId, (const CdmSessionId&,
+                                                        CdmQueryMap*), (override));
 
-  MOCK_METHOD7(GetProvisioningRequest, CdmResponseType(CdmCertificateType,
+  MOCK_METHOD(CdmResponseType, GetProvisioningRequest, (CdmCertificateType,
                                                        const std::string&,
                                                        const CdmIdentifier&,
                                                        const std::string&,
                                                        wvcdm::SecurityLevel,
                                                        CdmProvisioningRequest*,
-                                                       std::string*));
+                                                       std::string*), (override));
 
-  MOCK_METHOD5(HandleProvisioningResponse,
-      CdmResponseType(const CdmIdentifier&, CdmProvisioningResponse&,
-                      wvcdm::SecurityLevel, std::string*, std::string*));
+  MOCK_METHOD(CdmResponseType, HandleProvisioningResponse,
+      (const CdmIdentifier&, CdmProvisioningResponse&,
+                      wvcdm::SecurityLevel, std::string*, std::string*), (override));
 
-  MOCK_METHOD2(Unprovision, CdmResponseType(CdmSecurityLevel,
-                                            const CdmIdentifier&));
+  MOCK_METHOD(CdmResponseType, Unprovision, (CdmSecurityLevel,
+                                            const CdmIdentifier&), (override));
 
-  MOCK_METHOD4(IsProvisioned, bool(CdmSecurityLevel, const std::string&,
-                                   const std::string&, bool));
+  MOCK_METHOD(bool, IsProvisioned, (CdmSecurityLevel, const std::string&,
+                                   const std::string&, bool), (override));
 
-  MOCK_METHOD3(GetUsageInfo, CdmResponseType(const std::string&,
+  MOCK_METHOD(CdmResponseType, GetUsageInfo, (const std::string&,
                                              const CdmIdentifier&,
-                                             CdmUsageInfo*));
+                                             CdmUsageInfo*), (override));
 
-  MOCK_METHOD4(GetUsageInfo, CdmResponseType(const std::string&,
+  MOCK_METHOD(CdmResponseType, GetUsageInfo, (const std::string&,
                                              const CdmSecureStopId&,
                                              const CdmIdentifier&,
-                                             CdmUsageInfo*));
+                                             CdmUsageInfo*), (override));
 
-  MOCK_METHOD2(RemoveAllUsageInfo, CdmResponseType(const std::string&,
-                                                   const CdmIdentifier&));
+  MOCK_METHOD(CdmResponseType, RemoveAllUsageInfo, (const std::string&,
+                                                   const CdmIdentifier&), (override));
 
-  MOCK_METHOD2(ReleaseUsageInfo,
-      CdmResponseType(const CdmUsageInfoReleaseMessage&, const CdmIdentifier&));
+  MOCK_METHOD(CdmResponseType, ReleaseUsageInfo,
+      (const CdmUsageInfoReleaseMessage&, const CdmIdentifier&), (override));
 
-  MOCK_METHOD1(IsValidServiceCertificate, bool(const std::string&));
+  MOCK_METHOD(bool, IsValidServiceCertificate, (const std::string&), (override));
 
-  MOCK_METHOD2(GetMetrics, CdmResponseType(const CdmIdentifier&,
-                                           drm_metrics::WvCdmMetrics*));
+  MOCK_METHOD(CdmResponseType, GetMetrics, (const CdmIdentifier&,
+                                           drm_metrics::WvCdmMetrics*), (override));
 
-  MOCK_METHOD2(GetDecryptHashError,
-               CdmResponseType(const CdmSessionId&, std::string*));
+  MOCK_METHOD(CdmResponseType, GetDecryptHashError,
+               (const CdmSessionId&, std::string*), (override));
 
-  MOCK_METHOD3(ListStoredLicenses,
-      CdmResponseType(CdmSecurityLevel,
+  MOCK_METHOD(CdmResponseType, ListStoredLicenses,
+      (CdmSecurityLevel,
                       const CdmIdentifier&,
-                      std::vector<std::string>*));
+                      std::vector<std::string>*), (override));
 
-  MOCK_METHOD4(GetOfflineLicenseState,
-      CdmResponseType(const std::string&,
+  MOCK_METHOD(CdmResponseType, GetOfflineLicenseState,
+      (const std::string&,
                       CdmSecurityLevel,
                       const CdmIdentifier&,
-                      CdmOfflineLicenseState*));
+                      CdmOfflineLicenseState*), (override));
 
-  MOCK_METHOD3(RemoveOfflineLicense,
-      CdmResponseType(const std::string&,
+  MOCK_METHOD(CdmResponseType, RemoveOfflineLicense,
+      (const std::string&,
                       CdmSecurityLevel,
-                      const CdmIdentifier&));
+                      const CdmIdentifier&), (override));
 };
 
 class MockCrypto : public WVGenericCryptoInterface {
  public:
-  MOCK_METHOD3(selectKey, OEMCryptoResult(const OEMCrypto_SESSION,
-                                          const uint8_t*, size_t));
+  MOCK_METHOD(OEMCryptoResult, selectKey, (const OEMCrypto_SESSION,
+                                          const uint8_t*, size_t), (override));
 
-  MOCK_METHOD6(encrypt, OEMCryptoResult(OEMCrypto_SESSION, const uint8_t*,
+  MOCK_METHOD(OEMCryptoResult, encrypt, (OEMCrypto_SESSION, const uint8_t*,
                                         size_t, const uint8_t*,
-                                        OEMCrypto_Algorithm, uint8_t*));
+                                        OEMCrypto_Algorithm, uint8_t*), (override));
 
-  MOCK_METHOD6(decrypt, OEMCryptoResult(OEMCrypto_SESSION, const uint8_t*,
+  MOCK_METHOD(OEMCryptoResult, decrypt, (OEMCrypto_SESSION, const uint8_t*,
                                         size_t, const uint8_t*,
-                                        OEMCrypto_Algorithm, uint8_t*));
+                                        OEMCrypto_Algorithm, uint8_t*), (override));
 
-  MOCK_METHOD6(sign, OEMCryptoResult(OEMCrypto_SESSION, const uint8_t*, size_t,
-                                     OEMCrypto_Algorithm, uint8_t*, size_t*));
+  MOCK_METHOD(OEMCryptoResult, sign, (OEMCrypto_SESSION, const uint8_t*, size_t,
+                                     OEMCrypto_Algorithm, uint8_t*, size_t*), (override));
 
-  MOCK_METHOD6(verify, OEMCryptoResult(OEMCrypto_SESSION, const uint8_t*,
+  MOCK_METHOD(OEMCryptoResult, verify, (OEMCrypto_SESSION, const uint8_t*,
                                        size_t, OEMCrypto_Algorithm,
-                                       const uint8_t*, size_t));
+                                       const uint8_t*, size_t), (override));
 
-  MOCK_METHOD3(loadDeviceRSAKey, OEMCryptoResult(OEMCrypto_SESSION,
-                                                 const uint8_t*, size_t));
+  MOCK_METHOD(OEMCryptoResult, loadDeviceRSAKey, (OEMCrypto_SESSION,
+                                                 const uint8_t*, size_t), (override));
 
-  MOCK_METHOD6(generateRSASignature, OEMCryptoResult(OEMCrypto_SESSION,
+  MOCK_METHOD(OEMCryptoResult, generateRSASignature, (OEMCrypto_SESSION,
                                                      const uint8_t*, size_t,
                                                      uint8_t*, size_t*,
-                                                     RSA_Padding_Scheme));
+                                                     RSA_Padding_Scheme), (override));
 };
 
 class MockDrmPluginListener : public IDrmPluginListener_V1_2 {
  public:
-  MOCK_METHOD3(sendEvent, Return<void>(EventType, const hidl_vec<uint8_t>&,
-                                       const hidl_vec<uint8_t>&));
+  MOCK_METHOD(Return<void>, sendEvent, (EventType, const hidl_vec<uint8_t>&,
+                                       const hidl_vec<uint8_t>&), (override));
 
-  MOCK_METHOD2(sendExpirationUpdate,
-               Return<void>(const hidl_vec<uint8_t>&, int64_t));
+  MOCK_METHOD(Return<void>, sendExpirationUpdate,
+               (const hidl_vec<uint8_t>&, int64_t), (override));
 
-  MOCK_METHOD3(sendKeysChange, Return<void>(const hidl_vec<uint8_t>&,
-                                            const hidl_vec<KeyStatus>&, bool));
+  MOCK_METHOD(Return<void>, sendKeysChange, (const hidl_vec<uint8_t>&,
+                                            const hidl_vec<KeyStatus>&, bool), (override));
 
-  MOCK_METHOD1(sendSessionLostState,
-               Return<void>(const hidl_vec<uint8_t>&));
+  MOCK_METHOD(Return<void>, sendSessionLostState,
+               (const hidl_vec<uint8_t>&), (override));
 
-  MOCK_METHOD3(sendKeysChange_1_2, Return<void>(const hidl_vec<uint8_t>&,
-                                                const hidl_vec<KeyStatus_V1_2>&, bool));
+  MOCK_METHOD(Return<void>, sendKeysChange_1_2, (const hidl_vec<uint8_t>&,
+                                                const hidl_vec<KeyStatus_V1_2>&, bool), (override));
 
 };