diff --git a/modules/printbackends/cloudprint/Makefile.am b/modules/printbackends/cloudprint/Makefile.am
index e64d4ac..e606f47 100644
--- a/modules/printbackends/cloudprint/Makefile.am
+++ b/modules/printbackends/cloudprint/Makefile.am
@@ -8,22 +8,8 @@ backenddir = $(libdir)/gtk-3.0/$(GTK_BINARY_VERSION)/printbackends
 
 backend_LTLIBRARIES = libprintbackend-cloudprint.la
 
-dbus_built_sources = goa-generated.c goa-generated.h
-
-.stamp-dbus-built-sources: Makefile.am goa-interfaces.xml
-	gdbus-codegen \
-		--interface-prefix org.gnome.OnlineAccounts. \
-		--c-namespace Goa \
-		--c-generate-object-manager \
-		--generate-c-code goa-generated \
-		goa-interfaces.xml
-
-$(dbus_built_sources): .stamp-dbus-built-sources
-
 libprintbackend_cloudprint_la_SOURCES = \
-	gtkprintbackendcloudprint.c \
-	goa-generated.c \
-	goa-generated.h
+	gtkprintbackendcloudprint.c
 
 libprintbackend_cloudprint_la_CPPFLAGS = \
 	-I$(top_srcdir) 				\
@@ -32,13 +18,11 @@ libprintbackend_cloudprint_la_CPPFLAGS = \
 	-I$(top_srcdir)/gdk				\
 	-I$(top_builddir)/gdk				\
 	-DGTK_PRINT_BACKEND_ENABLE_UNSUPPORTED		\
-	-DGOA_API_IS_SUBJECT_TO_CHANGE			\
 	$(AM_CPPFLAGS)
 
 libprintbackend_cloudprint_la_CFLAGS = \
 	$(GTK_DEP_CFLAGS)				\
 	$(GTK_DEBUG_FLAGS)				\
-	$(GOA_CFLAGS)					\
 	$(REST_CFLAGS)					\
 	$(JSON_GLIB_CFLAGS)				\
 	$(AM_CFLAGS)
@@ -48,7 +32,6 @@ libprintbackend_cloudprint_la_LDFLAGS =  \
 
 libprintbackend_cloudprint_la_LIBADD =			\
 	$(top_builddir)/gtk/libgtk-3.la			\
-	$(GOA_LIBS)					\
 	$(REST_LIBS)					\
 	$(JSON_GLIB_LIBS)				\
 	$(GTK_DEP_LIBS)
diff --git a/modules/printbackends/cloudprint/gtkprintbackendcloudprint.c b/modules/printbackends/cloudprint/gtkprintbackendcloudprint.c
index 0915b41..c2883e3 100644
--- a/modules/printbackends/cloudprint/gtkprintbackendcloudprint.c
+++ b/modules/printbackends/cloudprint/gtkprintbackendcloudprint.c
@@ -41,7 +41,6 @@
 #include <rest/rest-proxy-call.h>
 #include <json-glib/json-glib.h>
 
-#include "goa-generated.h"
 #include "gtkprintbackendcloudprint.h"
 
 
@@ -54,6 +53,12 @@ typedef struct _GtkPrintBackendCloudprintClass GtkPrintBackendCloudprintClass;
 #define CLOUDPRINT_PROXY "GTK+"
 #define _STREAM_MAX_CHUNK_SIZE 8192
 
+#define ONLINE_ACCOUNTS_BUS  "org.gnome.OnlineAccounts"
+#define ONLINE_ACCOUNTS_PATH "/org/gnome/OnlineAccounts"
+#define ACCOUNT_IFACE        "org.gnome.OnlineAccounts.Account"
+#define O_AUTH2_BASED_IFACE  "org.gnome.OnlineAccounts.OAuth2Based"
+#define OBJECT_MANAGER_IFACE "org.freedesktop.DBus.ObjectManager"
+
 static GType print_backend_cloudprint_type = 0;
 
 struct _GtkPrintBackendCloudprintClass
@@ -61,18 +66,23 @@ struct _GtkPrintBackendCloudprintClass
   GtkPrintBackendClass parent_class;
 };
 
+struct
+{
+  gchar *id;
+  gchar *path;
+} typedef TGOAAccount;
+
 struct _GtkPrintBackendCloudprint
 {
   GtkPrintBackend parent_instance;
 
   GCancellable *cancellable;
-  GoaObject *goa_object;
+  TGOAAccount *goa_account;
   RestProxy *rest_proxy;
   gchar *oauth2_access_token;
 };
 
 static GObjectClass *backend_parent_class;
