Cleanup DBus interface.
Prior to importing the DBus interface into the Policy Manager, this
removes some clutter and fixes some behaviors.
* Switch from using dbus_g_proxy_new_for_name_owner() to using
dbus_g_proxy_new_for_name() instead. This has been advised in the past
(see chromium:209102) as the _owner version is mostly used for binding
to interfaces that do not retain the well-known name. It is not
appropriate for our use cases, where the provider inhibits the
well-known location constantly, nor is it a good thing given that
providers (e.g. Chrome) could get recycled.
* More consistent abstraction for variadic DBus functions: (a) We now
distinguish between different numbers of input/output arguments by
appending these numbers to the names of interface functions (e.g.
ProxyCall_3_0 delegates 3 input arguments and zero outputs); (b) We
drop G_TYPE arguments and embed them as constants in the delegating
code. This makes more sense because these types are constants and
depend on the actual values, which are bound to predetermined C/C++
types anyway; (c) It is still possible to override such functions by
variating the types of actual arguments (currently not exercised).
* The above also shortens the argument list for several DBus interface
functions, saving us from needing to prune them to fit in mock methods
with a maximum of 10 arguments (as was previously necessary).
* Removed an unnecessary #include; better comments; more descriptive
argument names.
Other notable changes in client code:
* Some cleaup in chrome_browser_proxy_resolver.cc, removing unnecessary
functions and reverting the proxy reacquisition logic introduced in
CL:15693, which is now redundant.
BUG=None
TEST=Unit tests.
Change-Id: I8063bb3e35c34212a8be1ae507834c931ee5a0b0
Reviewed-on: https://chromium-review.googlesource.com/188560
Tested-by: Gilad Arnold <garnold@chromium.org>
Reviewed-by: David Zeuthen <zeuthen@chromium.org>
Reviewed-by: Alex Deymo <deymo@chromium.org>
Commit-Queue: Gilad Arnold <garnold@chromium.org>
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