diff -up evolution-3.12.11/e-util/e-client-cache.c.client-cache-stuck evolution-3.12.11/e-util/e-client-cache.c
--- evolution-3.12.11/e-util/e-client-cache.c.client-cache-stuck	2015-01-27 14:46:14.000000000 +0100
+++ evolution-3.12.11/e-util/e-client-cache.c	2015-07-15 18:08:54.368866342 +0200
@@ -531,8 +531,12 @@ client_cache_process_results (ClientData
 	if (client != NULL) {
 		EClientCache *client_cache;
 
-		/* Make sure we're not leaking a reference. */
-		g_warn_if_fail (client_data->client == NULL);
+		/* Make sure we're not leaking a reference. This can happen when
+		   a synchronous and an asynchronous open are interleaving. The
+		   synchronous open bypasses pending openings, thus can eventually
+		   overwrite, or preset, the client.
+		*/
+		g_clear_object (&client_data->client);
 
 		client_data->client = g_object_ref (client);
 		client_data->dead_backend = FALSE;
@@ -1047,28 +1051,6 @@ e_client_cache_ref_registry (EClientCach
 	return g_object_ref (client_cache->priv->registry);
 }
 
-typedef struct _GetClientSyncData {
-	GMutex mutex;
-	EAsyncClosure *closure;
-} GetClientSyncData;
-
-static void
-client_cache_get_client_sync_cb (GObject *source_object,
-				 GAsyncResult *result,
-				 gpointer user_data)
-{
-	GetClientSyncData *data = user_data;
-
-	g_return_if_fail (E_IS_CLIENT_CACHE (source_object));
-	g_return_if_fail (data != NULL);
-
-	g_mutex_lock (&data->mutex);
-
-	e_async_closure_callback (source_object, result, data->closure);
-
-	g_mutex_unlock (&data->mutex);
-}
-
 /**
  * e_client_cache_get_client_sync:
  * @client_cache: an #EClientCache
@@ -1116,37 +1098,68 @@ e_client_cache_get_client_sync (EClientC
                                 GCancellable *cancellable,
                                 GError **error)
 {
-	GetClientSyncData data;
-	GAsyncResult *result;
-	EClient *client;
+	ClientData *client_data;
+	EClient *client = NULL;
+	GError *local_error = NULL;
 
 	g_return_val_if_fail (E_IS_CLIENT_CACHE (client_cache), NULL);
 	g_return_val_if_fail (E_IS_SOURCE (source), NULL);
 	g_return_val_if_fail (extension_name != NULL, NULL);
 
-	g_mutex_init (&data.mutex);
-	g_mutex_lock (&data.mutex);
+	client_data = client_ht_lookup (client_cache, source, extension_name);
 
-	e_client_cache_get_client (
-		client_cache, source, extension_name,cancellable,
-		client_cache_get_client_sync_cb, &data);
+	if (client_data == NULL) {
+		g_set_error (
+			error, G_IO_ERROR,
+			G_IO_ERROR_INVALID_ARGUMENT,
+			_("Cannot create a client object from "
+			"extension name '%s'"), extension_name);
+		return NULL;
+	}
 
-	/* This is needed, because e_async_closure_new() pushes its own thread default main context,
-	   which was later taken into an EClient within e_client_cache_get_client(), but that's wrong,
-	   because that main context effectively dies at the end of this function. */
-	data.closure = e_async_closure_new ();
+	g_mutex_lock (&client_data->lock);
 
-	g_mutex_unlock (&data.mutex);
+	if (client_data->client != NULL)
+		client = g_object_ref (client_data->client);
 
-	result = e_async_closure_wait (data.closure);
+	g_mutex_unlock (&client_data->lock);
 
-	client = e_client_cache_get_client_finish (
-		client_cache, result, error);
+	/* If a cached EClient already exists, we're done. */
+	if (client != NULL) {
+		client_data_unref (client_data);
+		return client;
+	}
 
-	g_mutex_lock (&data.mutex);
-	e_async_closure_free (data.closure);
-	g_mutex_unlock (&data.mutex);
-	g_mutex_clear (&data.mutex);
+	/* Create an appropriate EClient instance for the extension
+	 * name.  The client_ht_lookup() call above ensures us that
+	 * one of these options will match. */
+
+	if (g_str_equal (extension_name, E_SOURCE_EXTENSION_ADDRESS_BOOK)) {
+		client = e_book_client_connect_sync (source,
+			cancellable, &local_error);
+	} else if (g_str_equal (extension_name, E_SOURCE_EXTENSION_CALENDAR)) {
+		client = e_cal_client_connect_sync (
+			source, E_CAL_CLIENT_SOURCE_TYPE_EVENTS,
+			cancellable, &local_error);
+	} else if (g_str_equal (extension_name, E_SOURCE_EXTENSION_MEMO_LIST)) {
+		client = e_cal_client_connect_sync (
+			source, E_CAL_CLIENT_SOURCE_TYPE_MEMOS,
+			cancellable, &local_error);
+	} else if (g_str_equal (extension_name, E_SOURCE_EXTENSION_TASK_LIST)) {
+		client = e_cal_client_connect_sync (
+			source, E_CAL_CLIENT_SOURCE_TYPE_TASKS,
+			cancellable, &local_error);
+	} else {
+		g_warn_if_reached ();  /* Should never happen. */
+	}
+
+	if (client)
+		client_cache_process_results (client_data, client, local_error);
+
+	if (local_error)
+		g_propagate_error (error, local_error);
+
+	client_data_unref (client_data);
 
 	return client;
 }