-
 static void                 gtk_print_backend_cloudprint_class_init      (GtkPrintBackendCloudprintClass *class);
 static void                 gtk_print_backend_cloudprint_init            (GtkPrintBackendCloudprint      *impl);
 static void                 gtk_print_backend_cloudprint_finalize	 (GObject *object);
@@ -113,6 +123,10 @@ static void		    cloudprint_printer_rest_call_cb		 (RestProxyCall	*call,
 									  gpointer	userdata);
 static void                 cloudprint_printer_request_details           (GtkPrinter *printer);
 
+static TGOAAccount *        t_goa_account_copy                           (TGOAAccount *account);
+static void                 t_goa_account_free                           (gpointer data);
+
+
 static void
 gtk_print_backend_cloudprint_register_type (GTypeModule *module)
 {
@@ -213,25 +227,11 @@ gtk_print_backend_cloudprint_finalize (GObject *object)
 
   backend = GTK_PRINT_BACKEND_CLOUDPRINT (object);
 
-  if (backend->rest_proxy != NULL)
-    {
-      g_object_unref (backend->rest_proxy);
-      backend->rest_proxy = NULL;
-    }
-
-  if (backend->goa_object != NULL)
-    {
-      g_object_unref (backend->goa_object);
-      backend->goa_object = NULL;
-    }
-
-  if (backend->oauth2_access_token != NULL)
-    {
-      g_free (backend->oauth2_access_token);
-      backend->oauth2_access_token = NULL;
-    }
-
+  g_clear_object (&(backend->rest_proxy));
+  g_clear_pointer (&(backend->goa_account), t_goa_account_free);
+  g_clear_pointer (&(backend->oauth2_access_token), g_free);
   g_object_unref (backend->cancellable);
+
   backend_parent_class->finalize (object);
 }
 
@@ -613,84 +613,211 @@ error:
 		  ps);
 }
 
-static void
-cloudprint_got_oauth2_access_token_cb (GObject *source,
-				       GAsyncResult *result,
-				       gpointer user_data)
+static TGOAAccount *
+t_goa_account_copy (TGOAAccount *account)
 {
-  GtkPrintBackendCloudprint *backend = GTK_PRINT_BACKEND_CLOUDPRINT (user_data);
-  GoaOAuth2Based *oauth2 = (GoaOAuth2Based *) source;
-  gchar *access_token;
-  gint expires_in;
-  RestProxy *rest;
-  RestProxyCall *call;
-  GError *error = NULL;
-
-  if (!goa_oauth2_based_call_get_access_token_finish (oauth2,
-						      &access_token,
-						      &expires_in,
-						      result,
-						      &error))
+  TGOAAccount *result = NULL;
+
+  if (account != NULL)
     {
-      GTK_NOTE (PRINTING,
-		g_print ("Cloud Print Backend: failed to get access token: %s\n",
-			 error->message));
-      g_clear_error (&error);
-      g_object_unref (oauth2);
-      g_object_unref (backend->goa_object);
-      backend->goa_object = NULL;
-      goto fail;
+      result = g_new0 (TGOAAccount, 1);
+      result->id = g_strdup (account->id);
+      result->path = g_strdup (account->path);
     }
 
-  backend->oauth2_access_token = g_strdup (access_token);
+  return result;
+}
+
+static void
+t_goa_account_free (gpointer data)
+{
+  TGOAAccount *account = (TGOAAccount *) data;
 
-  GTK_NOTE (PRINTING,
-	    g_print ("Cloud Print Backend: got access token\n"));
+  if (account != NULL)
+    {
+      g_free (account->id);
+      g_free (account->path);
+      g_free (account);
+    }
+}
 
-  rest = oauth2_proxy_new_with_token (goa_oauth2_based_get_client_id (oauth2),
-				      access_token,
-				      "https://accounts.google.com/o/oauth2/token",
-				      "https://www.google.com/cloudprint/",
-				      FALSE);
+static GList *
+get_accounts (GVariant *output)
+{
+  GVariant *objects;
+  GList    *result = NULL;
+  gint      i, j, k;
 
-  g_object_unref (oauth2);
-  g_free (access_token);
-  g_object_unref (backend->goa_object);
-  backend->goa_object = NULL;
+  g_variant_get (output, "(@a{oa{sa{sv}}})",
+                 &objects);
 
-  if (rest == NULL)
+  if (objects)
     {
-      GTK_NOTE (PRINTING,
-		g_print ("Cloud Print Backend: REST proxy creation failed\n"));
-      goto fail;
+      for (i = 0; i < g_variant_n_children (objects); i++)
+        {
+          const gchar *object_name;
+          GVariant    *object_variant;
+
+          g_variant_get_child (objects, i, "{&o@a{sa{sv}}}",
+                               &object_name,
+                               &object_variant);
+
+          if (g_str_has_prefix (object_name, "/org/gnome/OnlineAccounts/Accounts/"))
+            {
+              for (j = 0; j < g_variant_n_children (object_variant); j++)
+                {
+                  const gchar *service_name;
+                  GVariant    *service_variant;
+
+                  g_variant_get_child (object_variant, j, "{&s@a{sv}}",
+                                       &service_name,
+                                       &service_variant);
+
+                  if (g_str_has_prefix (service_name, "org.gnome.OnlineAccounts.Account"))
+                    {
+                      TGOAAccount *account;
+                      gboolean     printers_disabled = FALSE;
+                      gchar       *provider_type = NULL;
+
+                      account = g_new0 (TGOAAccount, 1);
+
+                      account->path = g_strdup (object_name);
+                      for (k = 0; k < g_variant_n_children (service_variant); k++)
+                        {
+                          const gchar *property_name;
+                          GVariant    *property_variant;
+                          GVariant    *value;
+
+                          g_variant_get_child (service_variant, k, "{&s@v}",
+                                               &property_name,
+                                               &property_variant);
+
+                          g_variant_get (property_variant, "v",
+                                         &value);
+
+                          if (g_strcmp0 (property_name, "Id") == 0)
+                            account->id = g_variant_dup_string (value, NULL);
+                          else if (g_strcmp0 (property_name, "ProviderType") == 0)
+                            provider_type = g_variant_dup_string (value, NULL);
+                          else if (g_strcmp0 (property_name, "PrintersDisabled") == 0)
+                            printers_disabled = g_variant_get_boolean (value);
+
+                          g_variant_unref (property_variant);
+                          g_variant_unref (value);
+                        }
+
+                      if (!printers_disabled &&
+                          g_strcmp0 (provider_type, "google") == 0)
+                        result = g_list_append (result, account);
+                      else
+                        t_goa_account_free (account);
+
+                      g_free (provider_type);
+                    }
+
+                  g_variant_unref (service_variant);
+                }
+            }
+
+          g_variant_unref (object_variant);
+        }
+
+      g_variant_unref (objects);
     }
 
-  backend->rest_proxy = g_object_ref (rest);
-
-  call = rest_proxy_new_call (REST_PROXY (rest));
-  g_object_unref (rest);
-  rest_proxy_call_set_function (call, "search");
-  rest_proxy_call_add_header (call, "X-CloudPrint-Proxy", CLOUDPRINT_PROXY);
-  rest_proxy_call_add_param (call, "connection_status", "ALL");
-  if (!rest_proxy_call_async (call,
-			      cloudprint_search_rest_call_cb,
-			      G_OBJECT (backend),
-			      user_data,
-			      &error))
+  return result;
+}
+
+static void
+cloudprint_got_oauth2_access_token_cb (GObject      *source,
+                                       GAsyncResult *res,
+                                       gpointer      user_data)
+{
+  GtkPrintBackendCloudprint *backend;
+  RestProxyCall             *call;
+  RestProxy                 *rest;
+  GVariant                  *output;
+  GError                    *error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), res, &error);
+
+  if (output != NULL)
     {
-      GTK_NOTE (PRINTING,
-		g_printerr ("Cloud Print Backend: failed to call search: %s\n",
-			    error->message));
+      gchar *access_token = NULL;
+      gint   expires_in = 0;
+
+      backend = GTK_PRINT_BACKEND_CLOUDPRINT (user_data);
+
+      g_variant_get (output, "(si)",
+                     &access_token,
+                     &expires_in);
+      g_variant_unref (output);
+
+      backend->oauth2_access_token = g_strdup (access_token);
+
+      rest = oauth2_proxy_new_with_token (backend->goa_account->id,
+					  access_token,
+					  "https://accounts.google.com/o/oauth2/token",
+					  "https://www.google.com/cloudprint/",
+					  FALSE);
+
+      if (rest != NULL)
+        {
+          backend->rest_proxy = g_object_ref (rest);
+
+          call = rest_proxy_new_call (REST_PROXY (rest));
+          g_object_unref (rest);
+          rest_proxy_call_set_function (call, "search");
+          rest_proxy_call_add_header (call, "X-CloudPrint-Proxy", CLOUDPRINT_PROXY);
+          rest_proxy_call_add_param (call, "connection_status", "ALL");
+          if (!rest_proxy_call_async (call,
+			              cloudprint_search_rest_call_cb,
+			              G_OBJECT (backend),
+			              backend,
+			              &error))
+            {
+              GTK_NOTE (PRINTING,
+		        g_printerr ("Cloud Print Backend: failed to call search: %s\n",
+			            error->message));
+              g_error_free (error);
+              g_object_unref (call);
+              gtk_print_backend_set_list_done (GTK_PRINT_BACKEND (backend));
+            }
+        }
+      else
+        {
+          GTK_NOTE (PRINTING,
+		    g_print ("Cloud Print Backend: REST proxy creation failed\n"));
+          gtk_print_backend_set_list_done (GTK_PRINT_BACKEND (backend));
+        }
+
+      g_free (access_token);
+      g_clear_pointer (&(backend->goa_account), t_goa_account_free);
+    }
+  else
+    {
+      if (error->domain != G_IO_ERROR ||
+          error->code != G_IO_ERROR_CANCELLED)
+        {
+          if (error->domain != G_DBUS_ERROR ||
+              (error->code != G_DBUS_ERROR_SERVICE_UNKNOWN &&
+               error->code != G_DBUS_ERROR_UNKNOWN_METHOD))
+            {
+              GTK_NOTE (PRINTING,
+                        g_print ("Cloud Print Backend: failed to get access token: %s\n",
+                                 error->message));
+              g_warning ("%s", error->message);
+            }
+
+          backend = GTK_PRINT_BACKEND_CLOUDPRINT (user_data);
+          gtk_print_backend_set_list_done (GTK_PRINT_BACKEND (backend));
+          g_clear_pointer (&(backend->goa_account), t_goa_account_free);
+        }
+
       g_error_free (error);
-      g_object_unref (call);
-      goto fail;
     }
 
