libbrillo: migrate to generalized MOCK_METHOD() macro

This CL replaces the uses of MOCK_METHOD*() and MOCK_CONST_METHOD*()
macros in unit tests with the generalized MOCK_METHOD() macro, which is
now the recommended way to define mocked methods with gmock. In
particular, MOCK_METHOD() supports annotating a mocked method with
specifiers such as 'override'.

One minor change is that argument names are omitted in the argument list
provided to MOCK_METHOD() in order to prevent clang-format from
formatting code like `Foo* foo` into `Foo * foo`.

BUG=None
TEST=Run unit tests.

Change-Id: Ifcae4d820406d56654d68dceea99f0521e2ba134
Reviewed-on: https://chromium-review.googlesource.com/1807266
Tested-by: Ben Chan <benchan@chromium.org>
Commit-Ready: ChromeOS CL Exonerator Bot <chromiumos-cl-exonerator@appspot.gserviceaccount.com>
Legacy-Commit-Queue: Commit Bot <commit-bot@chromium.org>
Reviewed-by: Eric Caruso <ejcaruso@chromium.org>
Cr-Mirrored-From: https://chromium.googlesource.com/chromiumos/platform2
Cr-Mirrored-Commit: 74aed1c0ae0cfc3e32323a7a5514afb52f2ff38d

24 files changed, 515 insertions, 371 deletions

