libbrillo: update for libchrome uprev (2/n)

BUG=chromium:909719
TEST=unittest

Cq-Depend: chromium:1905306
Change-Id: Ie350ef2f8bf5cdc5a658f532461cac4cf8719287
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform2/+/1904775
Tested-by: Qijiang Fan <fqj@google.com>
Commit-Queue: Qijiang Fan <fqj@google.com>
Reviewed-by: Hidehiko Abe <hidehiko@chromium.org>
Reviewed-by: Eric Caruso <ejcaruso@chromium.org>
Cr-Mirrored-From: https://chromium.googlesource.com/chromiumos/platform2
Cr-Mirrored-Commit: 70386a4f5d8ba8c03698a5ea450e08e9ab4575ca

6 files changed, 54 insertions, 40 deletions

diff --git a/brillo/dbus/dbus_method_invoker_test.cc b/brillo/dbus/dbus_method_invoker_test.cc
index 7f0e182..9e6600a 100644
--- a/brillo/dbus/dbus_method_invoker_test.cc
+++ b/brillo/dbus/dbus_method_invoker_test.cc
@@ -83,16 +83,18 @@ class DBusMethodInvokerTest : public testing::Test {
                 GetObjectProxy(kTestServiceName, dbus::ObjectPath(kTestPath)))
         .WillRepeatedly(Return(mock_object_proxy_.get()));
     int def_timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT;
-    EXPECT_CALL(*mock_object_proxy_,
-                MockCallMethodAndBlockWithErrorDetails(_, def_timeout_ms, _))
+    EXPECT_CALL(
+        *mock_object_proxy_,
+        MIGRATE_MockCallMethodAndBlockWithErrorDetails(_, def_timeout_ms, _))
         .WillRepeatedly(Invoke(this, &DBusMethodInvokerTest::CreateResponse));
   }
 
   void TearDown() override { bus_ = nullptr; }
 
-  Response* CreateResponse(dbus::MethodCall* method_call,
-                           int /* timeout_ms */,
-                           dbus::ScopedDBusError* dbus_error) {
+  MIGRATE_WrapObjectProxyResponseType(Response)
+      CreateResponse(dbus::MethodCall* method_call,
+                     int /* timeout_ms */,
+                     dbus::ScopedDBusError* dbus_error) {
     if (method_call->GetInterface() == kTestInterface) {
       if (method_call->GetMember() == kTestMethod1) {
         MessageReader reader(method_call);
@@ -103,12 +105,12 @@ class DBusMethodInvokerTest : public testing::Test {
           auto response = Response::CreateEmpty();
           MessageWriter writer(response.get());
           writer.AppendString(std::to_string(v1 + v2));
-          return response.release();
+          return MIGRATE_WrapObjectProxyResponseConversion(response);
         }
       } else if (method_call->GetMember() == kTestMethod2) {
         method_call->SetSerial(123);
         dbus_set_error(dbus_error->get(), "org.MyError", "My error message");
-        return nullptr;
+        return MIGRATE_WrapObjectProxyResponseEmpty;
       } else if (method_call->GetMember() == kTestMethod3) {
         MessageReader reader(method_call);
         dbus_utils_test::TestMessage msg;
@@ -116,7 +118,7 @@ class DBusMethodInvokerTest : public testing::Test {
           auto response = Response::CreateEmpty();
           MessageWriter writer(response.get());
           AppendValueToWriter(&writer, msg);
-          return response.release();
+          return MIGRATE_WrapObjectProxyResponseConversion(response);
         }
       } else if (method_call->GetMember() == kTestMethod4) {
         method_call->SetSerial(123);
@@ -126,13 +128,13 @@ class DBusMethodInvokerTest : public testing::Test {
           auto response = Response::CreateEmpty();
           MessageWriter writer(response.get());
           writer.AppendFileDescriptor(fd.get());
-          return response.release();
+          return MIGRATE_WrapObjectProxyResponseConversion(response);
         }
       }
     }
 
     LOG(ERROR) << "Unexpected method call: " << method_call->ToString();
-    return nullptr;
+    return MIGRATE_WrapObjectProxyResponseEmpty;
   }
 
   std::string CallTestMethod(int v1, int v2) {
@@ -243,7 +245,7 @@ class AsyncDBusMethodInvokerTest : public testing::Test {
         .WillRepeatedly(Return(mock_object_proxy_.get()));
     int def_timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT;
     EXPECT_CALL(*mock_object_proxy_,
-                CallMethodWithErrorCallback(_, def_timeout_ms, _, _))
+                MIGRATE_CallMethodWithErrorCallback(_, def_timeout_ms, _, _))
         .WillRepeatedly(Invoke(this, &AsyncDBusMethodInvokerTest::HandleCall));
   }
 
@@ -251,8 +253,10 @@ class AsyncDBusMethodInvokerTest : public testing::Test {
 
   void HandleCall(dbus::MethodCall* method_call,
                   int /* timeout_ms */,
-                  dbus::ObjectProxy::ResponseCallback success_callback,
-                  dbus::ObjectProxy::ErrorCallback error_callback) {
+                  dbus::ObjectProxy::ResponseCallback
+                      MIGRATE_WrapObjectProxyCallback(success_callback),
+                  dbus::ObjectProxy::ErrorCallback
+                      MIGRATE_WrapObjectProxyCallback(error_callback)) {
     if (method_call->GetInterface() == kTestInterface) {
       if (method_call->GetMember() == kTestMethod1) {
         MessageReader reader(method_call);
@@ -263,14 +267,16 @@ class AsyncDBusMethodInvokerTest : public testing::Test {
           auto response = Response::CreateEmpty();
           MessageWriter writer(response.get());
           writer.AppendString(std::to_string(v1 + v2));
-          std::move(success_callback).Run(response.get());
+          std::move(MIGRATE_WrapObjectProxyCallback(success_callback))
+              .Run(response.get());
         }
         return;
       } else if (method_call->GetMember() == kTestMethod2) {
         method_call->SetSerial(123);
         auto error_response = dbus::ErrorResponse::FromMethodCall(
             method_call, "org.MyError", "My error message");
-        std::move(error_callback).Run(error_response.get());
+        std::move(MIGRATE_WrapObjectProxyCallback(error_callback))
+            .Run(error_response.get());
         return;
       }
     }
diff --git a/brillo/dbus/dbus_object.cc b/brillo/dbus/dbus_object.cc
index 3933bd6..12eb353 100644
--- a/brillo/dbus/dbus_object.cc
+++ b/brillo/dbus/dbus_object.cc
@@ -39,8 +39,10 @@ void SetupDefaultPropertyHandlers(DBusInterface* prop_interface,
 
 DBusInterface::DBusInterface(DBusObject* dbus_object,
                              const std::string& interface_name)
-    : dbus_object_(dbus_object), interface_name_(interface_name) {
-}
+    : dbus_object_(dbus_object),
+      interface_name_(interface_name),
+      // TODO(crbug.com/909719): Use base::DoNothing()
+      release_interface_cb_(base::Bind([]() {})) {}
 
 void DBusInterface::AddProperty(const std::string& property_name,
                                 ExportedPropertyBase* prop_base) {
diff --git a/brillo/dbus/dbus_signal_handler_test.cc b/brillo/dbus/dbus_signal_handler_test.cc
index a2b7a4c..edd0eca 100644
--- a/brillo/dbus/dbus_signal_handler_test.cc
+++ b/brillo/dbus/dbus_signal_handler_test.cc
@@ -49,7 +49,8 @@ class DBusSignalHandlerTest : public testing::Test {
   template<typename SignalHandlerSink, typename... Args>
   void CallSignal(SignalHandlerSink* sink, Args... args) {
     dbus::ObjectProxy::SignalCallback signal_callback;
-    EXPECT_CALL(*mock_object_proxy_, ConnectToSignal(kInterface, kSignal, _, _))
+    EXPECT_CALL(*mock_object_proxy_,
+                MIGRATE_ConnectToSignal(kInterface, kSignal, _, _))
         .WillOnce(SaveArg<2>(&signal_callback));
 
     brillo::dbus_utils::ConnectToSignal(
@@ -70,7 +71,8 @@ class DBusSignalHandlerTest : public testing::Test {
 };
 
 TEST_F(DBusSignalHandlerTest, ConnectToSignal) {
-  EXPECT_CALL(*mock_object_proxy_, ConnectToSignal(kInterface, kSignal, _, _))
+  EXPECT_CALL(*mock_object_proxy_,
+              MIGRATE_ConnectToSignal(kInterface, kSignal, _, _))
       .Times(1);
 
   brillo::dbus_utils::ConnectToSignal(
diff --git a/brillo/errors/error.cc b/brillo/errors/error.cc
index c1dbdc4..ccae1fa 100644
--- a/brillo/errors/error.cc
+++ b/brillo/errors/error.cc
@@ -21,9 +21,11 @@ inline void LogError(const base::Location& location,
   // the current error location with the location passed in to the Error object.
   // This way the log will contain the actual location of the error, and not
   // as if it always comes from brillo/errors/error.cc(22).
-  logging::LogMessage(
-      location.file_name(), location.line_number(), logging::LOG_ERROR).stream()
-      << location.function_name() << "(...): "
+  logging::LogMessage(location.file_name(), location.line_number(),
+                      logging::LOG_ERROR)
+          .stream()
+      << (location.function_name() ? location.function_name() : "unknown")
+      << "(...): "
       << "Domain=" << domain << ", Code=" << code << ", Message=" << message;
 }
 }  // anonymous namespace
diff --git a/brillo/http/http_proxy_test.cc b/brillo/http/http_proxy_test.cc
index 6f77f69..eb44263 100644
--- a/brillo/http/http_proxy_test.cc
+++ b/brillo/http/http_proxy_test.cc
@@ -32,22 +32,23 @@ class HttpProxyTest : public testing::Test {
  public:
   void ResolveProxyHandlerAsync(dbus::MethodCall* method_call,
                                 int timeout_msec,
-                                dbus::ObjectProxy::ResponseCallback callback) {
+                                dbus::ObjectProxy::ResponseCallback
+                                    MIGRATE_WrapObjectProxyCallback(callback)) {
     if (null_dbus_response_) {
-      std::move(callback).Run(nullptr);
+      std::move(MIGRATE_WrapObjectProxyCallback(callback)).Run(nullptr);
       return;
     }
-    std::move(callback).Run(CreateDBusResponse(method_call).get());
+    std::move(MIGRATE_WrapObjectProxyCallback(callback))
+        .Run(CreateDBusResponse(method_call).get());
   }
 
-  dbus::Response* ResolveProxyHandler(dbus::MethodCall* method_call,
-                                      int timeout_msec) {
+  MIGRATE_WrapObjectProxyResponseType(dbus::Response)
+      ResolveProxyHandler(dbus::MethodCall* method_call, int timeout_msec) {
     if (null_dbus_response_) {
-      return nullptr;
+      return MIGRATE_WrapObjectProxyResponseEmpty;
     }
-    // The mock wraps this back into a std::unique_ptr in the function calling
-    // us.
-    return CreateDBusResponse(method_call).release();
+    return MIGRATE_WrapObjectProxyResponseConversion(
+        CreateDBusResponse(method_call));
   }
 
   MOCK_METHOD(void,
@@ -101,7 +102,7 @@ class HttpProxyTest : public testing::Test {
 TEST_F(HttpProxyTest, DBusNullResponseFails) {
   std::vector<std::string> proxies;
   null_dbus_response_ = true;
-  EXPECT_CALL(*object_proxy_, MockCallMethodAndBlock(_, _))
+  EXPECT_CALL(*object_proxy_, MIGRATE_MockCallMethodAndBlock(_, _))
       .WillOnce(Invoke(this, &HttpProxyTest::ResolveProxyHandler));
   EXPECT_FALSE(GetChromeProxyServers(bus_, kTestUrl, &proxies));
 }
@@ -109,14 +110,14 @@ TEST_F(HttpProxyTest, DBusNullResponseFails) {
 TEST_F(HttpProxyTest, DBusInvalidResponseFails) {
   std::vector<std::string> proxies;
   invalid_dbus_response_ = true;
-  EXPECT_CALL(*object_proxy_, MockCallMethodAndBlock(_, _))
+  EXPECT_CALL(*object_proxy_, MIGRATE_MockCallMethodAndBlock(_, _))
       .WillOnce(Invoke(this, &HttpProxyTest::ResolveProxyHandler));
   EXPECT_FALSE(GetChromeProxyServers(bus_, kTestUrl, &proxies));
 }
 
 TEST_F(HttpProxyTest, NoProxies) {
   std::vector<std::string> proxies;
-  EXPECT_CALL(*object_proxy_, MockCallMethodAndBlock(_, _))
+  EXPECT_CALL(*object_proxy_, MIGRATE_MockCallMethodAndBlock(_, _))
       .WillOnce(Invoke(this, &HttpProxyTest::ResolveProxyHandler));
   EXPECT_TRUE(GetChromeProxyServers(bus_, kTestUrl, &proxies));
   EXPECT_THAT(proxies, ElementsAre(kDirectProxy));
@@ -125,7 +126,7 @@ TEST_F(HttpProxyTest, NoProxies) {
 TEST_F(HttpProxyTest, MultipleProxiesWithoutDirect) {
   proxy_info_ = "proxy example.com; socks5 foo.com;";
   std::vector<std::string> proxies;
-  EXPECT_CALL(*object_proxy_, MockCallMethodAndBlock(_, _))
+  EXPECT_CALL(*object_proxy_, MIGRATE_MockCallMethodAndBlock(_, _))
       .WillOnce(Invoke(this, &HttpProxyTest::ResolveProxyHandler));
   EXPECT_TRUE(GetChromeProxyServers(bus_, kTestUrl, &proxies));
   EXPECT_THAT(proxies, ElementsAre("http://example.com", "socks5://foo.com",
@@ -136,7 +137,7 @@ TEST_F(HttpProxyTest, MultipleProxiesWithDirect) {
   proxy_info_ = "socks foo.com; Https example.com ; badproxy example2.com ; "
                 "socks5 test.com  ; proxy foobar.com; DIRECT ";
   std::vector<std::string> proxies;
-  EXPECT_CALL(*object_proxy_, MockCallMethodAndBlock(_, _))
+  EXPECT_CALL(*object_proxy_, MIGRATE_MockCallMethodAndBlock(_, _))
       .WillOnce(Invoke(this, &HttpProxyTest::ResolveProxyHandler));
   EXPECT_TRUE(GetChromeProxyServers(bus_, kTestUrl, &proxies));
   EXPECT_THAT(proxies, ElementsAre("socks4://foo.com", "https://example.com",
@@ -146,7 +147,7 @@ TEST_F(HttpProxyTest, MultipleProxiesWithDirect) {
 
 TEST_F(HttpProxyTest, DBusNullResponseFailsAsync) {
   null_dbus_response_ = true;
-  EXPECT_CALL(*object_proxy_, CallMethod(_, _, _))
+  EXPECT_CALL(*object_proxy_, MIGRATE_CallMethod(_, _, _))
       .WillOnce(Invoke(this, &HttpProxyTest::ResolveProxyHandlerAsync));
   EXPECT_CALL(*this, GetProxiesCallback(false, _));
   GetChromeProxyServersAsync(
@@ -156,7 +157,7 @@ TEST_F(HttpProxyTest, DBusNullResponseFailsAsync) {
 
 TEST_F(HttpProxyTest, DBusInvalidResponseFailsAsync) {
   invalid_dbus_response_ = true;
-  EXPECT_CALL(*object_proxy_, CallMethod(_, _, _))
+  EXPECT_CALL(*object_proxy_, MIGRATE_CallMethod(_, _, _))
       .WillOnce(Invoke(this, &HttpProxyTest::ResolveProxyHandlerAsync));
   EXPECT_CALL(*this, GetProxiesCallback(false, _));
   GetChromeProxyServersAsync(
@@ -172,7 +173,7 @@ TEST_F(HttpProxyTest, MultipleProxiesWithDirectAsync) {
   std::vector<std::string> expected = {
       "socks4://foo.com", "https://example.com", "socks5://test.com",
       "http://foobar.com", kDirectProxy};
-  EXPECT_CALL(*object_proxy_, CallMethod(_, _, _))
+  EXPECT_CALL(*object_proxy_, MIGRATE_CallMethod(_, _, _))
       .WillOnce(Invoke(this, &HttpProxyTest::ResolveProxyHandlerAsync));
   EXPECT_CALL(*this, GetProxiesCallback(true, expected));
   GetChromeProxyServersAsync(
diff --git a/brillo/message_loops/message_loop_test.cc b/brillo/message_loops/message_loop_test.cc
index ea45536..ae86505 100644
--- a/brillo/message_loops/message_loop_test.cc
+++ b/brillo/message_loops/message_loop_test.cc
@@ -66,7 +66,8 @@ class MessageLoopTest : public ::testing::Test {
 template <>
 void MessageLoopTest<BaseMessageLoop>::MessageLoopSetUp() {
   base_loop_.reset(new base::MessageLoopForIO());
-  loop_.reset(new BaseMessageLoop(base::MessageLoopForIO::current()));
+  loop_.reset(new BaseMessageLoop(base_loop_.get()));
+  loop_->SetAsCurrent();
 }
 
 // This setups gtest to run each one of the following TYPED_TEST test cases on