-  /* Not done yet; wait for callback */
-  return;
-
- fail:
-  gtk_print_backend_set_list_done (GTK_PRINT_BACKEND (backend));
+  g_object_unref (source);
 }
 
 static void
@@ -702,133 +829,200 @@ cloudprint_backend_disposed (gpointer data,
 }
 
 static void
-cloudprint_ensure_credentials_cb (GObject *source,
-				  GAsyncResult *result,
-				  gpointer user_data)
+cloudprint_ensure_credentials_cb (GObject      *source,
+                                  GAsyncResult *res,
+                                  gpointer      user_data)
 {
   GtkPrintBackendCloudprint *backend = NULL;
-  GoaAccount *goa_account = (GoaAccount *) source;
-  GoaOAuth2Based *oauth2;
-  gint expires_in;
-  GError *error = NULL;
+  GVariant                  *output;
+  GError                    *error = NULL;
 
-  if (!goa_account_call_ensure_credentials_finish (goa_account, &expires_in,
-						   result, &error))
-    {
-      GTK_NOTE (PRINTING,
-		g_print ("Cloud Print Backend: failed ensuring credentials: %s\n",
-			 error->message));
-      g_clear_error (&error);
-      goto fail;
-    }
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), res, &error);
 
-  g_object_unref (goa_account);
-  backend = GTK_PRINT_BACKEND_CLOUDPRINT (user_data);
-  oauth2 = goa_object_get_oauth2_based (backend->goa_object);
-  if (oauth2 != NULL)
+  if (output != NULL)
     {
-      goa_oauth2_based_call_get_access_token (oauth2, backend->cancellable,
-					      cloudprint_got_oauth2_access_token_cb,
-					      backend);
+      gint expires_in = 0;
 
-      g_object_unref (oauth2);
-      return;
-    }
+      backend = GTK_PRINT_BACKEND_CLOUDPRINT (user_data);
 