diff --git a/brillo/dbus/async_event_sequencer_test.cc b/brillo/dbus/async_event_sequencer_test.cc
index 5f4c0e2..a3a21ba 100644
--- a/brillo/dbus/async_event_sequencer_test.cc
+++ b/brillo/dbus/async_event_sequencer_test.cc
@@ -22,7 +22,7 @@ const char kTestMethod2[] = "TestMethod2";
 
 class AsyncEventSequencerTest : public ::testing::Test {
  public:
-  MOCK_METHOD1(HandleCompletion, void(bool all_succeeded));
+  MOCK_METHOD(void, HandleCompletion, (bool));
 
   void SetUp() {
     aec_ = new AsyncEventSequencer();
diff --git a/brillo/dbus/dbus_signal_handler_test.cc b/brillo/dbus/dbus_signal_handler_test.cc
index d31c56a..a2b7a4c 100644
--- a/brillo/dbus/dbus_signal_handler_test.cc
+++ b/brillo/dbus/dbus_signal_handler_test.cc
@@ -80,7 +80,7 @@ TEST_F(DBusSignalHandlerTest, ConnectToSignal) {
 TEST_F(DBusSignalHandlerTest, CallSignal_3Args) {
   class SignalHandlerSink {
    public:
-    MOCK_METHOD3(Handler, void(int, int, double));
+    MOCK_METHOD(void, Handler, (int, int, double));
   } sink;
 
   EXPECT_CALL(sink, Handler(10, 20, 30.5)).Times(1);
@@ -91,7 +91,7 @@ TEST_F(DBusSignalHandlerTest, CallSignal_2Args) {
   class SignalHandlerSink {
    public:
     // Take string both by reference and by value to make sure this works too.
-    MOCK_METHOD2(Handler, void(const std::string&, std::string));
+    MOCK_METHOD(void, Handler, (const std::string&, std::string));
   } sink;
 
   EXPECT_CALL(sink, Handler(std::string{"foo"}, std::string{"bar"})).Times(1);
@@ -101,7 +101,7 @@ TEST_F(DBusSignalHandlerTest, CallSignal_2Args) {
 TEST_F(DBusSignalHandlerTest, CallSignal_NoArgs) {
   class SignalHandlerSink {
    public:
-    MOCK_METHOD0(Handler, void());
+    MOCK_METHOD(void, Handler, ());
   } sink;
 
   EXPECT_CALL(sink, Handler()).Times(1);
@@ -111,7 +111,7 @@ TEST_F(DBusSignalHandlerTest, CallSignal_NoArgs) {
 TEST_F(DBusSignalHandlerTest, CallSignal_Error_TooManyArgs) {
   class SignalHandlerSink {
    public:
-    MOCK_METHOD0(Handler, void());
+    MOCK_METHOD(void, Handler, ());
   } sink;
 
   // Handler() expects no args, but we send an int.
@@ -122,7 +122,7 @@ TEST_F(DBusSignalHandlerTest, CallSignal_Error_TooManyArgs) {
 TEST_F(DBusSignalHandlerTest, CallSignal_Error_TooFewArgs) {
   class SignalHandlerSink {
    public:
-    MOCK_METHOD2(Handler, void(std::string, bool));
+    MOCK_METHOD(void, Handler, (std::string, bool));
   } sink;
 
   // Handler() expects 2 args while we send it just one.
@@ -133,7 +133,7 @@ TEST_F(DBusSignalHandlerTest, CallSignal_Error_TooFewArgs) {
 TEST_F(DBusSignalHandlerTest, CallSignal_Error_TypeMismatchArgs) {
   class SignalHandlerSink {
    public:
-    MOCK_METHOD2(Handler, void(std::string, bool));
+    MOCK_METHOD(void, Handler, (std::string, bool));
   } sink;
 
   // Handler() expects "sb" while we send it "ii".
diff --git a/brillo/dbus/exported_property_set_test.cc b/brillo/dbus/exported_property_set_test.cc
index 93aceb4..6f9dbd7 100644
--- a/brillo/dbus/exported_property_set_test.cc
+++ b/brillo/dbus/exported_property_set_test.cc
@@ -177,8 +177,7 @@ class PropertyValidatorObserver {
                        base::Unretained(this))) {}
   virtual ~PropertyValidatorObserver() {}
 
-  MOCK_METHOD2_T(ValidateProperty,
-                 bool(brillo::ErrorPtr* error, const T& value));
+  MOCK_METHOD(bool, ValidateProperty, (brillo::ErrorPtr*, const T&));
 
   const base::Callback<bool(brillo::ErrorPtr*, const T&)>&
   validate_property_callback() const {
diff --git a/brillo/dbus/mock_dbus_object.h b/brillo/dbus/mock_dbus_object.h
index 4bc1c2f..d65f9ab 100644
--- a/brillo/dbus/mock_dbus_object.h
+++ b/brillo/dbus/mock_dbus_object.h
@@ -22,8 +22,10 @@ class MockDBusObject : public DBusObject {
       : DBusObject(object_manager, bus, object_path) {}
   ~MockDBusObject() override = default;
 
-  MOCK_METHOD1(RegisterAsync,
-               void(const AsyncEventSequencer::CompletionAction&));
+  MOCK_METHOD(void,
+              RegisterAsync,
+              (const AsyncEventSequencer::CompletionAction&),
+              (override));
 };  // class MockDBusObject
 
 }  // namespace dbus_utils
diff --git a/brillo/dbus/mock_exported_object_manager.h b/brillo/dbus/mock_exported_object_manager.h
index bf67996..02bb073 100644
--- a/brillo/dbus/mock_exported_object_manager.h
+++ b/brillo/dbus/mock_exported_object_manager.h
@@ -24,15 +24,17 @@ class MockExportedObjectManager : public ExportedObjectManager {
   using ExportedObjectManager::ExportedObjectManager;
   ~MockExportedObjectManager() override = default;
 
-  MOCK_METHOD1(RegisterAsync,
-               void(const CompletionAction& completion_callback));
-  MOCK_METHOD3(ClaimInterface,
-               void(const ::dbus::ObjectPath& path,
-                    const std::string& interface_name,
-                    const ExportedPropertySet::PropertyWriter& writer));
-  MOCK_METHOD2(ReleaseInterface,
-               void(const ::dbus::ObjectPath& path,
-                    const std::string& interface_name));
+  MOCK_METHOD(void, RegisterAsync, (const CompletionAction&), (override));
+  MOCK_METHOD(void,
+              ClaimInterface,
+              (const ::dbus::ObjectPath&,
+               const std::string&,
+               const ExportedPropertySet::PropertyWriter&),
+              (override));
+  MOCK_METHOD(void,
+              ReleaseInterface,
+              (const ::dbus::ObjectPath&, const std::string&),
+              (override));
 };
 
 }  // namespace dbus_utils
diff --git a/brillo/http/http_proxy_test.cc b/brillo/http/http_proxy_test.cc
index a880003..d921a27 100644
--- a/brillo/http/http_proxy_test.cc
+++ b/brillo/http/http_proxy_test.cc
@@ -49,7 +49,9 @@ class HttpProxyTest : public testing::Test {
     return CreateDBusResponse(method_call).release();
   }
 
-  MOCK_METHOD2(GetProxiesCallback, void(bool, const std::vector<std::string>&));
+  MOCK_METHOD(void,
+              GetProxiesCallback,
+              (bool, const std::vector<std::string>&));
 
  protected:
   HttpProxyTest() {
diff --git a/brillo/http/mock_connection.h b/brillo/http/mock_connection.h
index 0796a7e..1810824 100644
--- a/brillo/http/mock_connection.h
+++ b/brillo/http/mock_connection.h
@@ -19,17 +19,22 @@ class MockConnection : public Connection {
  public:
   using Connection::Connection;
 
-  MOCK_METHOD2(SendHeaders, bool(const HeaderList&, ErrorPtr*));
-  MOCK_METHOD2(MockSetRequestData, bool(Stream*, ErrorPtr*));
-  MOCK_METHOD1(MockSetResponseData, void(Stream*));
-  MOCK_METHOD1(FinishRequest, bool(ErrorPtr*));
-  MOCK_METHOD2(FinishRequestAsync,
-               RequestID(const SuccessCallback&, const ErrorCallback&));
-  MOCK_CONST_METHOD0(GetResponseStatusCode, int());
-  MOCK_CONST_METHOD0(GetResponseStatusText, std::string());
-  MOCK_CONST_METHOD0(GetProtocolVersion, std::string());
-  MOCK_CONST_METHOD1(GetResponseHeader, std::string(const std::string&));
-  MOCK_CONST_METHOD1(MockExtractDataStream, Stream*(brillo::ErrorPtr*));
+  MOCK_METHOD(bool, SendHeaders, (const HeaderList&, ErrorPtr*), (override));
+  MOCK_METHOD(bool, MockSetRequestData, (Stream*, ErrorPtr*));
+  MOCK_METHOD(void, MockSetResponseData, (Stream*));
+  MOCK_METHOD(bool, FinishRequest, (ErrorPtr*), (override));
+  MOCK_METHOD(RequestID,
+              FinishRequestAsync,
+              (const SuccessCallback&, const ErrorCallback&),
+              (override));
+  MOCK_METHOD(int, GetResponseStatusCode, (), (const, override));
+  MOCK_METHOD(std::string, GetResponseStatusText, (), (const, override));
+  MOCK_METHOD(std::string, GetProtocolVersion, (), (const, override));
+  MOCK_METHOD(std::string,
+              GetResponseHeader,
+              (const std::string&),
+              (const, override));
+  MOCK_METHOD(Stream*, MockExtractDataStream, (brillo::ErrorPtr*), (const));
 
  private:
   bool SetRequestData(StreamPtr stream, brillo::ErrorPtr* error) override {
diff --git a/brillo/http/mock_curl_api.h b/brillo/http/mock_curl_api.h
index 32b6e0d..daac8c2 100644
--- a/brillo/http/mock_curl_api.h
+++ b/brillo/http/mock_curl_api.h
@@ -20,34 +20,67 @@ class MockCurlInterface : public CurlInterface {
  public:
   MockCurlInterface() = default;
 
-  MOCK_METHOD0(EasyInit, CURL*());
-  MOCK_METHOD1(EasyCleanup, void(CURL*));
-  MOCK_METHOD3(EasySetOptInt, CURLcode(CURL*, CURLoption, int));
-  MOCK_METHOD3(EasySetOptStr, CURLcode(CURL*, CURLoption, const std::string&));
-  MOCK_METHOD3(EasySetOptPtr, CURLcode(CURL*, CURLoption, void*));
-  MOCK_METHOD3(EasySetOptCallback, CURLcode(CURL*, CURLoption, intptr_t));
-  MOCK_METHOD3(EasySetOptOffT, CURLcode(CURL*, CURLoption, curl_off_t));
-  MOCK_METHOD1(EasyPerform, CURLcode(CURL*));
-  MOCK_CONST_METHOD3(EasyGetInfoInt, CURLcode(CURL*, CURLINFO, int*));
-  MOCK_CONST_METHOD3(EasyGetInfoDbl, CURLcode(CURL*, CURLINFO, double*));
-  MOCK_CONST_METHOD3(EasyGetInfoStr, CURLcode(CURL*, CURLINFO, std::string*));
-  MOCK_CONST_METHOD3(EasyGetInfoPtr, CURLcode(CURL*, CURLINFO, void**));
-  MOCK_CONST_METHOD1(EasyStrError, std::string(CURLcode));
-  MOCK_METHOD0(MultiInit, CURLM*());
-  MOCK_METHOD1(MultiCleanup, CURLMcode(CURLM*));
-  MOCK_METHOD2(MultiInfoRead, CURLMsg*(CURLM*, int*));
-  MOCK_METHOD2(MultiAddHandle, CURLMcode(CURLM*, CURL*));
-  MOCK_METHOD2(MultiRemoveHandle, CURLMcode(CURLM*, CURL*));
-  MOCK_METHOD3(MultiSetSocketCallback,
-               CURLMcode(CURLM*, curl_socket_callback, void*));
-  MOCK_METHOD3(MultiSetTimerCallback,
-               CURLMcode(CURLM*, curl_multi_timer_callback, void*));
-  MOCK_METHOD3(MultiAssign, CURLMcode(CURLM*, curl_socket_t, void*));
-  MOCK_METHOD4(MultiSocketAction, CURLMcode(CURLM*, curl_socket_t, int, int*));
-  MOCK_CONST_METHOD1(MultiStrError, std::string(CURLMcode));
-  MOCK_METHOD2(MultiPerform, CURLMcode(CURLM*, int*));
-  MOCK_METHOD5(MultiWait,
-               CURLMcode(CURLM*, curl_waitfd[], unsigned int, int, int*));
+  MOCK_METHOD(CURL*, EasyInit, (), (override));
+  MOCK_METHOD(void, EasyCleanup, (CURL*), (override));
+  MOCK_METHOD(CURLcode, EasySetOptInt, (CURL*, CURLoption, int), (override));
+  MOCK_METHOD(CURLcode,
+              EasySetOptStr,
+              (CURL*, CURLoption, const std::string&),
+              (override));
+  MOCK_METHOD(CURLcode, EasySetOptPtr, (CURL*, CURLoption, void*), (override));
+  MOCK_METHOD(CURLcode,
+              EasySetOptCallback,
+              (CURL*, CURLoption, intptr_t),
+              (override));
+  MOCK_METHOD(CURLcode,
+              EasySetOptOffT,
+              (CURL*, CURLoption, curl_off_t),
+              (override));
+  MOCK_METHOD(CURLcode, EasyPerform, (CURL*), (override));
+  MOCK_METHOD(CURLcode,
+              EasyGetInfoInt,
+              (CURL*, CURLINFO, int*),
+              (const, override));
+  MOCK_METHOD(CURLcode,
+              EasyGetInfoDbl,
+              (CURL*, CURLINFO, double*),
+              (const, override));
+  MOCK_METHOD(CURLcode,
+              EasyGetInfoStr,
+              (CURL*, CURLINFO, std::string*),
+              (const, override));
+  MOCK_METHOD(CURLcode,
+              EasyGetInfoPtr,
+              (CURL*, CURLINFO, void**),
+              (const, override));
+  MOCK_METHOD(std::string, EasyStrError, (CURLcode), (const, override));
+  MOCK_METHOD(CURLM*, MultiInit, (), (override));
+  MOCK_METHOD(CURLMcode, MultiCleanup, (CURLM*), (override));
+  MOCK_METHOD(CURLMsg*, MultiInfoRead, (CURLM*, int*), (override));
+  MOCK_METHOD(CURLMcode, MultiAddHandle, (CURLM*, CURL*), (override));
+  MOCK_METHOD(CURLMcode, MultiRemoveHandle, (CURLM*, CURL*), (override));
+  MOCK_METHOD(CURLMcode,
+              MultiSetSocketCallback,
+              (CURLM*, curl_socket_callback, void*),
+              (override));
+  MOCK_METHOD(CURLMcode,
+              MultiSetTimerCallback,
+              (CURLM*, curl_multi_timer_callback, void*),
+              (override));
+  MOCK_METHOD(CURLMcode,
+              MultiAssign,
+              (CURLM*, curl_socket_t, void*),
+              (override));
+  MOCK_METHOD(CURLMcode,
+              MultiSocketAction,
+              (CURLM*, curl_socket_t, int, int*),
+              (override));
+  MOCK_METHOD(std::string, MultiStrError, (CURLMcode), (const, override));
+  MOCK_METHOD(CURLMcode, MultiPerform, (CURLM*, int*), (override));
+  MOCK_METHOD(CURLMcode,
+              MultiWait,
+              (CURLM*, curl_waitfd[], unsigned int, int, int*),
+              (override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockCurlInterface);
diff --git a/brillo/http/mock_transport.h b/brillo/http/mock_transport.h
index dfb02c7..a9f5d46 100644
--- a/brillo/http/mock_transport.h
+++ b/brillo/http/mock_transport.h
@@ -20,28 +20,35 @@ class MockTransport : public Transport {
  public:
   MockTransport() = default;
 
-  MOCK_METHOD6(CreateConnection,
-               std::shared_ptr<Connection>(const std::string&,
-                                           const std::string&,
-                                           const HeaderList&,
-                                           const std::string&,
-                                           const std::string&,
-                                           brillo::ErrorPtr*));
-  MOCK_METHOD2(RunCallbackAsync,
-               void(const base::Location&, const base::Closure&));
-  MOCK_METHOD3(StartAsyncTransfer, RequestID(Connection*,
-                                             const SuccessCallback&,
-                                             const ErrorCallback&));
-  MOCK_METHOD1(CancelRequest, bool(RequestID));
-  MOCK_METHOD1(SetDefaultTimeout, void(base::TimeDelta));
-  MOCK_METHOD1(SetLocalIpAddress, void(const std::string&));
-  MOCK_METHOD0(UseDefaultCertificate, void());
-  MOCK_METHOD1(UseCustomCertificate, void(Certificate));
-  MOCK_METHOD3(ResolveHostToIp,
-               void(const std::string&, uint16_t, const std::string&));
+  MOCK_METHOD(std::shared_ptr<Connection>,
+              CreateConnection,
+              (const std::string&,
+               const std::string&,
+               const HeaderList&,
+               const std::string&,
+               const std::string&,
+               brillo::ErrorPtr*),
+              (override));
+  MOCK_METHOD(void,
+              RunCallbackAsync,
+              (const base::Location&, const base::Closure&),
+              (override));
+  MOCK_METHOD(RequestID,
+              StartAsyncTransfer,
+              (Connection*, const SuccessCallback&, const ErrorCallback&),
+              (override));
+  MOCK_METHOD(bool, CancelRequest, (RequestID), (override));
+  MOCK_METHOD(void, SetDefaultTimeout, (base::TimeDelta), (override));
+  MOCK_METHOD(void, SetLocalIpAddress, (const std::string&), (override));
+  MOCK_METHOD(void, UseDefaultCertificate, (), (override));
+  MOCK_METHOD(void, UseCustomCertificate, (Certificate), (override));
+  MOCK_METHOD(void,
+              ResolveHostToIp,
+              (const std::string&, uint16_t, const std::string&),
+              (override));
 
  protected:
-  MOCK_METHOD0(ClearHost, void());
+  MOCK_METHOD(void, ClearHost, (), (override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockTransport);
diff --git a/brillo/message_loops/mock_message_loop.h b/brillo/message_loops/mock_message_loop.h
index 9f9a1e4..c84e585 100644
--- a/brillo/message_loops/mock_message_loop.h
+++ b/brillo/message_loops/mock_message_loop.h
@@ -57,20 +57,19 @@ class BRILLO_EXPORT MockMessageLoop : public MessageLoop {
   }
   ~MockMessageLoop() override = default;
 
-  MOCK_METHOD3(PostDelayedTask,
-               TaskId(const base::Location& from_here,
-                      const base::Closure& task,
-                      base::TimeDelta delay));
+  MOCK_METHOD(TaskId,
+              PostDelayedTask,
+              (const base::Location&, const base::Closure&, base::TimeDelta),
+              (override));
   using MessageLoop::PostDelayedTask;
-  MOCK_METHOD5(WatchFileDescriptor,
-               TaskId(const base::Location& from_here,
-                      int fd,
-                      WatchMode mode,
-                      bool persistent,
-                      const base::Closure& task));
+  MOCK_METHOD(
+      TaskId,
+      WatchFileDescriptor,
+      (const base::Location&, int, WatchMode, bool, const base::Closure&),
+      (override));
   using MessageLoop::WatchFileDescriptor;
-  MOCK_METHOD1(CancelTask, bool(TaskId task_id));
-  MOCK_METHOD1(RunOnce, bool(bool may_block));
+  MOCK_METHOD(bool, CancelTask, (TaskId), (override));
+  MOCK_METHOD(bool, RunOnce, (bool), (override));
 
   // Returns the actual FakeMessageLoop instance so default actions can be
   // override with other actions or call
diff --git a/brillo/minijail/mock_minijail.h b/brillo/minijail/mock_minijail.h
index 82b1efe..6c95405 100644
--- a/brillo/minijail/mock_minijail.h
+++ b/brillo/minijail/mock_minijail.h
@@ -19,48 +19,46 @@ class MockMinijail : public brillo::Minijail {
   MockMinijail() {}
   virtual ~MockMinijail() {}
 
-  MOCK_METHOD0(New, struct minijail*());
-  MOCK_METHOD1(Destroy, void(struct minijail*));
+  MOCK_METHOD(struct minijail*, New, (), (override));
+  MOCK_METHOD(void, Destroy, (struct minijail*), (override));
 
-  MOCK_METHOD3(DropRoot,
-               bool(struct minijail* jail,
-                    const char* user,
-                    const char* group));
-  MOCK_METHOD2(UseSeccompFilter, void(struct minijail* jail, const char* path));
-  MOCK_METHOD2(UseCapabilities, void(struct minijail* jail, uint64_t capmask));
-  MOCK_METHOD1(ResetSignalMask, void(struct minijail* jail));
-  MOCK_METHOD1(CloseOpenFds, void(struct minijail* jail));
-  MOCK_METHOD3(PreserveFd,
-               void(struct minijail* jail, int parent_fd, int child_fd));
-  MOCK_METHOD1(Enter, void(struct minijail* jail));
-  MOCK_METHOD3(Run,
-               bool(struct minijail* jail,
-                    std::vector<char*> args,
-                    pid_t* pid));
-  MOCK_METHOD3(RunSync,
-               bool(struct minijail* jail,
-                    std::vector<char*> args,
-                    int* status));
-  MOCK_METHOD3(RunAndDestroy,
-               bool(struct minijail* jail,
-                    std::vector<char*> args,
-                    pid_t* pid));
-  MOCK_METHOD3(RunSyncAndDestroy,
-               bool(struct minijail* jail,
-                    std::vector<char*> args,
-                    int* status));
-  MOCK_METHOD4(RunPipeAndDestroy,
-               bool(struct minijail* jail,
-                    std::vector<char*> args,
-                    pid_t* pid,
-                    int* stdin));
-  MOCK_METHOD6(RunPipesAndDestroy,
-               bool(struct minijail* jail,
-                    std::vector<char*> args,
-                    pid_t* pid,
-                    int* stdin,
-                    int* stdout,
-                    int* stderr));
+  MOCK_METHOD(bool,
+              DropRoot,
+              (struct minijail*, const char*, const char*),
+              (override));
+  MOCK_METHOD(void,
+              UseSeccompFilter,
+              (struct minijail*, const char*),
+              (override));
+  MOCK_METHOD(void, UseCapabilities, (struct minijail*, uint64_t), (override));
+  MOCK_METHOD(void, ResetSignalMask, (struct minijail*), (override));
+  MOCK_METHOD(void, CloseOpenFds, (struct minijail*), (override));
+  MOCK_METHOD(void, PreserveFd, (struct minijail*, int, int), (override));
+  MOCK_METHOD(void, Enter, (struct minijail*), (override));
+  MOCK_METHOD(bool,
+              Run,
+              (struct minijail*, std::vector<char*>, pid_t*),
+              (override));
+  MOCK_METHOD(bool,
+              RunSync,
+              (struct minijail*, std::vector<char*>, int*),
+              (override));
+  MOCK_METHOD(bool,
+              RunAndDestroy,
+              (struct minijail*, std::vector<char*>, pid_t*),
+              (override));
+  MOCK_METHOD(bool,
+              RunSyncAndDestroy,
+              (struct minijail*, std::vector<char*>, int*),
+              (override));
+  MOCK_METHOD(bool,
+              RunPipeAndDestroy,
+              (struct minijail*, std::vector<char*>, pid_t*, int*),
+              (override));
+  MOCK_METHOD(bool,
+              RunPipesAndDestroy,
+              (struct minijail*, std::vector<char*>, pid_t*, int*, int*, int*),
+              (override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockMinijail);
diff --git a/brillo/process_mock.h b/brillo/process_mock.h
index 92ffa0a..cc33681 100644
--- a/brillo/process_mock.h
+++ b/brillo/process_mock.h
@@ -19,29 +19,29 @@ class ProcessMock : public Process {
   ProcessMock() {}
   virtual ~ProcessMock() {}
 
-  MOCK_METHOD1(AddArg, void(const std::string& arg));
-  MOCK_METHOD1(RedirectInput, void(const std::string& input_file));
-  MOCK_METHOD1(RedirectOutput, void(const std::string& output_file));
-  MOCK_METHOD2(RedirectUsingPipe, void(int child_fd, bool is_input));
-  MOCK_METHOD2(BindFd, void(int parent_fd, int child_fd));
-  MOCK_METHOD1(SetUid, void(uid_t));
-  MOCK_METHOD1(SetGid, void(gid_t));
-  MOCK_METHOD1(SetCapabilities, void(uint64_t capmask));
-  MOCK_METHOD1(ApplySyscallFilter, void(const std::string& path));
-  MOCK_METHOD0(EnterNewPidNamespace, void());
-  MOCK_METHOD1(SetInheritParentSignalMask, void(bool));
-  MOCK_METHOD1(SetPreExecCallback, void(const PreExecCallback&));
-  MOCK_METHOD1(SetSearchPath, void(bool));
-  MOCK_METHOD1(GetPipe, int(int child_fd));
-  MOCK_METHOD0(Start, bool());
-  MOCK_METHOD0(Wait, int());
-  MOCK_METHOD0(Run, int());
-  MOCK_METHOD0(pid, pid_t());
-  MOCK_METHOD2(Kill, bool(int signal, int timeout));
-  MOCK_METHOD1(Reset, void(pid_t));
-  MOCK_METHOD1(ResetPidByFile, bool(const std::string& pid_file));
-  MOCK_METHOD0(Release, pid_t());
-  MOCK_METHOD1(SetCloseUnusedFileDescriptors, void(bool close_unused_fds));
+  MOCK_METHOD(void, AddArg, (const std::string&), (override));
+  MOCK_METHOD(void, RedirectInput, (const std::string&), (override));
+  MOCK_METHOD(void, RedirectOutput, (const std::string&), (override));
+  MOCK_METHOD(void, RedirectUsingPipe, (int, bool), (override));
+  MOCK_METHOD(void, BindFd, (int, int), (override));
+  MOCK_METHOD(void, SetUid, (uid_t), (override));
+  MOCK_METHOD(void, SetGid, (gid_t), (override));
+  MOCK_METHOD(void, SetCapabilities, (uint64_t), (override));
+  MOCK_METHOD(void, ApplySyscallFilter, (const std::string&), (override));
+  MOCK_METHOD(void, EnterNewPidNamespace, (), (override));
+  MOCK_METHOD(void, SetInheritParentSignalMask, (bool), (override));
+  MOCK_METHOD(void, SetPreExecCallback, (const PreExecCallback&), (override));
+  MOCK_METHOD(void, SetSearchPath, (bool), (override));
+  MOCK_METHOD(int, GetPipe, (int), (override));
+  MOCK_METHOD(bool, Start, (), (override));
+  MOCK_METHOD(int, Wait, (), (override));
+  MOCK_METHOD(int, Run, (), (override));
+  MOCK_METHOD(pid_t, pid, (), (override));
+  MOCK_METHOD(bool, Kill, (int, int), (override));
+  MOCK_METHOD(void, Reset, (pid_t), (override));
+  MOCK_METHOD(bool, ResetPidByFile, (const std::string&), (override));
+  MOCK_METHOD(pid_t, Release, (), (override));
+  MOCK_METHOD(void, SetCloseUnusedFileDescriptors, (bool), (override));
 };
 
 }  // namespace brillo
diff --git a/brillo/streams/file_stream_test.cc b/brillo/streams/file_stream_test.cc
index b386aef..593b1f7 100644
--- a/brillo/streams/file_stream_test.cc
+++ b/brillo/streams/file_stream_test.cc
@@ -132,20 +132,23 @@ void SetToTrue(bool* target, const Error* /* error */) {
 // A mock file descriptor wrapper to test low-level file API used by FileStream.
 class MockFileDescriptor : public FileStream::FileDescriptorInterface {
  public:
-  MOCK_CONST_METHOD0(IsOpen, bool());
-  MOCK_METHOD2(Read, ssize_t(void*, size_t));
-  MOCK_METHOD2(Write, ssize_t(const void*, size_t));
-  MOCK_METHOD2(Seek, off64_t(off64_t, int));
-  MOCK_CONST_METHOD0(GetFileMode, mode_t());
-  MOCK_CONST_METHOD0(GetSize, uint64_t());
-  MOCK_CONST_METHOD1(Truncate, int(off64_t));
-  MOCK_METHOD0(Flush, int());
-  MOCK_METHOD0(Close, int());
-  MOCK_METHOD3(WaitForData,
-               bool(Stream::AccessMode, const DataCallback&, ErrorPtr*));
-  MOCK_METHOD3(WaitForDataBlocking,
-               int(Stream::AccessMode, base::TimeDelta, Stream::AccessMode*));
-  MOCK_METHOD0(CancelPendingAsyncOperations, void());
+  MOCK_METHOD(bool, IsOpen, (), (const, override));
+  MOCK_METHOD(ssize_t, Read, (void*, size_t), (override));
+  MOCK_METHOD(ssize_t, Write, (const void*, size_t), (override));
+  MOCK_METHOD(off64_t, Seek, (off64_t, int), (override));
+  MOCK_METHOD(mode_t, GetFileMode, (), (const, override));
+  MOCK_METHOD(uint64_t, GetSize, (), (const, override));
+  MOCK_METHOD(int, Truncate, (off64_t), (const, override));
+  MOCK_METHOD(int, Close, (), (override));
+  MOCK_METHOD(bool,
+              WaitForData,
+              (Stream::AccessMode, const DataCallback&, ErrorPtr*),
+              (override));
+  MOCK_METHOD(int,
+              WaitForDataBlocking,
+              (Stream::AccessMode, base::TimeDelta, Stream::AccessMode*),
+              (override));
+  MOCK_METHOD(void, CancelPendingAsyncOperations, (), (override));
 };
 
 class FileStreamTest : public testing::Test {
diff --git a/brillo/streams/memory_containers_test.cc b/brillo/streams/memory_containers_test.cc
index 2f0bf38..8b56ade 100644
--- a/brillo/streams/memory_containers_test.cc
+++ b/brillo/streams/memory_containers_test.cc
@@ -26,14 +26,20 @@ class MockContiguousBuffer : public data_container::ContiguousBufferBase {
  public:
   MockContiguousBuffer() = default;
 
-  MOCK_METHOD2(Resize, bool(size_t, ErrorPtr*));
-  MOCK_CONST_METHOD0(GetSize, size_t());
-  MOCK_CONST_METHOD0(IsReadOnly, bool());
-
-  MOCK_CONST_METHOD2(GetReadOnlyBuffer, const void*(size_t, ErrorPtr*));
-  MOCK_METHOD2(GetBuffer, void*(size_t, ErrorPtr*));
-
-  MOCK_CONST_METHOD3(CopyMemoryBlock, void(void*, const void*, size_t));
+  MOCK_METHOD(bool, Resize, (size_t, ErrorPtr*), (override));
+  MOCK_METHOD(size_t, GetSize, (), (const, override));
+  MOCK_METHOD(bool, IsReadOnly, (), (const, override));
+
+  MOCK_METHOD(const void*,
+              GetReadOnlyBuffer,
+              (size_t, ErrorPtr*),
+              (const, override));
+  MOCK_METHOD(void*, GetBuffer, (size_t, ErrorPtr*), (override));
+
+  MOCK_METHOD(void,
+              CopyMemoryBlock,
+              (void*, const void*, size_t),
+              (const, override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockContiguousBuffer);
diff --git a/brillo/streams/memory_stream_test.cc b/brillo/streams/memory_stream_test.cc
index a9d1cfa..28a88fa 100644
--- a/brillo/streams/memory_stream_test.cc
+++ b/brillo/streams/memory_stream_test.cc
@@ -33,11 +33,17 @@ class MockMemoryContainer : public data_container::DataContainerInterface {
  public:
   MockMemoryContainer() = default;
 
-  MOCK_METHOD5(Read, bool(void*, size_t, size_t, size_t*, ErrorPtr*));
-  MOCK_METHOD5(Write, bool(const void*, size_t, size_t, size_t*, ErrorPtr*));
-  MOCK_METHOD2(Resize, bool(size_t, ErrorPtr*));
-  MOCK_CONST_METHOD0(GetSize, size_t());
-  MOCK_CONST_METHOD0(IsReadOnly, bool());
+  MOCK_METHOD(bool,
+              Read,
+              (void*, size_t, size_t, size_t*, ErrorPtr*),
+              (override));
+  MOCK_METHOD(bool,
+              Write,
+              (const void*, size_t, size_t, size_t*, ErrorPtr*),
+              (override));
+  MOCK_METHOD(bool, Resize, (size_t, ErrorPtr*), (override));
+  MOCK_METHOD(size_t, GetSize, (), (const, override));
+  MOCK_METHOD(bool, IsReadOnly, (), (const, override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockMemoryContainer);
diff --git a/brillo/streams/mock_stream.h b/brillo/streams/mock_stream.h
index 934912a..45f83ed 100644
--- a/brillo/streams/mock_stream.h
+++ b/brillo/streams/mock_stream.h
@@ -16,55 +16,82 @@ class MockStream : public Stream {
  public:
   MockStream() = default;
 
-  MOCK_CONST_METHOD0(IsOpen, bool());
-  MOCK_CONST_METHOD0(CanRead, bool());
-  MOCK_CONST_METHOD0(CanWrite, bool());
-  MOCK_CONST_METHOD0(CanSeek, bool());
-  MOCK_CONST_METHOD0(CanGetSize, bool());
+  MOCK_METHOD(bool, IsOpen, (), (const, override));
+  MOCK_METHOD(bool, CanRead, (), (const, override));
+  MOCK_METHOD(bool, CanWrite, (), (const, override));
+  MOCK_METHOD(bool, CanSeek, (), (const, override));
+  MOCK_METHOD(bool, CanGetSize, (), (const, override));
 
-  MOCK_CONST_METHOD0(GetSize, uint64_t());
-  MOCK_METHOD2(SetSizeBlocking, bool(uint64_t, ErrorPtr*));
-  MOCK_CONST_METHOD0(GetRemainingSize, uint64_t());
+  MOCK_METHOD(uint64_t, GetSize, (), (const, override));
+  MOCK_METHOD(bool, SetSizeBlocking, (uint64_t, ErrorPtr*), (override));
+  MOCK_METHOD(uint64_t, GetRemainingSize, (), (const, override));
 
-  MOCK_CONST_METHOD0(GetPosition, uint64_t());
-  MOCK_METHOD4(Seek, bool(int64_t, Whence, uint64_t*, ErrorPtr*));
+  MOCK_METHOD(uint64_t, GetPosition, (), (const, override));
+  MOCK_METHOD(bool, Seek, (int64_t, Whence, uint64_t*, ErrorPtr*), (override));
 
-  MOCK_METHOD5(ReadAsync, bool(void*,
-                               size_t,
-                               const base::Callback<void(size_t)>&,
-                               const ErrorCallback&,
-                               ErrorPtr*));
-  MOCK_METHOD5(ReadAllAsync, bool(void*,
-                                  size_t,
-                                  const base::Closure&,
-                                  const ErrorCallback&,
-                                  ErrorPtr*));
-  MOCK_METHOD5(ReadNonBlocking, bool(void*, size_t, size_t*, bool*, ErrorPtr*));
-  MOCK_METHOD4(ReadBlocking, bool(void*, size_t, size_t*, ErrorPtr*));
-  MOCK_METHOD3(ReadAllBlocking, bool(void*, size_t, ErrorPtr*));
+  MOCK_METHOD(bool,
+              ReadAsync,
+              (void*,
+               size_t,
+               const base::Callback<void(size_t)>&,
+               const ErrorCallback&,
+               ErrorPtr*),
+              (override));
+  MOCK_METHOD(
+      bool,
+      ReadAllAsync,
+      (void*, size_t, const base::Closure&, const ErrorCallback&, ErrorPtr*),
+      (override));
+  MOCK_METHOD(bool,
+              ReadNonBlocking,
+              (void*, size_t, size_t*, bool*, ErrorPtr*),
+              (override));
+  MOCK_METHOD(bool,
+              ReadBlocking,
+              (void*, size_t, size_t*, ErrorPtr*),
+              (override));
+  MOCK_METHOD(bool, ReadAllBlocking, (void*, size_t, ErrorPtr*), (override));
 
-  MOCK_METHOD5(WriteAsync, bool(const void*,
-                                size_t,
-                                const base::Callback<void(size_t)>&,
-                                const ErrorCallback&,
-                                ErrorPtr*));
-  MOCK_METHOD5(WriteAllAsync, bool(const void*,
-                                   size_t,
-                                   const base::Closure&,
-                                   const ErrorCallback&,
-                                   ErrorPtr*));
-  MOCK_METHOD4(WriteNonBlocking, bool(const void*, size_t, size_t*, ErrorPtr*));
-  MOCK_METHOD4(WriteBlocking, bool(const void*, size_t, size_t*, ErrorPtr*));
-  MOCK_METHOD3(WriteAllBlocking, bool(const void*, size_t, ErrorPtr*));
+  MOCK_METHOD(bool,
+              WriteAsync,
+              (const void*,
+               size_t,
+               const base::Callback<void(size_t)>&,
+               const ErrorCallback&,
+               ErrorPtr*),
+              (override));
+  MOCK_METHOD(bool,
+              WriteAllAsync,
+              (const void*,
+               size_t,
+               const base::Closure&,
+               const ErrorCallback&,
+               ErrorPtr*),
+              (override));
+  MOCK_METHOD(bool,
+              WriteNonBlocking,
+              (const void*, size_t, size_t*, ErrorPtr*),
+              (override));
+  MOCK_METHOD(bool,
+              WriteBlocking,
+              (const void*, size_t, size_t*, ErrorPtr*),
+              (override));
+  MOCK_METHOD(bool,
+              WriteAllBlocking,
+              (const void*, size_t, ErrorPtr*),
+              (override));
 
-  MOCK_METHOD1(FlushBlocking, bool(ErrorPtr*));
-  MOCK_METHOD1(CloseBlocking, bool(ErrorPtr*));
+  MOCK_METHOD(bool, FlushBlocking, (ErrorPtr*), (override));
+  MOCK_METHOD(bool, CloseBlocking, (ErrorPtr*), (override));
 
-  MOCK_METHOD3(WaitForData, bool(AccessMode,
-                                 const base::Callback<void(AccessMode)>&,
-                                 ErrorPtr*));
-  MOCK_METHOD4(WaitForDataBlocking,
-               bool(AccessMode, base::TimeDelta, AccessMode*, ErrorPtr*));
+  MOCK_METHOD(bool,
+              WaitForData,
+              (AccessMode, const base::Callback<void(AccessMode)>&, ErrorPtr*),
+              (override));
+  MOCK_METHOD(bool,
+              WaitForDataBlocking,
+              (AccessMode, base::TimeDelta, AccessMode*, ErrorPtr*),
+              (override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockStream);
diff --git a/brillo/streams/stream_test.cc b/brillo/streams/stream_test.cc
index ce7370a..8cb99a9 100644
--- a/brillo/streams/stream_test.cc
+++ b/brillo/streams/stream_test.cc
@@ -42,39 +42,48 @@ class MockStreamImpl : public Stream {
  public:
   MockStreamImpl() = default;
 
-  MOCK_CONST_METHOD0(IsOpen, bool());
-  MOCK_CONST_METHOD0(CanRead, bool());
-  MOCK_CONST_METHOD0(CanWrite, bool());
-  MOCK_CONST_METHOD0(CanSeek, bool());
-  MOCK_CONST_METHOD0(CanGetSize, bool());
+  MOCK_METHOD(bool, IsOpen, (), (const, override));
+  MOCK_METHOD(bool, CanRead, (), (const, override));
+  MOCK_METHOD(bool, CanWrite, (), (const, override));
+  MOCK_METHOD(bool, CanSeek, (), (const, override));
+  MOCK_METHOD(bool, CanGetSize, (), (const, override));
 
-  MOCK_CONST_METHOD0(GetSize, uint64_t());
-  MOCK_METHOD2(SetSizeBlocking, bool(uint64_t, ErrorPtr*));
-  MOCK_CONST_METHOD0(GetRemainingSize, uint64_t());
+  MOCK_METHOD(uint64_t, GetSize, (), (const, override));
+  MOCK_METHOD(bool, SetSizeBlocking, (uint64_t, ErrorPtr*), (override));
+  MOCK_METHOD(uint64_t, GetRemainingSize, (), (const, override));
 
-  MOCK_CONST_METHOD0(GetPosition, uint64_t());
-  MOCK_METHOD4(Seek, bool(int64_t, Whence, uint64_t*, ErrorPtr*));
+  MOCK_METHOD(uint64_t, GetPosition, (), (const, override));
+  MOCK_METHOD(bool, Seek, (int64_t, Whence, uint64_t*, ErrorPtr*), (override));
 
   // Omitted: ReadAsync
   // Omitted: ReadAllAsync
-  MOCK_METHOD5(ReadNonBlocking, bool(void*, size_t, size_t*, bool*, ErrorPtr*));
+  MOCK_METHOD(bool,
+              ReadNonBlocking,
+              (void*, size_t, size_t*, bool*, ErrorPtr*),
+              (override));
   // Omitted: ReadBlocking
   // Omitted: ReadAllBlocking
 
   // Omitted: WriteAsync
   // Omitted: WriteAllAsync
-  MOCK_METHOD4(WriteNonBlocking, bool(const void*, size_t, size_t*, ErrorPtr*));
+  MOCK_METHOD(bool,
+              WriteNonBlocking,
+              (const void*, size_t, size_t*, ErrorPtr*),
+              (override));
   // Omitted: WriteBlocking
   // Omitted: WriteAllBlocking
 
-  MOCK_METHOD1(FlushBlocking, bool(ErrorPtr*));
-  MOCK_METHOD1(CloseBlocking, bool(ErrorPtr*));
+  MOCK_METHOD(bool, FlushBlocking, (ErrorPtr*), (override));
+  MOCK_METHOD(bool, CloseBlocking, (ErrorPtr*), (override));
 
-  MOCK_METHOD3(WaitForData, bool(AccessMode,
-                                 const base::Callback<void(AccessMode)>&,
-                                 ErrorPtr*));
-  MOCK_METHOD4(WaitForDataBlocking,
-               bool(AccessMode, base::TimeDelta, AccessMode*, ErrorPtr*));
+  MOCK_METHOD(bool,
+              WaitForData,
+              (AccessMode, const base::Callback<void(AccessMode)>&, ErrorPtr*),
+              (override));
+  MOCK_METHOD(bool,
+              WaitForDataBlocking,
+              (AccessMode, base::TimeDelta, AccessMode*, ErrorPtr*),
+              (override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockStreamImpl);
@@ -333,7 +342,10 @@ TEST(Stream, ReadBlocking) {
 TEST(Stream, ReadAllBlocking) {
   class MockReadBlocking : public MockStreamImpl {
    public:
-    MOCK_METHOD4(ReadBlocking, bool(void*, size_t, size_t*, ErrorPtr*));
+    MOCK_METHOD(bool,
+                ReadBlocking,
+                (void*, size_t, size_t*, ErrorPtr*),
+                (override));
   } stream_mock;
 
   char buf[1024];
@@ -471,7 +483,10 @@ TEST(Stream, WriteBlocking) {
 TEST(Stream, WriteAllBlocking) {
   class MockWritelocking : public MockStreamImpl {
    public:
-    MOCK_METHOD4(WriteBlocking, bool(const void*, size_t, size_t*, ErrorPtr*));
+    MOCK_METHOD(bool,
+                WriteBlocking,
+                (const void*, size_t, size_t*, ErrorPtr*),
+                (override));
   } stream_mock;
 
   char buf[1024];
diff --git a/brillo/udev/mock_udev.h b/brillo/udev/mock_udev.h
index addd29c..8494bab 100644
--- a/brillo/udev/mock_udev.h
+++ b/brillo/udev/mock_udev.h
@@ -21,16 +21,23 @@ class BRILLO_EXPORT MockUdev : public Udev {
   MockUdev() : Udev(nullptr) {}
   ~MockUdev() override = default;
 
-  MOCK_METHOD1(CreateDeviceFromSysPath,
-               std::unique_ptr<UdevDevice>(const char* sys_path));
-  MOCK_METHOD2(CreateDeviceFromDeviceNumber,
-               std::unique_ptr<UdevDevice>(char type, dev_t device_number));
-  MOCK_METHOD2(CreateDeviceFromSubsystemSysName,
-               std::unique_ptr<UdevDevice>(const char* subsystem,
-                                           const char* sys_name));
-  MOCK_METHOD0(CreateEnumerate, std::unique_ptr<UdevEnumerate>());
-  MOCK_METHOD1(CreateMonitorFromNetlink,
-               std::unique_ptr<UdevMonitor>(const char* name));
+  MOCK_METHOD(std::unique_ptr<UdevDevice>,
+              CreateDeviceFromSysPath,
+              (const char*),
+              (override));
+  MOCK_METHOD(std::unique_ptr<UdevDevice>,
+              CreateDeviceFromDeviceNumber,
+              (char, dev_t),
+              (override));
+  MOCK_METHOD(std::unique_ptr<UdevDevice>,
+              CreateDeviceFromSubsystemSysName,
+              (const char*, const char*),
+              (override));
+  MOCK_METHOD(std::unique_ptr<UdevEnumerate>, CreateEnumerate, (), (override));
+  MOCK_METHOD(std::unique_ptr<UdevMonitor>,
+              CreateMonitorFromNetlink,
+              (const char*),
+              (override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockUdev);
diff --git a/brillo/udev/mock_udev_device.h b/brillo/udev/mock_udev_device.h
index aa3b472..9e0c2ef 100644
--- a/brillo/udev/mock_udev_device.h
+++ b/brillo/udev/mock_udev_device.h
@@ -18,30 +18,45 @@ class BRILLO_EXPORT MockUdevDevice : public UdevDevice {
   MockUdevDevice() = default;
   ~MockUdevDevice() override = default;
 
-  MOCK_CONST_METHOD0(GetParent, std::unique_ptr<UdevDevice>());
-  MOCK_CONST_METHOD2(GetParentWithSubsystemDeviceType,
-                     std::unique_ptr<UdevDevice>(const char* subsystem,
-                                                 const char* device_type));
-  MOCK_CONST_METHOD0(IsInitialized, bool());
-  MOCK_CONST_METHOD0(GetMicrosecondsSinceInitialized, uint64_t());
-  MOCK_CONST_METHOD0(GetSequenceNumber, uint64_t());
-  MOCK_CONST_METHOD0(GetDevicePath, const char*());
-  MOCK_CONST_METHOD0(GetDeviceNode, const char*());
-  MOCK_CONST_METHOD0(GetDeviceNumber, dev_t());
-  MOCK_CONST_METHOD0(GetDeviceType, const char*());
-  MOCK_CONST_METHOD0(GetDriver, const char*());
-  MOCK_CONST_METHOD0(GetSubsystem, const char*());
-  MOCK_CONST_METHOD0(GetSysPath, const char*());
-  MOCK_CONST_METHOD0(GetSysName, const char*());
-  MOCK_CONST_METHOD0(GetSysNumber, const char*());
-  MOCK_CONST_METHOD0(GetAction, const char*());
-  MOCK_CONST_METHOD0(GetDeviceLinksListEntry, std::unique_ptr<UdevListEntry>());
-  MOCK_CONST_METHOD0(GetPropertiesListEntry, std::unique_ptr<UdevListEntry>());
-  MOCK_CONST_METHOD1(GetPropertyValue, const char*(const char* key));
-  MOCK_CONST_METHOD0(GetTagsListEntry, std::unique_ptr<UdevListEntry>());
-  MOCK_CONST_METHOD0(GetSysAttributeListEntry,
-                     std::unique_ptr<UdevListEntry>());
-  MOCK_CONST_METHOD1(GetSysAttributeValue, const char*(const char* attribute));
+  MOCK_METHOD(std::unique_ptr<UdevDevice>, GetParent, (), (const, override));
+  MOCK_METHOD(std::unique_ptr<UdevDevice>,
+              GetParentWithSubsystemDeviceType,
+              (const char*, const char*),
+              (const, override));
+  MOCK_METHOD(bool, IsInitialized, (), (const, override));
+  MOCK_METHOD(uint64_t, GetMicrosecondsSinceInitialized, (), (const, override));
+  MOCK_METHOD(uint64_t, GetSequenceNumber, (), (const, override));
+  MOCK_METHOD(const char*, GetDevicePath, (), (const, override));
+  MOCK_METHOD(const char*, GetDeviceNode, (), (const, override));
+  MOCK_METHOD(dev_t, GetDeviceNumber, (), (const, override));
+  MOCK_METHOD(const char*, GetDeviceType, (), (const, override));
+  MOCK_METHOD(const char*, GetDriver, (), (const, override));
+  MOCK_METHOD(const char*, GetSubsystem, (), (const, override));
+  MOCK_METHOD(const char*, GetSysPath, (), (const, override));
+  MOCK_METHOD(const char*, GetSysName, (), (const, override));
+  MOCK_METHOD(const char*, GetSysNumber, (), (const, override));
+  MOCK_METHOD(const char*, GetAction, (), (const, override));
+  MOCK_METHOD(std::unique_ptr<UdevListEntry>,
+              GetDeviceLinksListEntry,
+              (),
+              (const, override));
+  MOCK_METHOD(std::unique_ptr<UdevListEntry>,
+              GetPropertiesListEntry,
+              (),
+              (const, override));
+  MOCK_METHOD(const char*, GetPropertyValue, (const char*), (const, override));
+  MOCK_METHOD(std::unique_ptr<UdevListEntry>,
+              GetTagsListEntry,
+              (),
+              (const, override));
+  MOCK_METHOD(std::unique_ptr<UdevListEntry>,
+              GetSysAttributeListEntry,
+              (),
+              (const, override));
+  MOCK_METHOD(const char*,
+              GetSysAttributeValue,
+              (const char*),
+              (const, override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockUdevDevice);
diff --git a/brillo/udev/mock_udev_enumerate.h b/brillo/udev/mock_udev_enumerate.h
index 4f47f6d..faf94fc 100644
--- a/brillo/udev/mock_udev_enumerate.h
+++ b/brillo/udev/mock_udev_enumerate.h
@@ -18,20 +18,27 @@ class BRILLO_EXPORT MockUdevEnumerate : public UdevEnumerate {
   MockUdevEnumerate() = default;
   ~MockUdevEnumerate() override = default;
 
-  MOCK_METHOD1(AddMatchSubsystem, bool(const char* subsystem));
-  MOCK_METHOD1(AddNoMatchSubsystem, bool(const char* subsystem));
-  MOCK_METHOD2(AddMatchSysAttribute,
-               bool(const char* attribute, const char* value));
-  MOCK_METHOD2(AddNoMatchSysAttribute,
-               bool(const char* attribute, const char* value));
-  MOCK_METHOD2(AddMatchProperty, bool(const char* property, const char* value));
-  MOCK_METHOD1(AddMatchSysName, bool(const char* sys_name));
-  MOCK_METHOD1(AddMatchTag, bool(const char* tag));
-  MOCK_METHOD0(AddMatchIsInitialized, bool());
-  MOCK_METHOD1(AddSysPath, bool(const char* sys_path));
-  MOCK_METHOD0(ScanDevices, bool());
-  MOCK_METHOD0(ScanSubsystems, bool());
-  MOCK_CONST_METHOD0(GetListEntry, std::unique_ptr<UdevListEntry>());
+  MOCK_METHOD(bool, AddMatchSubsystem, (const char*), (override));
+  MOCK_METHOD(bool, AddNoMatchSubsystem, (const char*), (override));
+  MOCK_METHOD(bool,
+              AddMatchSysAttribute,
+              (const char*, const char*),
+              (override));
+  MOCK_METHOD(bool,
+              AddNoMatchSysAttribute,
+              (const char*, const char*),
+              (override));
+  MOCK_METHOD(bool, AddMatchProperty, (const char*, const char*), (override));
+  MOCK_METHOD(bool, AddMatchSysName, (const char*), (override));
+  MOCK_METHOD(bool, AddMatchTag, (const char*), (override));
+  MOCK_METHOD(bool, AddMatchIsInitialized, (), (override));
+  MOCK_METHOD(bool, AddSysPath, (const char*), (override));
+  MOCK_METHOD(bool, ScanDevices, (), (override));
+  MOCK_METHOD(bool, ScanSubsystems, (), (override));
+  MOCK_METHOD(std::unique_ptr<UdevListEntry>,
+              GetListEntry,
+              (),
+              (const, override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockUdevEnumerate);
diff --git a/brillo/udev/mock_udev_list_entry.h b/brillo/udev/mock_udev_list_entry.h
index 0da1246..255b6e2 100644
--- a/brillo/udev/mock_udev_list_entry.h
+++ b/brillo/udev/mock_udev_list_entry.h
@@ -18,11 +18,13 @@ class BRILLO_EXPORT MockUdevListEntry : public UdevListEntry {
   MockUdevListEntry() = default;
   ~MockUdevListEntry() override = default;
 
-  MOCK_CONST_METHOD0(GetNext, std::unique_ptr<UdevListEntry>());
-  MOCK_CONST_METHOD1(GetByName,
-                     std::unique_ptr<UdevListEntry>(const char* name));
-  MOCK_CONST_METHOD0(GetName, const char*());
-  MOCK_CONST_METHOD0(GetValue, const char*());
+  MOCK_METHOD(std::unique_ptr<UdevListEntry>, GetNext, (), (const, override));
+  MOCK_METHOD(std::unique_ptr<UdevListEntry>,
+              GetByName,
+              (const char*),
+              (const, override));
+  MOCK_METHOD(const char*, GetName, (), (const, override));
+  MOCK_METHOD(const char*, GetValue, (), (const, override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockUdevListEntry);
diff --git a/brillo/udev/mock_udev_monitor.h b/brillo/udev/mock_udev_monitor.h
index b955fb8..44e8560 100644
--- a/brillo/udev/mock_udev_monitor.h
+++ b/brillo/udev/mock_udev_monitor.h
@@ -18,15 +18,17 @@ class BRILLO_EXPORT MockUdevMonitor : public UdevMonitor {
   MockUdevMonitor() = default;
   ~MockUdevMonitor() override = default;
 
-  MOCK_METHOD0(EnableReceiving, bool());
-  MOCK_METHOD1(SetReceiveBufferSize, bool(int size));
-  MOCK_CONST_METHOD0(GetFileDescriptor, int());
-  MOCK_METHOD0(ReceiveDevice, std::unique_ptr<UdevDevice>());
-  MOCK_METHOD2(FilterAddMatchSubsystemDeviceType,
-               bool(const char* subsystem, const char* device_type));
-  MOCK_METHOD1(FilterAddMatchTag, bool(const char* tag));
-  MOCK_METHOD0(FilterUpdate, bool());
-  MOCK_METHOD0(FilterRemove, bool());
+  MOCK_METHOD(bool, EnableReceiving, (), (override));
+  MOCK_METHOD(bool, SetReceiveBufferSize, (int), (override));
+  MOCK_METHOD(int, GetFileDescriptor, (), (const, override));
+  MOCK_METHOD(std::unique_ptr<UdevDevice>, ReceiveDevice, (), (override));
+  MOCK_METHOD(bool,
+              FilterAddMatchSubsystemDeviceType,
+              (const char*, const char*),
+              (override));
+  MOCK_METHOD(bool, FilterAddMatchTag, (const char*), (override));
+  MOCK_METHOD(bool, FilterUpdate, (), (override));
+  MOCK_METHOD(bool, FilterRemove, (), (override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockUdevMonitor);
diff --git a/policy/mock_device_policy.h b/policy/mock_device_policy.h
index de68a00..5cd9ce8 100644
--- a/policy/mock_device_policy.h
+++ b/policy/mock_device_policy.h
@@ -52,65 +52,72 @@ class MockDevicePolicy : public DevicePolicy {
   }
   ~MockDevicePolicy() override = default;
 
-  MOCK_METHOD0(LoadPolicy, bool(void));
-  MOCK_CONST_METHOD0(IsEnterpriseEnrolled, bool(void));
+  MOCK_METHOD(bool, LoadPolicy, (), (override));
+  MOCK_METHOD(bool, IsEnterpriseEnrolled, (), (const, override));
 
-  MOCK_CONST_METHOD1(GetPolicyRefreshRate,
-                     bool(int*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetUserWhitelist, bool(std::vector<std::string>*));
-  MOCK_CONST_METHOD1(GetGuestModeEnabled,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetCameraEnabled,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetShowUserNames,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetDataRoamingEnabled,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetAllowNewUsers,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetMetricsEnabled,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetReportVersionInfo,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetReportActivityTimes,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetReportBootMode,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetEphemeralUsersEnabled,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetReleaseChannel, bool(std::string*));
-  MOCK_CONST_METHOD1(GetReleaseChannelDelegated,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetUpdateDisabled,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetTargetVersionPrefix, bool(std::string*));
-  MOCK_CONST_METHOD1(GetRollbackToTargetVersion, bool(int*));
-  MOCK_CONST_METHOD1(GetRollbackAllowedMilestones, bool(int*));
-  MOCK_CONST_METHOD1(GetScatterFactorInSeconds,
-                     bool(int64_t*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetAllowedConnectionTypesForUpdate,
-                     bool(std::set<std::string>*));
-  MOCK_CONST_METHOD1(GetOpenNetworkConfiguration, bool(std::string*));
-  MOCK_CONST_METHOD1(GetOwner, bool(std::string*));
-  MOCK_CONST_METHOD1(GetHttpDownloadsEnabled,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetAuP2PEnabled,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetAllowKioskAppControlChromeVersion,
-                     bool(bool*));  // NOLINT(readability/function)
-  MOCK_CONST_METHOD1(GetUsbDetachableWhitelist,
-                     bool(std::vector<DevicePolicy::UsbDeviceId>*));
-  MOCK_CONST_METHOD1(GetAutoLaunchedKioskAppId, bool(std::string*));
-  MOCK_CONST_METHOD0(IsEnterpriseManaged, bool());
-  MOCK_CONST_METHOD1(GetSecondFactorAuthenticationMode, bool(int*));
-  MOCK_CONST_METHOD1(GetDisallowedTimeIntervals,
-                     bool(std::vector<WeeklyTimeInterval>*));
-  MOCK_CONST_METHOD1(GetDeviceUpdateStagingSchedule,
-                     bool(std::vector<DayPercentagePair>*));
-  MOCK_CONST_METHOD1(GetDeviceQuickFixBuildToken,
-                     bool(std::string*));
-  MOCK_METHOD0(VerifyPolicyFiles, bool(void));
-  MOCK_METHOD0(VerifyPolicySignature, bool(void));
+  MOCK_METHOD(bool, GetPolicyRefreshRate, (int*), (const, override));
+  MOCK_METHOD(bool,
+              GetUserWhitelist,
+              (std::vector<std::string>*),
+              (const, override));
+  MOCK_METHOD(bool, GetGuestModeEnabled, (bool*), (const, override));
+  MOCK_METHOD(bool, GetCameraEnabled, (bool*), (const, override));
+  MOCK_METHOD(bool, GetShowUserNames, (bool*), (const, override));
+  MOCK_METHOD(bool, GetDataRoamingEnabled, (bool*), (const, override));
+  MOCK_METHOD(bool, GetAllowNewUsers, (bool*), (const, override));
+  MOCK_METHOD(bool, GetMetricsEnabled, (bool*), (const, override));
+  MOCK_METHOD(bool, GetReportVersionInfo, (bool*), (const, override));
+  MOCK_METHOD(bool, GetReportActivityTimes, (bool*), (const, override));
+  MOCK_METHOD(bool, GetReportBootMode, (bool*), (const, override));
+  MOCK_METHOD(bool, GetEphemeralUsersEnabled, (bool*), (const, override));
+  MOCK_METHOD(bool, GetReleaseChannel, (std::string*), (const, override));
+  MOCK_METHOD(bool, GetReleaseChannelDelegated, (bool*), (const, override));
+  MOCK_METHOD(bool, GetUpdateDisabled, (bool*), (const, override));
+  MOCK_METHOD(bool, GetTargetVersionPrefix, (std::string*), (const, override));
+  MOCK_METHOD(bool, GetRollbackToTargetVersion, (int*), (const, override));
+  MOCK_METHOD(bool, GetRollbackAllowedMilestones, (int*), (const, override));
+  MOCK_METHOD(bool, GetScatterFactorInSeconds, (int64_t*), (const, override));
+  MOCK_METHOD(bool,
+              GetAllowedConnectionTypesForUpdate,
+              (std::set<std::string>*),
+              (const, override));
+  MOCK_METHOD(bool,
+              GetOpenNetworkConfiguration,
+              (std::string*),
+              (const, override));
+  MOCK_METHOD(bool, GetOwner, (std::string*), (const, override));
+  MOCK_METHOD(bool, GetHttpDownloadsEnabled, (bool*), (const, override));
+  MOCK_METHOD(bool, GetAuP2PEnabled, (bool*), (const, override));
+  MOCK_METHOD(bool,
+              GetAllowKioskAppControlChromeVersion,
+              (bool*),
+              (const, override));
+  MOCK_METHOD(bool,
+              GetUsbDetachableWhitelist,
+              (std::vector<DevicePolicy::UsbDeviceId>*),
+              (const, override));
+  MOCK_METHOD(bool,
+              GetAutoLaunchedKioskAppId,
+              (std::string*),
+              (const, override));
+  MOCK_METHOD(bool, IsEnterpriseManaged, (), (const, override));
+  MOCK_METHOD(bool,
+              GetSecondFactorAuthenticationMode,
+              (int*),
+              (const, override));
+  MOCK_METHOD(bool,
+              GetDisallowedTimeIntervals,
+              (std::vector<WeeklyTimeInterval>*),
+              (const, override));
+  MOCK_METHOD(bool,
+              GetDeviceUpdateStagingSchedule,
+              (std::vector<DayPercentagePair>*),
+              (const, override));
+  MOCK_METHOD(bool,
+              GetDeviceQuickFixBuildToken,
+              (std::string*),
+              (const, override));
+  MOCK_METHOD(bool, VerifyPolicySignature, (), (override));
 };
 }  // namespace policy
 
diff --git a/policy/mock_libpolicy.h b/policy/mock_libpolicy.h
index a0f6920..a04af7b 100644
--- a/policy/mock_libpolicy.h
+++ b/policy/mock_libpolicy.h
@@ -20,10 +20,10 @@ class MockPolicyProvider : public PolicyProvider {
   MockPolicyProvider() = default;
   ~MockPolicyProvider() override = default;
 
-  MOCK_METHOD0(Reload, bool(void));
-  MOCK_CONST_METHOD0(device_policy_is_loaded, bool(void));
-  MOCK_CONST_METHOD0(GetDevicePolicy, const DevicePolicy&(void));
-  MOCK_CONST_METHOD0(IsConsumerDevice, bool(void));
+  MOCK_METHOD(bool, Reload, (), (override));
+  MOCK_METHOD(bool, device_policy_is_loaded, (), (const, override));
+  MOCK_METHOD(const DevicePolicy&, GetDevicePolicy, (), (const, override));
+  MOCK_METHOD(bool, IsConsumerDevice, (), (const, override));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockPolicyProvider);