diff --git a/chrome_browser_proxy_resolver.cc b/chrome_browser_proxy_resolver.cc
index 3c1fe23..3841fe9 100644
--- a/chrome_browser_proxy_resolver.cc
+++ b/chrome_browser_proxy_resolver.cc
@@ -45,56 +45,38 @@
 #undef LIB_CROS_PROXY_RESOLVE_NAME
 
 namespace {
+
 const int kTimeout = 5;  // seconds
 
-DBusGProxy* GetProxy(DbusGlibInterface* dbus) {
-  GError* error = NULL;
-
-  DBusGConnection* bus = dbus->BusGet(DBUS_BUS_SYSTEM, &error);
-  if (!bus) {
-    LOG(ERROR) << "Failed to get bus";
-    return NULL;
-  }
-  DBusGProxy* proxy = dbus->ProxyNewForNameOwner(bus,
-                                                 kLibCrosServiceName,
-                                                 kLibCrosServicePath,
-                                                 kLibCrosServiceInterface,
-                                                 &error);
-  if (!proxy) {
-    LOG(ERROR) << "Error getting dbus proxy for " << kLibCrosServiceName << ": "
-               << utils::GetAndFreeGError(&error);
-    return NULL;
-  }
-  return proxy;
-}
-
 }  // namespace {}
 
 ChromeBrowserProxyResolver::ChromeBrowserProxyResolver(DbusGlibInterface* dbus)
     : dbus_(dbus), proxy_(NULL), timeout_(kTimeout) {}
 
 bool ChromeBrowserProxyResolver::Init() {
-  // Set up signal handler. Code lifted from libcros
-  if (proxy_) {
-    // Already initialized
-    return true;
-  }
-  GError* gerror = NULL;
-  DBusGConnection* gbus = dbus_->BusGet(DBUS_BUS_SYSTEM, &gerror);
-  TEST_AND_RETURN_FALSE(gbus);
-  DBusConnection* connection = dbus_->ConnectionGetConnection(gbus);
+  if (proxy_)
+    return true;  // Already initialized.
+
+  // Set up signal handler. Code lifted from libcros.
+  GError* g_error = NULL;
+  DBusGConnection* bus = dbus_->BusGet(DBUS_BUS_SYSTEM, &g_error);
+  TEST_AND_RETURN_FALSE(bus);
+  DBusConnection* connection = dbus_->ConnectionGetConnection(bus);
   TEST_AND_RETURN_FALSE(connection);
-  DBusError error;
-  dbus_error_init(&error);
-  dbus_->DbusBusAddMatch(connection, kLibCrosProxyResolveSignalFilter, &error);
-  TEST_AND_RETURN_FALSE(!dbus_error_is_set(&error));
+
+  DBusError dbus_error;
+  dbus_error_init(&dbus_error);
+  dbus_->DbusBusAddMatch(connection, kLibCrosProxyResolveSignalFilter,
+                         &dbus_error);
+  TEST_AND_RETURN_FALSE(!dbus_error_is_set(&dbus_error));
   TEST_AND_RETURN_FALSE(dbus_->DbusConnectionAddFilter(
       connection,
       &ChromeBrowserProxyResolver::StaticFilterMessage,
       this,
       NULL));
 
-  proxy_ = GetProxy(dbus_);
+  proxy_ = dbus_->ProxyNewForName(bus, kLibCrosServiceName, kLibCrosServicePath,
+                                  kLibCrosServiceInterface);
   if (!proxy_) {
     dbus_->DbusConnectionRemoveFilter(
         connection,
@@ -105,24 +87,21 @@
   return true;
 }
 
-void ChromeBrowserProxyResolver::Shutdown() {
-  if (!proxy_)
-    return;
-
-  GError* gerror = NULL;
-  DBusGConnection* gbus = dbus_->BusGet(DBUS_BUS_SYSTEM, &gerror);
-  TEST_AND_RETURN(gbus);
-  DBusConnection* connection = dbus_->ConnectionGetConnection(gbus);
-  dbus_->DbusConnectionRemoveFilter(
-      connection,
-      &ChromeBrowserProxyResolver::StaticFilterMessage,
-      this);
-  proxy_ = NULL;
-}
-
 ChromeBrowserProxyResolver::~ChromeBrowserProxyResolver() {
-  // Kill proxy object.
-  Shutdown();
+  // Remove DBus connection filters and Kill proxy object.
+  if (proxy_) {
+    GError* gerror = NULL;
+    DBusGConnection* gbus = dbus_->BusGet(DBUS_BUS_SYSTEM, &gerror);
+    if (gbus) {
+      DBusConnection* connection = dbus_->ConnectionGetConnection(gbus);
+      dbus_->DbusConnectionRemoveFilter(
+          connection,
+          &ChromeBrowserProxyResolver::StaticFilterMessage,
+          this);
+    }
+    dbus_->ProxyUnref(proxy_);
+  }
+
   // Kill outstanding timers
   for (TimeoutsMap::iterator it = timers_.begin(), e = timers_.end(); it != e;
        ++it) {
@@ -137,50 +116,22 @@
   GError* error = NULL;
   guint timeout = timeout_;
   if (proxy_) {
-    bool dbus_success = true;
-    bool dbus_reinit = false;
-    bool dbus_got_error;
+    if (!dbus_->ProxyCall_3_0(proxy_,
+                              kLibCrosServiceResolveNetworkProxyMethodName,
+                              &error,
+                              url.c_str(),
+                              kLibCrosProxyResolveSignalInterface,
+                              kLibCrosProxyResolveName)) {
 
-    do {
-      if (!dbus_success) {
-        // We failed with a null error, time to re-init the dbus proxy.
-        LOG(WARNING) << "attempting to reinitialize dbus proxy and retrying";
-        Shutdown();
-        if (!Init()) {
-          LOG(WARNING) << "failed to reinitialize the dbus proxy";
-          break;
-        }
-        dbus_reinit = true;
-      }
-
-      dbus_success = dbus_->ProxyCall(
-          proxy_,
-          kLibCrosServiceResolveNetworkProxyMethodName,
-          &error,
-          G_TYPE_STRING, url.c_str(),
-          G_TYPE_STRING, kLibCrosProxyResolveSignalInterface,
-          G_TYPE_STRING, kLibCrosProxyResolveName,
-          G_TYPE_INVALID, G_TYPE_INVALID);
-
-      dbus_got_error = false;
-
-      if (dbus_success) {
-        LOG(INFO) << "dbus_g_proxy_call succeeded!";
+      if (error) {
+        LOG(WARNING) << "dbus_g_proxy_call failed, continuing with no proxy: "
+                     << utils::GetAndFreeGError(&error);
       } else {
-        if (error) {
-          // Register the fact that we did receive an error, as it is nullified
-          // on the next line.
-          dbus_got_error = true;
-          LOG(WARNING) << "dbus_g_proxy_call failed: "
-                       << utils::GetAndFreeGError(&error)
-                       << " Continuing with no proxy.";
-        } else {
-          LOG(WARNING) << "dbus_g_proxy_call failed with no error string, "
-                          "continuing with no proxy.";
-        }
-        timeout = 0;
+        LOG(WARNING) << "dbus_g_proxy_call failed with no error string, "
+                        "continuing with no proxy.";
       }
-    } while (!(dbus_success || dbus_got_error || dbus_reinit));
+      timeout = 0;
+    }
   } else {
     LOG(WARNING) << "dbus proxy object missing, continuing with no proxy.";
     timeout = 0;
@@ -212,11 +163,10 @@
   char* error = NULL;
   DBusError arg_error;
   dbus_error_init(&arg_error);
-  if (!dbus_->DbusMessageGetArgs(message, &arg_error,
-                                 DBUS_TYPE_STRING, &source_url,
-                                 DBUS_TYPE_STRING, &proxy_list,
-                                 DBUS_TYPE_STRING, &error,
-                                 DBUS_TYPE_INVALID)) {
+  if (!dbus_->DbusMessageGetArgs_3(message, &arg_error,
+                                   &source_url,
+                                   &proxy_list,
+                                   &error)) {
     LOG(ERROR) << "Error reading dbus signal.";
     return DBUS_HANDLER_RESULT_HANDLED;
   }
diff --git a/chrome_browser_proxy_resolver_unittest.cc b/chrome_browser_proxy_resolver_unittest.cc
index 9c29d85..8ae1a51 100644
--- a/chrome_browser_proxy_resolver_unittest.cc
+++ b/chrome_browser_proxy_resolver_unittest.cc
@@ -124,32 +124,30 @@
   MockDbusGlib dbus_iface;
   
   EXPECT_CALL(dbus_iface, BusGet(_, _))
-      .Times(chrome_alive ? 3 : 2)
+      .Times(2)
       .WillRepeatedly(Return(kMockSystemGBus));
   EXPECT_CALL(dbus_iface,
               ConnectionGetConnection(kMockSystemGBus))
-      .Times(chrome_alive ? 2 : 1)
+      .Times(2)
       .WillRepeatedly(Return(kMockSystemBus));
   EXPECT_CALL(dbus_iface, DbusBusAddMatch(kMockSystemBus, _, _));
   EXPECT_CALL(dbus_iface,
               DbusConnectionAddFilter(kMockSystemBus, _, _, _))
       .WillOnce(Return(1));
   EXPECT_CALL(dbus_iface,
-              ProxyNewForNameOwner(kMockSystemGBus,
-                                   StrEq(kLibCrosServiceName),
-                                   StrEq(kLibCrosServicePath),
-                                   StrEq(kLibCrosServiceInterface),
-                                   _))
-      .WillOnce(Return(chrome_alive ? kMockDbusProxy : NULL));
+              ProxyNewForName(kMockSystemGBus,
+                              StrEq(kLibCrosServiceName),
+                              StrEq(kLibCrosServicePath),
+                              StrEq(kLibCrosServiceInterface)))
+      .WillOnce(Return(kMockDbusProxy));
   if (chrome_alive)
-    EXPECT_CALL(dbus_iface, ProxyCall(
+    EXPECT_CALL(dbus_iface, ProxyCall_3_0(
         kMockDbusProxy,
         StrEq(kLibCrosServiceResolveNetworkProxyMethodName),
         _,
-        G_TYPE_STRING, StrEq(kUrl),
-        G_TYPE_STRING, StrEq(kLibCrosProxyResolveSignalInterface),
-        G_TYPE_STRING, StrEq(kLibCrosProxyResolveName),
-        G_TYPE_INVALID))
+        StrEq(kUrl),
+        StrEq(kLibCrosProxyResolveSignalInterface),
+        StrEq(kLibCrosProxyResolveName)))
         .WillOnce(Return(chrome_alive ? TRUE : FALSE));
   EXPECT_CALL(dbus_iface,
               DbusConnectionRemoveFilter(kMockSystemBus, _, _));
@@ -160,13 +158,9 @@
                                     kLibCrosProxyResolveName))
         .WillOnce(Return(1));
     EXPECT_CALL(dbus_iface,
-                DbusMessageGetArgs(kMockDbusMessage, _,
-                                   DBUS_TYPE_STRING, _,
-                                   DBUS_TYPE_STRING, _,
-                                   DBUS_TYPE_STRING, _,
-                                   DBUS_TYPE_INVALID))
-        .WillOnce(DoAll(SetArgumentPointee<3>(strdup(kUrl)),
-                        SetArgumentPointee<5>(
+                DbusMessageGetArgs_3(kMockDbusMessage, _, _, _, _))
+        .WillOnce(DoAll(SetArgumentPointee<2>(strdup(kUrl)),
+                        SetArgumentPointee<3>(
                             strdup("SOCKS5 192.168.52.83:5555;DIRECT")),
                         Return(TRUE)));
   }
@@ -174,7 +168,7 @@
   GMainLoop* loop = g_main_loop_new(g_main_context_default(), FALSE);
 
   ChromeBrowserProxyResolver resolver(&dbus_iface);
-  EXPECT_EQ(chrome_alive, resolver.Init());
+  EXPECT_EQ(true, resolver.Init());
   resolver.set_timeout(1);
   SendReplyArgs args = {
     kMockSystemBus,
diff --git a/connection_manager.cc b/connection_manager.cc
index bd584b1..1b436dc 100644
--- a/connection_manager.cc
+++ b/connection_manager.cc
@@ -37,16 +37,8 @@
     LOG(ERROR) << "Failed to get system bus";
     return false;
   }
-  proxy = dbus_iface->ProxyNewForNameOwner(bus,
-                                           shill::kFlimflamServiceName,
-                                           path,
-                                           interface,
-                                           &error);
-  if (!proxy) {
-    LOG(ERROR) << "Error getting FlimFlam proxy: "
-               << utils::GetAndFreeGError(&error);
-    return false;
-  }
+  proxy = dbus_iface->ProxyNewForName(bus, shill::kFlimflamServiceName, path,
+                                      interface);
   *out_proxy = proxy;
   return true;
 }
@@ -65,15 +57,10 @@
                                          interface,
                                          &proxy));
 
-  gboolean rc = dbus_iface->ProxyCall(proxy,
-                                      "GetProperties",
-                                      &error,
-                                      G_TYPE_INVALID,
-                                      dbus_g_type_get_map("GHashTable",
-                                                          G_TYPE_STRING,
-                                                          G_TYPE_VALUE),
-                                      out_hash_table,
-                                      G_TYPE_INVALID);
+  gboolean rc = dbus_iface->ProxyCall_0_1(proxy,
+                                          "GetProperties",
+                                          &error,
+                                          out_hash_table);
   dbus_iface->ProxyUnref(proxy);
   if (rc == FALSE) {
     LOG(ERROR) << "dbus_g_proxy_call failed";
diff --git a/connection_manager_unittest.cc b/connection_manager_unittest.cc
index 3b88564..b8e8531 100644
--- a/connection_manager_unittest.cc
+++ b/connection_manager_unittest.cc
@@ -91,24 +91,17 @@
                       array_as_value);
 
   // Plumb return value into mock object.
-  EXPECT_CALL(dbus_iface_, ProxyCall(kMockFlimFlamManagerProxy_,
-                                     StrEq(kGetPropertiesMethod),
-                                     _,
-                                     G_TYPE_INVALID,
-                                     dbus_g_type_get_map("GHashTable",
-                                                         G_TYPE_STRING,
-                                                         G_TYPE_VALUE),
-                                     _,
-                                     G_TYPE_INVALID))
-      .WillOnce(DoAll(SetArgumentPointee<5>(manager_hash_table), Return(TRUE)));
+  EXPECT_CALL(dbus_iface_, ProxyCall_0_1(kMockFlimFlamManagerProxy_,
+                                         StrEq(kGetPropertiesMethod),
+                                         _, _))
+      .WillOnce(DoAll(SetArgumentPointee<3>(manager_hash_table), Return(TRUE)));
 
   // Set other expectations.
   EXPECT_CALL(dbus_iface_,
-              ProxyNewForNameOwner(kMockSystemBus_,
-                                   StrEq(shill::kFlimflamServiceName),
-                                   StrEq(shill::kFlimflamServicePath),
-                                   StrEq(shill::kFlimflamManagerInterface),
-                                   _))
+              ProxyNewForName(kMockSystemBus_,
+                              StrEq(shill::kFlimflamServiceName),
+                              StrEq(shill::kFlimflamServicePath),
+                              StrEq(shill::kFlimflamManagerInterface)))
       .WillOnce(Return(kMockFlimFlamManagerProxy_));
   EXPECT_CALL(dbus_iface_, ProxyUnref(kMockFlimFlamManagerProxy_));
   EXPECT_CALL(dbus_iface_, BusGet(DBUS_BUS_SYSTEM, _))
@@ -142,24 +135,17 @@
   }
 
   // Plumb return value into mock object.