-fail:
-  if (backend != NULL)
+      g_variant_get (output, "(i)",
+                     &expires_in);
+      g_variant_unref (output);
+
+      g_dbus_connection_call (G_DBUS_CONNECTION (g_object_ref (source)),
+                              ONLINE_ACCOUNTS_BUS,
+                              backend->goa_account->path,
+                              O_AUTH2_BASED_IFACE,
+                              "GetAccessToken",
+                              NULL,
+                              G_VARIANT_TYPE ("(si)"),
+                              G_DBUS_CALL_FLAGS_NONE,
+                              -1,
+                              backend->cancellable,
+                              cloudprint_got_oauth2_access_token_cb,
+                              backend);
+    }
+  else
     {
-      g_object_unref (backend->goa_object);
-      backend->goa_object = NULL;
-      gtk_print_backend_set_list_done (GTK_PRINT_BACKEND (backend));
+      if (error->domain != G_IO_ERROR ||
+          error->code != G_IO_ERROR_CANCELLED)
+        {
+          if (error->domain != G_DBUS_ERROR ||
+              (error->code != G_DBUS_ERROR_SERVICE_UNKNOWN &&
+               error->code != G_DBUS_ERROR_UNKNOWN_METHOD))
+            {
+              GTK_NOTE (PRINTING,
+                        g_print ("Cloud Print Backend: failed ensuring credentials: %s\n",
+                                 error->message));
+              g_warning ("%s", error->message);
+            }
+
+          gtk_print_backend_set_list_done (GTK_PRINT_BACKEND (user_data));
+        }
+
+      g_error_free (error);
     }
+
+  g_object_unref (source);
 }
 
 static void
-cloudprint_goa_object_manager_new_cb (GObject *source,
-				      GAsyncResult *res,
-				      gpointer user_data)
+cloudprint_get_managed_objects_cb (GObject      *source,
+                                   GAsyncResult *res,
+                                   gpointer      user_data)
 {
-  GtkPrintBackendCloudprint *backend = GTK_PRINT_BACKEND_CLOUDPRINT (user_data);
-  GDBusObjectManager *object_manager = NULL;
-  GList *objects;
-  GList *item;
-  GoaObject *goa_object;
-  GError *error = NULL;
+  GtkPrintBackendCloudprint *backend;
+  GVariant *output;
+  GError   *error = NULL;
+
+  output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), res, &error);
 
-  object_manager = goa_object_manager_client_new_for_bus_finish (res, &error);
-  if (object_manager == NULL)
+  if (output != NULL)
     {
+      TGOAAccount *account;
+      GList       *accounts = NULL;
+      GList       *iter;
+
       GTK_NOTE (PRINTING,
-		g_printerr ("Cloud Print Backend: failed to create "
-			    "goa object manager: %s\n",
-			    error->message));
-      goto done;
+                g_print ("Cloud Print Backend: got objects managed by goa\n"));
+
+      backend = GTK_PRINT_BACKEND_CLOUDPRINT (user_data);
+
+      accounts = get_accounts (output);
+      g_variant_unref (output);
+
+      for (iter = accounts; iter != NULL; iter = iter->next)
+        {
+          account = (TGOAAccount *) iter->data;
+
+          GTK_NOTE (PRINTING,
+                    g_print ("Cloud Print Backend: ensuring credentials for %s\n",
+                             account->id));
+
+          backend->goa_account = t_goa_account_copy (account);
+
+          g_dbus_connection_call (G_DBUS_CONNECTION (g_object_ref (source)),
+                                  ONLINE_ACCOUNTS_BUS,
+                                  account->path,
+                                  ACCOUNT_IFACE,
+                                  "EnsureCredentials",
+                                  NULL,
+                                  G_VARIANT_TYPE ("(i)"),
+                                  G_DBUS_CALL_FLAGS_NONE,
+                                  -1,
+                                  backend->cancellable,
+                                  cloudprint_ensure_credentials_cb,
+                                  backend);
+
+          break;
+        }
+
+      if (iter == NULL)
+        gtk_print_backend_set_list_done (GTK_PRINT_BACKEND (backend));
+
+      g_list_free_full (accounts, t_goa_account_free);
     }
+  else
+    {
+      if (error->domain != G_IO_ERROR ||
+          error->code != G_IO_ERROR_CANCELLED)
+        {
+          if (error->domain != G_DBUS_ERROR ||
+              (error->code != G_DBUS_ERROR_SERVICE_UNKNOWN &&
+               error->code != G_DBUS_ERROR_UNKNOWN_METHOD))
+            {
+              GTK_NOTE (PRINTING,
+                        g_print ("Cloud Print Backend: failed to get objects managed by goa: %s\n",
+                                 error->message));
+              g_warning ("%s", error->message);
+            }
+
+          gtk_print_backend_set_list_done (GTK_PRINT_BACKEND (user_data));
+        }
+
+      g_error_free (error);
+    }
+
+  g_object_unref (source);
+}
 