-  EXPECT_CALL(dbus_iface_, ProxyCall(kMockFlimFlamServiceProxy_,
-                                    StrEq(kGetPropertiesMethod),
-                                    _,
-                                    G_TYPE_INVALID,
-                                    dbus_g_type_get_map("GHashTable",
-                                                        G_TYPE_STRING,
-                                                        G_TYPE_VALUE),
-                                    _,
-                                    G_TYPE_INVALID))
-      .WillOnce(DoAll(SetArgumentPointee<5>(service_hash_table), Return(TRUE)));
+  EXPECT_CALL(dbus_iface_, ProxyCall_0_1(kMockFlimFlamServiceProxy_,
+                                         StrEq(kGetPropertiesMethod),
+                                         _, _))
+      .WillOnce(DoAll(SetArgumentPointee<3>(service_hash_table), Return(TRUE)));
 
   // Set other expectations.
   EXPECT_CALL(dbus_iface_,
-      ProxyNewForNameOwner(kMockSystemBus_,
-                             StrEq(shill::kFlimflamServiceName),
-                             StrEq(kServicePath_),
-                             StrEq(shill::kFlimflamServiceInterface),
-                             _))
+              ProxyNewForName(kMockSystemBus_,
+                              StrEq(shill::kFlimflamServiceName),
+                              StrEq(kServicePath_),
+                              StrEq(shill::kFlimflamServiceInterface)))
       .WillOnce(Return(kMockFlimFlamServiceProxy_));
   EXPECT_CALL(dbus_iface_, ProxyUnref(kMockFlimFlamServiceProxy_));
   EXPECT_CALL(dbus_iface_, BusGet(DBUS_BUS_SYSTEM, _))