-  GTK_NOTE (PRINTING,
-	    g_print ("Cloud Print Backend: got goa object manager\n"));
+static void
+cloudprint_bus_get_cb (GObject      *source,
+                       GAsyncResult *res,
+                       gpointer      user_data)
+{
+  GtkPrintBackendCloudprint *backend;
+  GDBusConnection *connection;
+  GError *error = NULL;
 
-  objects = g_dbus_object_manager_get_objects (object_manager);
-  for (item = g_list_first (objects);
-       item != NULL;
-       item = g_list_next (item))
+  connection = g_bus_get_finish (res, &error);
+
+  if (connection != NULL)
     {
-      goa_object = GOA_OBJECT (item->data);
-      GoaAccount *account;
-
-      if (goa_object_peek_account (goa_object) == NULL)
-	continue;
-
-      account = goa_object_get_account (goa_object);
-      if (goa_account_get_printers_disabled (account) ||
-	  strcmp (goa_account_get_provider_type (account), "google") != 0)
-	{
-	  /* Not a cloudprint account, or printers disabled */
-	  g_object_unref (account);
-	  continue;
-	}
-
-      backend->goa_object = g_object_ref (goa_object);
+      backend = GTK_PRINT_BACKEND_CLOUDPRINT (user_data);
+
       GTK_NOTE (PRINTING,
-		g_print ("Cloud Print Backend: ensuring credentials for %s\n",
-			 goa_account_get_id (account)));
-
-      goa_account_call_ensure_credentials (account, backend->cancellable,
-					   cloudprint_ensure_credentials_cb,
-					   GTK_PRINT_BACKEND (backend));
-      g_object_unref (account);
-      break;
-    }
+                g_print ("Cloud Print Backend: got connection to session bus\n"));
 
-  g_list_foreach (objects, (GFunc) g_object_unref, NULL);
-  g_list_free (objects);
-  g_object_unref (object_manager);
+      g_dbus_connection_call (connection,
+                              ONLINE_ACCOUNTS_BUS,
+                              ONLINE_ACCOUNTS_PATH,
+                              OBJECT_MANAGER_IFACE,
+                              "GetManagedObjects",
+                              NULL,
+                              G_VARIANT_TYPE ("(a{oa{sa{sv}}})"),
+                              G_DBUS_CALL_FLAGS_NONE,
+                              -1,
+                              backend->cancellable,
+                              cloudprint_get_managed_objects_cb,
+                              backend);
+    }
+  else
+    {
+      if (error->code != G_IO_ERROR_CANCELLED)
+        {
+          GTK_NOTE (PRINTING,
+                    g_print ("Cloud Print Backend: failed getting session bus: %s\n",
+                             error->message));
+          g_warning ("%s", error->message);
 
-  if (item == NULL)
-  done:
-    gtk_print_backend_set_list_done (GTK_PRINT_BACKEND (backend));
+          gtk_print_backend_set_list_done (GTK_PRINT_BACKEND (user_data));
+        }
+      g_error_free (error);
+    }
 }
 
 static void
 cloudprint_request_printer_list (GtkPrintBackend *print_backend)
 {
-  GtkPrintBackendCloudprint *backend;
-
-  backend = GTK_PRINT_BACKEND_CLOUDPRINT (print_backend);
+  GtkPrintBackendCloudprint *backend = GTK_PRINT_BACKEND_CLOUDPRINT (print_backend);
 
   g_cancellable_reset (backend->cancellable);
   g_object_weak_ref (G_OBJECT (print_backend),
 		     cloudprint_backend_disposed,
 		     backend);
 
-  goa_object_manager_client_new_for_bus (G_BUS_TYPE_SESSION,
-					 G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
-					 "org.gnome.OnlineAccounts",
-					 "/org/gnome/OnlineAccounts",
-					 backend->cancellable,
-					 cloudprint_goa_object_manager_new_cb,
-					 backend);
+  g_bus_get (G_BUS_TYPE_SESSION, backend->cancellable, cloudprint_bus_get_cb, backend);
 }
 
 static void