diff --git a/dbus_interface.h b/dbus_interface.h
index 24ed7c4..8a4b037 100644
--- a/dbus_interface.h
+++ b/dbus_interface.h
@@ -5,9 +5,8 @@
 #ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_DBUS_INTERFACE_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_DBUS_INTERFACE_H__
 
-// This class interfaces with DBus. The interface allows it to be mocked.
+// A mockable interface for DBus.
 
-#include <base/logging.h>
 #include <dbus/dbus-glib.h>
 #include <dbus/dbus-glib-lowlevel.h>
 
@@ -25,81 +24,79 @@
 
 class DbusGlibInterface {
  public:
-  // wraps dbus_g_proxy_new_for_name_owner
-  virtual DBusGProxy* ProxyNewForNameOwner(DBusGConnection* connection,
-                                           const char* name,
-                                           const char* path,
-                                           const char* interface,
-                                           GError** error) = 0;
+  // Wraps dbus_g_proxy_new_for_name().
+  virtual DBusGProxy* ProxyNewForName(DBusGConnection* connection,
+                                      const char* name,
+                                      const char* path,
+                                      const char* interface) = 0;
 
-  // wraps g_object_unref
+  // Wraps g_object_unref().
   virtual void ProxyUnref(DBusGProxy* proxy) = 0;
 
-  // wraps dbus_g_bus_get
+  // Wraps dbus_g_bus_get().
   virtual DBusGConnection* BusGet(DBusBusType type, GError** error) = 0;
 
-  // wraps dbus_g_proxy_call
-  virtual gboolean ProxyCall(DBusGProxy* proxy,
-                             const char* method,
-                             GError** error,
-                             GType first_arg_type,
-                             GType var_arg1,
-                             GHashTable** var_arg2,
-                             GType var_arg3) = 0;
+  // Wraps dbus_g_proxy_call(). Since this is a variadic function without a
+  // va_list equivalent, we have to list specific wrappers depending on the
+  // number of input and output arguments, based on the required usage. Note,
+  // however, that we do rely on automatic signature overriding to facilitate
+  // different types of input/output arguments.
+  virtual gboolean ProxyCall_0_1(DBusGProxy* proxy,
+                                 const char* method,
+                                 GError** error,
+                                 GHashTable** out1) = 0;
 
-  virtual gboolean ProxyCall(DBusGProxy* proxy,
-                             const char* method,
-                             GError** error,
-                             GType var_arg1, const char* var_arg2,
-                             GType var_arg3,
-                             GType var_arg4, gchar** var_arg5,
-                             GType var_arg6, GArray** var_arg7,
-                             GType var_arg8) = 0;
+  virtual gboolean ProxyCall_3_0(DBusGProxy* proxy,
+                                 const char* method,
+                                 GError** error,
+                                 const char* in1,
+                                 const char* in2,
+                                 const char* in3) = 0;
 
-  virtual gboolean ProxyCall(DBusGProxy* proxy,
-                             const char* method,
-                             GError** error,
-                             GType var_arg1, const char* var_arg2,
-                             GType var_arg3, const char* var_arg4,
-                             GType var_arg5, const char* var_arg6,
-                             GType var_arg7, GType var_arg8) = 0;
-
+  // Wraps dbus_g_connection_get_connection().
   virtual DBusConnection* ConnectionGetConnection(DBusGConnection* gbus) = 0;
 
+  // Wraps dbus_bus_add_match().
   virtual void DbusBusAddMatch(DBusConnection* connection,
                                const char* rule,
                                DBusError* error) = 0;
 
+  // Wraps dbus_connection_add_filter().
   virtual dbus_bool_t DbusConnectionAddFilter(
       DBusConnection* connection,
       DBusHandleMessageFunction function,
       void* user_data,
       DBusFreeFunction free_data_function) = 0;
+
+  // Wraps dbus_connection_remove_filter().
   virtual void DbusConnectionRemoveFilter(DBusConnection* connection,
                                           DBusHandleMessageFunction function,
                                           void* user_data) = 0;
+
+  // Wraps dbus_message_is_signal().
   virtual dbus_bool_t DbusMessageIsSignal(DBusMessage* message,
                                           const char* interface,
                                           const char* signal_name) = 0;
-  virtual dbus_bool_t DbusMessageGetArgs(DBusMessage* message,
-                                         DBusError* error,
-                                         GType var_arg1, char** var_arg2,
-                                         GType var_arg3, char** var_arg4,
-                                         GType var_arg5, char** var_arg6,
-                                         GType var_arg7) = 0;
+
+  // Wraps dbus_message_get_args(). Deploys the same approach for handling
+  // variadic arguments as ProxyCall above.
+  virtual dbus_bool_t DbusMessageGetArgs_3(DBusMessage* message,
+                                           DBusError* error,
+                                           char** out1,
+                                           char** out2,
+                                           char** out3) = 0;
 };
 
+
 class ConcreteDbusGlib : public DbusGlibInterface {
-  virtual DBusGProxy* ProxyNewForNameOwner(DBusGConnection* connection,
-                                           const char* name,
-                                           const char* path,
-                                           const char* interface,
-                                           GError** error) {
-    return dbus_g_proxy_new_for_name_owner(connection,
-                                           name,
-                                           path,
-                                           interface,
-                                           error);
+  virtual DBusGProxy* ProxyNewForName(DBusGConnection* connection,
+                                      const char* name,
+                                      const char* path,
+                                      const char* interface) {
+    return dbus_g_proxy_new_for_name(connection,
+                                     name,
+                                     path,
+                                     interface);
   }
 
   virtual void ProxyUnref(DBusGProxy* proxy) {
@@ -109,44 +106,30 @@
   virtual DBusGConnection* BusGet(DBusBusType type, GError** error) {
     return dbus_g_bus_get(type, error);
   }
-  
-  virtual gboolean ProxyCall(DBusGProxy* proxy,
-                             const char* method,
-                             GError** error,
-                             GType first_arg_type,
-                             GType var_arg1,
-                             GHashTable** var_arg2,
-                             GType var_arg3) {
-    return dbus_g_proxy_call(
-        proxy, method, error, first_arg_type, var_arg1, var_arg2, var_arg3);
+
+  virtual gboolean ProxyCall_0_1(DBusGProxy* proxy,
+                                 const char* method,
+                                 GError** error,
+                                 GHashTable** out1) {
+    return dbus_g_proxy_call(proxy, method, error, G_TYPE_INVALID,
+                             dbus_g_type_get_map("GHashTable",
+                                                 G_TYPE_STRING,
+                                                 G_TYPE_VALUE),
+                             out1, G_TYPE_INVALID);
   }
 
-  virtual gboolean ProxyCall(DBusGProxy* proxy,
-                             const char* method,
-                             GError** error,
-                             GType var_arg1, const char* var_arg2,
-                             GType var_arg3,
-                             GType var_arg4, gchar** var_arg5,
-                             GType var_arg6, GArray** var_arg7,
-                             GType var_arg8) {
+  virtual gboolean ProxyCall_3_0(DBusGProxy* proxy,
+                                 const char* method,
+                                 GError** error,
+                                 const char* in1,
+                                 const char* in2,
+                                 const char* in3) {
     return dbus_g_proxy_call(
-        proxy, method, error, var_arg1, var_arg2, var_arg3,
-        var_arg4, var_arg5, var_arg6, var_arg7, var_arg8);
+        proxy, method, error,
+        G_TYPE_STRING, in1, G_TYPE_STRING, in2, G_TYPE_STRING, in3,
+        G_TYPE_INVALID, G_TYPE_INVALID);
   }
 
-  virtual gboolean ProxyCall(DBusGProxy* proxy,
-                             const char* method,
-                             GError** error,
-                             GType var_arg1, const char* var_arg2,
-                             GType var_arg3, const char* var_arg4,
-                             GType var_arg5, const char* var_arg6,
-                             GType var_arg7, GType var_arg8) {
-    return dbus_g_proxy_call(
-        proxy, method, error, var_arg1, var_arg2, var_arg3,
-        var_arg4, var_arg5, var_arg6, var_arg7, var_arg8);
-  }
-
-
   virtual DBusConnection* ConnectionGetConnection(DBusGConnection* gbus) {
     return dbus_g_connection_get_connection(gbus);
   }
@@ -167,27 +150,29 @@
                                       user_data,
                                       free_data_function);
   }
+
   virtual void DbusConnectionRemoveFilter(DBusConnection* connection,
                                           DBusHandleMessageFunction function,
                                           void* user_data) {
     dbus_connection_remove_filter(connection, function, user_data);
   }
+
   dbus_bool_t DbusMessageIsSignal(DBusMessage* message,
                                   const char* interface,
                                   const char* signal_name) {
     return dbus_message_is_signal(message, interface, signal_name);
   }
-  virtual dbus_bool_t DbusMessageGetArgs(DBusMessage* message,
-                                         DBusError* error,
-                                         GType var_arg1, char** var_arg2,
-                                         GType var_arg3, char** var_arg4,
-                                         GType var_arg5, char** var_arg6,
-                                         GType var_arg7) {
+
+  virtual dbus_bool_t DbusMessageGetArgs_3(DBusMessage* message,
+                                           DBusError* error,
+                                           char** out1,
+                                           char** out2,
+                                           char** out3) {
     return dbus_message_get_args(message, error,
-                                 var_arg1, var_arg2,
-                                 var_arg3, var_arg4,
-                                 var_arg5, var_arg6,
-                                 var_arg7);
+                                 DBUS_TYPE_STRING, out1,
+                                 DBUS_TYPE_STRING, out2,
+                                 DBUS_TYPE_STRING, out3,
+                                 G_TYPE_INVALID);
   }
 };
 
diff --git a/mock_dbus_interface.h b/mock_dbus_interface.h
index 781b3f3..02a4bfc 100644
--- a/mock_dbus_interface.h
+++ b/mock_dbus_interface.h
@@ -13,37 +13,25 @@
 
 class MockDbusGlib : public DbusGlibInterface {
  public:
-  MOCK_METHOD5(ProxyNewForNameOwner, DBusGProxy*(DBusGConnection *connection,
-                                                 const char *name,
-                                                 const char *path,
-                                                 const char *interface,
-                                                 GError **error));
+  MOCK_METHOD4(ProxyNewForName, DBusGProxy*(DBusGConnection *connection,
+                                            const char *name,
+                                            const char *path,
+                                            const char *interface));
 
   MOCK_METHOD1(ProxyUnref, void(DBusGProxy* proxy));
 
   MOCK_METHOD2(BusGet, DBusGConnection*(DBusBusType type, GError **error));
 
-  MOCK_METHOD7(ProxyCall, gboolean(DBusGProxy *proxy,
-                                   const char *method,
-                                   GError **error,
-                                   GType first_arg_type,
-                                   GType var_arg1,
-                                   GHashTable** var_arg2,
-                                   GType var_arg3));
-  MOCK_METHOD10(ProxyCall, gboolean(DBusGProxy* proxy,
-                                    const char* method,
-                                    GError** error,
-                                    GType var_arg1, const char* var_arg2,
-                                    GType var_arg3,
-                                    GType var_arg4, gchar** var_arg5,
-                                    GType var_arg6, GArray** var_arg7));
-  MOCK_METHOD10(ProxyCall, gboolean(DBusGProxy* proxy,
-                                    const char* method,
-                                    GError** error,
-                                    GType var_arg1, const char* var_arg2,
-                                    GType var_arg3, const char* var_arg4,
-                                    GType var_arg5, const char* var_arg6,
-                                    GType var_arg7));
+  MOCK_METHOD4(ProxyCall_0_1, gboolean(DBusGProxy *proxy,
+                                       const char *method,
+                                       GError **error,
+                                       GHashTable** out1));
+  MOCK_METHOD6(ProxyCall_3_0, gboolean(DBusGProxy* proxy,
+                                       const char* method,
+                                       GError** error,
+                                       const char* in1,
+                                       const char* in2,
+                                       const char* in3));
 
   MOCK_METHOD1(ConnectionGetConnection, DBusConnection*(DBusGConnection* gbus));
 
@@ -66,49 +54,11 @@
                                                 const char* interface,
                                                 const char* signal_name));
 
-  MOCK_METHOD9(DbusMessageGetArgs, dbus_bool_t(
-      DBusMessage* message,
-      DBusError* error,
-      GType var_arg1, char** var_arg2,
-      GType var_arg3, char** var_arg4,
-      GType var_arg5, char** var_arg6,
-      GType var_arg7));
-
-  // Since gmock only supports mocking functions up to 10 args, we
-  // take the 11-arg function we'd like to mock, drop the last arg
-  // and call the 10-arg version. Dropping the last arg isn't ideal,
-  // but this is a lot better than nothing.
-  gboolean ProxyCall(DBusGProxy* proxy,
-                     const char* method,
-                     GError** error,
-                     GType var_arg1, const char* var_arg2,
-                     GType var_arg3,
-                     GType var_arg4, gchar** var_arg5,
-                     GType var_arg6, GArray** var_arg7,
-                     GType var_arg8) {
-    return ProxyCall(proxy,
-                     method,
-                     error,
-                     var_arg1, var_arg2,
-                     var_arg3,
-                     var_arg4, var_arg5,
-                     var_arg6, var_arg7);
-  }
-  gboolean ProxyCall(DBusGProxy* proxy,
-                     const char* method,
-                     GError** error,
-                     GType var_arg1, const char* var_arg2,
-                     GType var_arg3, const char* var_arg4,
-                     GType var_arg5, const char* var_arg6,
-                     GType var_arg7, GType var_arg8) {
-    return ProxyCall(proxy,
-                     method,
-                     error,
-                     var_arg1, var_arg2,
-                     var_arg3,
-                     var_arg4, var_arg5,
-                     var_arg6, var_arg7);
-  }
+  MOCK_METHOD5(DbusMessageGetArgs_3, dbus_bool_t(DBusMessage* message,
+                                                 DBusError* error,
+                                                 char** out1,
+                                                 char** out2,
+                                                 char** out3));
 };
 
 }  // namespace chromeos_update_engine