diff --git a/libpurple/core.c b/libpurple/core.c
--- a/libpurple/core.c
+++ b/libpurple/core.c
@@ -217,7 +217,7 @@
 
 	/* Remove the active provider in the credential manager. */
 	manager = purple_credential_manager_get_default();
-	purple_credential_manager_set_active_provider(manager, NULL, NULL);
+	purple_credential_manager_set_active(manager, NULL, NULL);
 
 	/* Transmission ends */
 	purple_connections_disconnect_all();
diff --git a/libpurple/plugins/keyrings/kwallet/purplekwallet.cpp b/libpurple/plugins/keyrings/kwallet/purplekwallet.cpp
--- a/libpurple/plugins/keyrings/kwallet/purplekwallet.cpp
+++ b/libpurple/plugins/keyrings/kwallet/purplekwallet.cpp
@@ -584,8 +584,7 @@
 
 	instance = purple_kwallet_provider_new();
 
-	return purple_credential_manager_register_provider(manager, instance,
-	                                                   error);
+	return purple_credential_manager_register(manager, instance, error);
 }
 
 static gboolean
@@ -594,8 +593,7 @@
 	gboolean ret = FALSE;
 
 	manager = purple_credential_manager_get_default();
-	ret = purple_credential_manager_unregister_provider(manager, instance,
-	                                                    error);
+	ret = purple_credential_manager_unregister(manager, instance, error);
 
 	if(!ret) {
 		return ret;
diff --git a/libpurple/plugins/keyrings/secretservice.c b/libpurple/plugins/keyrings/secretservice.c
--- a/libpurple/plugins/keyrings/secretservice.c
+++ b/libpurple/plugins/keyrings/secretservice.c
@@ -310,8 +310,7 @@
 
 	instance = purple_secret_service_new();
 
-	return purple_credential_manager_register_provider(manager, instance,
-	                                                   error);
+	return purple_credential_manager_register(manager, instance, error);
 }
 
 static gboolean
@@ -320,8 +319,7 @@
 	gboolean ret = FALSE;
 
 	manager = purple_credential_manager_get_default();
-	ret = purple_credential_manager_unregister_provider(manager, instance,
-	                                                    error);
+	ret = purple_credential_manager_unregister(manager, instance, error);
 	if(!ret) {
 		return ret;
 	}
diff --git a/libpurple/plugins/keyrings/wincred.c b/libpurple/plugins/keyrings/wincred.c
--- a/libpurple/plugins/keyrings/wincred.c
+++ b/libpurple/plugins/keyrings/wincred.c
@@ -409,8 +409,7 @@
 
 	instance = purple_wincred_new();
 
-	return purple_credential_manager_register_provider(manager, instance,
-	                                                   error);
+	return purple_credential_manager_register(manager, instance, error);
 }
 
 static gboolean
@@ -419,8 +418,7 @@
 	gboolean ret = FALSE;
 
 	manager = purple_credential_manager_get_default();
-	ret = purple_credential_manager_unregister_provider(manager, instance,
-	                                                    error);
+	ret = purple_credential_manager_unregister(manager, instance, error);
 	if (!ret) {
 		return ret;
 	}
diff --git a/libpurple/purplecredentialmanager.h b/libpurple/purplecredentialmanager.h
--- a/libpurple/purplecredentialmanager.h
+++ b/libpurple/purplecredentialmanager.h
@@ -74,12 +74,11 @@
 
 /**
  * PurpleCredentialManagerClass:
- * @provider_registered: The default signal handler for when a provider is
- *                       registered.
- * @provider_unregistered: The default signal handler for when a provider is
- *                         unregistered.
- * @active_provider_changed: The default signal handler for when the active
- *                           provider is changed.
+ * @registered: The default signal handler for when a provider is registered.
+ * @unregistered: The default signal handler for when a provider is
+ *                unregistered.
+ * @active_changed: The default signal handler for when the active provider is
+ *                  changed.
  *
  * The class structure for #PurpleCredentialProvider.
  *
@@ -90,9 +89,9 @@
 	GObjectClass parent;
 
 	/*< public >*/
-	void (*provider_registered)(PurpleCredentialManager *manager, PurpleCredentialProvider *provider);
-	void (*provider_unregistered)(PurpleCredentialManager *manager, PurpleCredentialProvider *provider);
-	void (*active_provider_changed)(PurpleCredentialManager *manager, PurpleCredentialProvider *old, PurpleCredentialProvider *current);
+	void (*registered)(PurpleCredentialManager *manager, PurpleCredentialProvider *provider);
+	void (*unregistered)(PurpleCredentialManager *manager, PurpleCredentialProvider *provider);
+	void (*active_changed)(PurpleCredentialManager *manager, PurpleCredentialProvider *previous, PurpleCredentialProvider *current);
 
 	/*< private >*/
 	gpointer reserved[8];
@@ -103,8 +102,7 @@
  * @provider: The #PurpleCredentialProvider instance.
  * @data: User supplied data.
  *
- * A function to be used as a callback with
- * purple_credential_manager_foreach_provider().
+ * A function to be used as a callback with purple_credential_manager_foreach().
  *
  * Since: 3.0.0
  */
@@ -122,7 +120,7 @@
 PurpleCredentialManager *purple_credential_manager_get_default(void);
 
 /**
- * purple_credential_manager_register_provider:
+ * purple_credential_manager_register:
  * @manager: The #PurpleCredentialManager instance.
  * @provider: The #PurpleCredentialProvider to register.
  * @error: (out) (optional) (nullable): A return address for a #GError.
@@ -134,10 +132,10 @@
  *
  * Since: 3.0.0
  */
-gboolean purple_credential_manager_register_provider(PurpleCredentialManager *manager, PurpleCredentialProvider *provider, GError **error);
+gboolean purple_credential_manager_register(PurpleCredentialManager *manager, PurpleCredentialProvider *provider, GError **error);
 
 /**
- * purple_credential_manager_unregister_provider:
+ * purple_credential_manager_unregister:
  * @manager: The #PurpleCredentialManager instance.
  * @provider: The #PurpleCredentialProvider to unregister.
  * @error: (out) (optional) (nullable): A return address for a #GError.
@@ -149,10 +147,10 @@
  *
  * Since: 3.0.0
  */
-gboolean purple_credential_manager_unregister_provider(PurpleCredentialManager *manager, PurpleCredentialProvider *provider, GError **error);
+gboolean purple_credential_manager_unregister(PurpleCredentialManager *manager, PurpleCredentialProvider *provider, GError **error);
 
 /**
- * purple_credential_manager_set_active_provider:
+ * purple_credential_manager_set_active:
  * @manager: The #PurpleCredentialManager instance.
  * @id: The id of the #PurpleCredentialProvider to use or %NULL to disable the
  *      active provider.
@@ -165,10 +163,10 @@
  *
  * Since: 3.0.0
  */
-gboolean purple_credential_manager_set_active_provider(PurpleCredentialManager *manager, const gchar *id, GError **error);
+gboolean purple_credential_manager_set_active(PurpleCredentialManager *manager, const gchar *id, GError **error);
 
 /**
- * purple_credential_manager_get_active_provider:
+ * purple_credential_manager_get_active:
  * @manager: The #PurpleCredentialManager instance.
  *
  * Gets the currently active #PurpleCredentialProvider or %NULL if there is no
@@ -178,7 +176,7 @@
  *
  * Since: 3.0.0
  */
-PurpleCredentialProvider *purple_credential_manager_get_active_provider(PurpleCredentialManager *manager);
+PurpleCredentialProvider *purple_credential_manager_get_active(PurpleCredentialManager *manager);
 
 /**
  * purple_credential_manager_read_password_async:
@@ -309,7 +307,7 @@
 
 
 /**
- * purple_credential_manager_foreach_provider:
+ * purple_credential_manager_foreach:
  * @manager: The #PurpleCredentialManager instance.
  * @func: (scope call): The #PurpleCredentialManagerForeachFunc to call.
  * @data: User data to pass to @func.
@@ -318,7 +316,7 @@
  *
  * Since: 3.0.0
  */
-void purple_credential_manager_foreach_provider(PurpleCredentialManager *manager, PurpleCredentialManagerForeachFunc func, gpointer data);
+void purple_credential_manager_foreach(PurpleCredentialManager *manager, PurpleCredentialManagerForeachFunc func, gpointer data);
 
 G_END_DECLS
 
diff --git a/libpurple/purplecredentialmanager.c b/libpurple/purplecredentialmanager.c
--- a/libpurple/purplecredentialmanager.c
+++ b/libpurple/purplecredentialmanager.c
@@ -28,9 +28,9 @@
 #include "util.h"
 
 enum {
-	SIG_PROVIDER_REGISTERED,
-	SIG_PROVIDER_UNREGISTERED,
-	SIG_ACTIVE_PROVIDER_CHANGED,
+	SIG_REGISTERED,
+	SIG_UNREGISTERED,
+	SIG_ACTIVE_CHANGED,
 	N_SIGNALS,
 };
 static guint signals[N_SIGNALS] = {0, };
@@ -38,7 +38,7 @@
 typedef struct {
 	GHashTable *providers;
 
-	PurpleCredentialProvider *active_provider;
+	PurpleCredentialProvider *active;
 } PurpleCredentialManagerPrivate;
 
 G_DEFINE_TYPE_WITH_PRIVATE(PurpleCredentialManager, purple_credential_manager,
@@ -127,7 +127,7 @@
 	PurpleCredentialManagerPrivate *priv = NULL;
 
 	priv = purple_credential_manager_get_instance_private(manager);
-	if(!PURPLE_IS_CREDENTIAL_PROVIDER(priv->active_provider)) {
+	if(!PURPLE_IS_CREDENTIAL_PROVIDER(priv->active)) {
 		purple_notify_error(NULL, _("Credential Manager"),
 		                    _("Failed to load the selected credential "
 		                      "provider."),
@@ -148,7 +148,7 @@
 	priv = purple_credential_manager_get_instance_private(manager);
 
 	g_clear_pointer(&priv->providers, g_hash_table_destroy);
-	g_clear_object(&priv->active_provider);
+	g_clear_object(&priv->active);
 
 	G_OBJECT_CLASS(purple_credential_manager_parent_class)->finalize(obj);
 }
@@ -164,7 +164,7 @@
 	                                        g_object_unref);
 
 	noop = purple_noop_credential_provider_new();
-	purple_credential_manager_register_provider(manager, noop, NULL);
+	purple_credential_manager_register(manager, noop, NULL);
 	g_object_unref(G_OBJECT(noop));
 
 	/* Connect to the core-initialized signal so we can alert the user if we
@@ -182,7 +182,7 @@
 	obj_class->finalize = purple_credential_manager_finalize;
 
 	/**
-	 * PurpleCredentialManager::provider-registered:
+	 * PurpleCredentialManager::registered:
 	 * @manager: The #PurpleCredentialManager instance.
 	 * @provider: The #PurpleCredentialProvider that was registered.
 	 *
@@ -190,11 +190,11 @@
 	 *
 	 * Since: 3.0.0
 	 */
-	signals[SIG_PROVIDER_REGISTERED] = g_signal_new(
-		"provider-registered",
+	signals[SIG_REGISTERED] = g_signal_new(
+		"registered",
 		G_OBJECT_CLASS_TYPE(klass),
 		G_SIGNAL_RUN_LAST,
-		G_STRUCT_OFFSET(PurpleCredentialManagerClass, provider_registered),
+		G_STRUCT_OFFSET(PurpleCredentialManagerClass, registered),
 		NULL,
 		NULL,
 		NULL,
@@ -203,7 +203,7 @@
 		PURPLE_TYPE_CREDENTIAL_PROVIDER);
 
 	/**
-	 * PurpleCredentialManager::provider-unregistered:
+	 * PurpleCredentialManager::unregistered:
 	 * @manager: The #PurpleCredentialManager instance.
 	 * @provider: The #PurpleCredentialProvider that was unregistered.
 	 *
@@ -211,11 +211,11 @@
 	 *
 	 * Since: 3.0.0
 	 */
-	signals[SIG_PROVIDER_UNREGISTERED] = g_signal_new(
-		"provider-unregistered",
+	signals[SIG_UNREGISTERED] = g_signal_new(
+		"unregistered",
 		G_OBJECT_CLASS_TYPE(klass),
 		G_SIGNAL_RUN_LAST,
-		G_STRUCT_OFFSET(PurpleCredentialManagerClass, provider_unregistered),
+		G_STRUCT_OFFSET(PurpleCredentialManagerClass, unregistered),
 		NULL,
 		NULL,
 		NULL,
@@ -224,20 +224,20 @@
 		PURPLE_TYPE_CREDENTIAL_PROVIDER);
 
 	/**
-	 * PurpleCredentialManager::active-provider-changed:
+	 * PurpleCredentialManager::active-changed:
 	 * @manager: The #PurpleCredentialManager instance.
-	 * @old: The #PurpleCredentialProvider that was previously active.
+	 * @previous: The #PurpleCredentialProvider that was previously active.
 	 * @current: The #PurpleCredentialProvider that is now currently active.
 	 *
 	 * Emitted after @provider has become the active provider for @manager.
 	 *
 	 * Since: 3.0.0
 	 */
-	signals[SIG_ACTIVE_PROVIDER_CHANGED] = g_signal_new(
-		"active-provider-changed",
+	signals[SIG_ACTIVE_CHANGED] = g_signal_new(
+		"active-changed",
 		G_OBJECT_CLASS_TYPE(klass),
 		G_SIGNAL_RUN_LAST,
-		G_STRUCT_OFFSET(PurpleCredentialManagerClass, active_provider_changed),
+		G_STRUCT_OFFSET(PurpleCredentialManagerClass, active_changed),
 		NULL,
 		NULL,
 		NULL,
@@ -285,9 +285,9 @@
 }
 
 gboolean
-purple_credential_manager_register_provider(PurpleCredentialManager *manager,
-                                            PurpleCredentialProvider *provider,
-                                            GError **error)
+purple_credential_manager_register(PurpleCredentialManager *manager,
+                                   PurpleCredentialProvider *provider,
+                                   GError **error)
 {
 	PurpleCredentialManagerPrivate *priv = NULL;
 	const gchar *id = NULL;
@@ -313,20 +313,19 @@
 
 	g_hash_table_insert(priv->providers, g_strdup(id), g_object_ref(provider));
 
-	g_signal_emit(G_OBJECT(manager), signals[SIG_PROVIDER_REGISTERED], 0,
-	              provider);
+	g_signal_emit(G_OBJECT(manager), signals[SIG_REGISTERED], 0, provider);
 
 	/* If we don't currently have an active provider, check if the newly
 	 * registered provider has the id of the stored provider in preferences.
 	 * If it is, go ahead and make it the active provider.
 	 */
-	if(!PURPLE_IS_CREDENTIAL_PROVIDER(priv->active_provider)) {
+	if(!PURPLE_IS_CREDENTIAL_PROVIDER(priv->active)) {
 		const gchar *wanted = NULL;
 
 		wanted = purple_prefs_get_string("/purple/credentials/active-provider");
 
 		if(purple_strequal(wanted, id)) {
-			purple_credential_manager_set_active_provider(manager, id, error);
+			purple_credential_manager_set_active(manager, id, error);
 		}
 	}
 
@@ -334,9 +333,9 @@
 }
 
 gboolean
-purple_credential_manager_unregister_provider(PurpleCredentialManager *manager,
-                                              PurpleCredentialProvider *provider,
-                                              GError **error)
+purple_credential_manager_unregister(PurpleCredentialManager *manager,
+                                     PurpleCredentialProvider *provider,
+                                     GError **error)
 {
 	PurpleCredentialManagerPrivate *priv = NULL;
 	const gchar *id = NULL;
@@ -347,7 +346,7 @@
 	priv = purple_credential_manager_get_instance_private(manager);
 	id = purple_credential_provider_get_id(provider);
 
-	if(provider == priv->active_provider) {
+	if(provider == priv->active) {
 		g_set_error(error, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
 		            _("provider %s is currently in use"), id);
 
@@ -355,7 +354,7 @@
 	}
 
 	if(g_hash_table_remove(priv->providers, id)) {
-		g_signal_emit(G_OBJECT(manager), signals[SIG_PROVIDER_UNREGISTERED], 0,
+		g_signal_emit(G_OBJECT(manager), signals[SIG_UNREGISTERED], 0,
 		              provider);
 
 		return TRUE;
@@ -368,11 +367,11 @@
 }
 
 gboolean
-purple_credential_manager_set_active_provider(PurpleCredentialManager *manager,
-                                              const gchar *id, GError **error)
+purple_credential_manager_set_active(PurpleCredentialManager *manager,
+                                     const gchar *id, GError **error)
 {
 	PurpleCredentialManagerPrivate *priv = NULL;
-	PurpleCredentialProvider *old = NULL, *provider = NULL;
+	PurpleCredentialProvider *previous = NULL, *provider = NULL;
 
 	g_return_val_if_fail(PURPLE_IS_CREDENTIAL_MANAGER(manager), FALSE);
 
@@ -389,24 +388,24 @@
 		}
 	}
 
-	if(PURPLE_IS_CREDENTIAL_PROVIDER(priv->active_provider)) {
-		old = PURPLE_CREDENTIAL_PROVIDER(g_object_ref(priv->active_provider));
+	if(PURPLE_IS_CREDENTIAL_PROVIDER(priv->active)) {
+		previous = PURPLE_CREDENTIAL_PROVIDER(g_object_ref(priv->active));
 	}
 
-	if(g_set_object(&priv->active_provider, provider)) {
-		if(PURPLE_IS_CREDENTIAL_PROVIDER(old)) {
-			purple_credential_provider_deactivate(old);
+	if(g_set_object(&priv->active, provider)) {
+		if(PURPLE_IS_CREDENTIAL_PROVIDER(previous)) {
+			purple_credential_provider_deactivate(previous);
 		}
 
 		if(PURPLE_IS_CREDENTIAL_PROVIDER(provider)) {
 			purple_credential_provider_activate(provider);
 		}
 
-		g_signal_emit(G_OBJECT(manager), signals[SIG_ACTIVE_PROVIDER_CHANGED],
-		              0, old, priv->active_provider);
+		g_signal_emit(G_OBJECT(manager), signals[SIG_ACTIVE_CHANGED], 0,
+		              previous, priv->active);
 	}
 
-	g_clear_object(&old);
+	g_clear_object(&previous);
 
 	purple_debug_info("credential-manager", "set active provider to '%s'", id);
 
@@ -414,15 +413,14 @@
 }
 
 PurpleCredentialProvider *
-purple_credential_manager_get_active_provider(PurpleCredentialManager *manager)
-{
+purple_credential_manager_get_active(PurpleCredentialManager *manager) {
 	PurpleCredentialManagerPrivate *priv = NULL;
 
 	g_return_val_if_fail(PURPLE_IS_CREDENTIAL_MANAGER(manager), NULL);
 
 	priv = purple_credential_manager_get_instance_private(manager);
 
-	return priv->active_provider;
+	return priv->active;
 }
 
 void
@@ -442,24 +440,17 @@
 
 	task = g_task_new(manager, cancellable, callback, data);
 
-	if(priv->active_provider == NULL) {
-		GError *error = NULL;
-
-		error = g_error_new_literal(PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
-		                            _("can not read password, no active "
-		                              "credential provider"));
-
-		g_task_return_error(task, error);
+	if(priv->active != NULL) {
+		purple_credential_provider_read_password_async(priv->active, account,
+		                                               cancellable,
+			                                           purple_credential_manager_read_password_callback,
+				                                       task);
+	} else {
+		g_task_return_new_error(task, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
+		                        _("can not read password, no active "
+		                          "credential provider"));
 		g_object_unref(G_OBJECT(task));
-
-		return;
 	}
-
-	purple_credential_provider_read_password_async(priv->active_provider,
-	                                               account,
-	                                               cancellable,
-	                                               purple_credential_manager_read_password_callback,
-	                                               task);
 }
 
 gchar *
@@ -491,37 +482,29 @@
 	task = g_task_new(manager, cancellable, callback, data);
 
 	if(!purple_account_get_remember_password(account)) {
-		GError *error = NULL;
 		const gchar *name = purple_account_get_username(account);
 
-		error = g_error_new(PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
-		                    _("account \"%s\" is not marked to be stored"),
-		                    name);
-
-		g_task_return_error(task, error);
+		g_task_return_new_error(task, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
+		                        _("account \"%s\" is not marked to be stored"),
+		                        name);
 		g_object_unref(G_OBJECT(task));
 
 		return;
 	}
 
-	if(priv->active_provider == NULL) {
-		GError *error = NULL;
+	if(priv->active != NULL) {
+		purple_credential_provider_write_password_async(priv->active, account,
+		                                                password, cancellable,
+			                                            purple_credential_manager_write_password_callback,
+				                                        task);
+	} else {
+		g_task_return_new_error(task, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
+		                        _("can not write password, no active "
+		                          "credential provider"));
 
-		error = g_error_new_literal(PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
-		                            _("can not write password, no active "
-		                              "credential provider"));
-
-		g_task_return_error(task, error);
 		g_object_unref(G_OBJECT(task));
-
-		return;
 	}
 
-	purple_credential_provider_write_password_async(priv->active_provider,
-	                                                account, password,
-	                                                cancellable,
-	                                                purple_credential_manager_write_password_callback,
-	                                                task);
 }
 
 gboolean
@@ -551,24 +534,18 @@
 
 	task = g_task_new(manager, cancellable, callback, data);
 
-	if(priv->active_provider == NULL) {
-		GError *error = NULL;
+	if(priv->active != NULL) {
+		purple_credential_provider_clear_password_async(priv->active, account,
+		                                                cancellable,
+			                                            purple_credential_manager_clear_password_callback,
+				                                        task);
+	} else {
+		g_task_return_new_error(task, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
+		                        _("can not clear password, no active "
+		                          "credential provider"));
 
-		error = g_error_new_literal(PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
-		                            _("can not clear password, no active "
-		                              "credential provider"));
-
-		g_task_return_error(task, error);
 		g_object_unref(G_OBJECT(task));
-
-		return;
 	}
-
-	purple_credential_provider_clear_password_async(priv->active_provider,
-	                                                account,
-	                                                cancellable,
-	                                                purple_credential_manager_clear_password_callback,
-	                                                task);
 }
 
 gboolean
@@ -591,14 +568,14 @@
 
 	priv = purple_credential_manager_get_instance_private(manager);
 
-	if(priv->active_provider == NULL) {
-		g_set_error(error, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
-		            _("can not read settings, no active credential provider"));
-
-		return NULL;
+	if(priv->active != NULL) {
+		return purple_credential_provider_read_settings(priv->active);
 	}
 
-	return purple_credential_provider_read_settings(priv->active_provider);
+	g_set_error(error, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
+	            _("can not read settings, no active credential provider"));
+
+	return NULL;
 }
 
 gboolean
@@ -612,21 +589,20 @@
 
 	priv = purple_credential_manager_get_instance_private(manager);
 
-	if(priv->active_provider == NULL) {
-		g_set_error(error, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
-		            _("can not write settings, no active credential provider"));
-
-		return FALSE;
+	if(priv->active != NULL) {
+		return purple_credential_provider_write_settings(priv->active, fields);
 	}
 
-	return purple_credential_provider_write_settings(priv->active_provider,
-	                                                 fields);
+	g_set_error(error, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0,
+	            _("can not write settings, no active credential provider"));
+
+	return FALSE;
 }
 
 void
-purple_credential_manager_foreach_provider(PurpleCredentialManager *manager,
-                                           PurpleCredentialManagerForeachFunc func,
-                                           gpointer data)
+purple_credential_manager_foreach(PurpleCredentialManager *manager,
+                                  PurpleCredentialManagerForeachFunc func,
+                                  gpointer data)
 {
 	GHashTableIter iter;
 	PurpleCredentialManagerPrivate *priv = NULL;
@@ -641,4 +617,5 @@
 	while(g_hash_table_iter_next(&iter, NULL, &value)) {
 		func(PURPLE_CREDENTIAL_PROVIDER(value), data);
 	}
-}
\ No newline at end of file
+}
+
diff --git a/libpurple/tests/test_credential_manager.c b/libpurple/tests/test_credential_manager.c
--- a/libpurple/tests/test_credential_manager.c
+++ b/libpurple/tests/test_credential_manager.c
@@ -211,25 +211,23 @@
 	provider = test_purple_credential_provider_new();
 
 	/* Register the first time cleanly. */
-	r = purple_credential_manager_register_provider(manager, provider, &error);
+	r = purple_credential_manager_register(manager, provider, &error);
 	g_assert_no_error(error);
 	g_assert_true(r);
 
 	/* Register again and verify the error. */
-	r = purple_credential_manager_register_provider(manager, provider, &error);
+	r = purple_credential_manager_register(manager, provider, &error);
 	g_assert_false(r);
 	g_assert_error(error, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0);
 	g_clear_error(&error);
 
 	/* Unregister the provider. */
-	r = purple_credential_manager_unregister_provider(manager, provider,
-	                                                  &error);
+	r = purple_credential_manager_unregister(manager, provider, &error);
 	g_assert_no_error(error);
 	g_assert_true(r);
 
 	/* Unregister the provider again and verify the error. */
-	r = purple_credential_manager_unregister_provider(manager, provider,
-	                                                  &error);
+	r = purple_credential_manager_unregister(manager, provider, &error);
 	g_assert_false(r);
 	g_assert_error(error, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0);
 	g_clear_error(&error);
@@ -249,7 +247,7 @@
 
 	manager = purple_credential_manager_get_default();
 
-	ret = purple_credential_manager_set_active_provider(manager, NULL, &error);
+	ret = purple_credential_manager_set_active(manager, NULL, &error);
 
 	g_assert_no_error(error);
 	g_assert_true(ret);
@@ -264,7 +262,7 @@
 
 	manager = purple_credential_manager_get_default();
 
-	ret = purple_credential_manager_set_active_provider(manager, "foo", &error);
+	ret = purple_credential_manager_set_active(manager, "foo", &error);
 
 	g_assert_false(ret);
 	g_assert_error(error, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0);
@@ -282,31 +280,29 @@
 
 	/* Create the provider and register it in the manager. */
 	provider = test_purple_credential_provider_new();
-	r = purple_credential_manager_register_provider(manager, provider, &error);
+	r = purple_credential_manager_register(manager, provider, &error);
 	g_assert_no_error(error);
 	g_assert_true(r);
 
 	/* Set the provider as active and verify it was successful. */
-	r = purple_credential_manager_set_active_provider(manager, "test-provider",
+	r = purple_credential_manager_set_active(manager, "test-provider",
 	                                                  &error);
 	g_assert_no_error(error);
 	g_assert_true(r);
 
 	/* Verify that unregistering the provider fails. */
-	r = purple_credential_manager_unregister_provider(manager, provider,
-	                                                  &error);
+	r = purple_credential_manager_unregister(manager, provider, &error);
 	g_assert_false(r);
 	g_assert_error(error, PURPLE_CREDENTIAL_MANAGER_DOMAIN, 0);
 	g_clear_error(&error);
 
 	/* Now unset the active provider. */
-	r = purple_credential_manager_set_active_provider(manager, NULL, &error);
+	r = purple_credential_manager_set_active(manager, NULL, &error);
 	g_assert_no_error(error);
 	g_assert_true(r);
 
 	/* Finally unregister the provider now that it's no longer active. */
-	r = purple_credential_manager_unregister_provider(manager, provider,
-	                                                  &error);
+	r = purple_credential_manager_unregister(manager, provider, &error);
 	g_assert_no_error(error);
 	g_assert_true(r);
 
@@ -527,11 +523,11 @@
 	GError *e = NULL;
 	gboolean r = FALSE;
 
-	r = purple_credential_manager_register_provider(m, p, &e);
+	r = purple_credential_manager_register(m, p, &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
-	r = purple_credential_manager_set_active_provider(m, "test-provider", &e);
+	r = purple_credential_manager_set_active(m, "test-provider", &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
@@ -540,11 +536,11 @@
 
 	g_main_loop_run(loop);
 
-	r = purple_credential_manager_set_active_provider(m, NULL, &e);
+	r = purple_credential_manager_set_active(m, NULL, &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
-	r = purple_credential_manager_unregister_provider(m, p, &e);
+	r = purple_credential_manager_unregister(m, p, &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
@@ -591,11 +587,11 @@
 	GError *e = NULL;
 	gboolean r = FALSE;
 
-	r = purple_credential_manager_register_provider(m, p, &e);
+	r = purple_credential_manager_register(m, p, &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
-	r = purple_credential_manager_set_active_provider(m, "test-provider", &e);
+	r = purple_credential_manager_set_active(m, "test-provider", &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
@@ -604,11 +600,11 @@
 
 	g_main_loop_run(loop);
 
-	r = purple_credential_manager_set_active_provider(m, NULL, &e);
+	r = purple_credential_manager_set_active(m, NULL, &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
-	r = purple_credential_manager_unregister_provider(m, p, &e);
+	r = purple_credential_manager_unregister(m, p, &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
@@ -655,11 +651,11 @@
 	GError *e = NULL;
 	gboolean r = FALSE;
 
-	r = purple_credential_manager_register_provider(m, p, &e);
+	r = purple_credential_manager_register(m, p, &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
-	r = purple_credential_manager_set_active_provider(m, "test-provider", &e);
+	r = purple_credential_manager_set_active(m, "test-provider", &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
@@ -668,11 +664,11 @@
 
 	g_main_loop_run(loop);
 
-	r = purple_credential_manager_set_active_provider(m, NULL, &e);
+	r = purple_credential_manager_set_active(m, NULL, &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
-	r = purple_credential_manager_unregister_provider(m, p, &e);
+	r = purple_credential_manager_unregister(m, p, &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
@@ -688,11 +684,11 @@
 	GError *e = NULL;
 	gboolean r = FALSE;
 
-	r = purple_credential_manager_register_provider(m, p, &e);
+	r = purple_credential_manager_register(m, p, &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
-	r = purple_credential_manager_set_active_provider(m, "test-provider", &e);
+	r = purple_credential_manager_set_active(m, "test-provider", &e);
 	g_assert_no_error(e);
 	g_assert_true(r);
 
@@ -709,6 +705,14 @@
 
 	purple_request_fields_destroy(fields);
 
+	r = purple_credential_manager_set_active(m, NULL, &e);
+	g_assert_no_error(e);
+	g_assert_true(r);
+
+	r = purple_credential_manager_unregister(m, p, &e);
+	g_assert_no_error(e);
+	g_assert_true(r);
+
 	g_clear_object(&p);
 }
 
diff --git a/pidgin/prefs/pidgincredentialspage.c b/pidgin/prefs/pidgincredentialspage.c
--- a/pidgin/prefs/pidgincredentialspage.c
+++ b/pidgin/prefs/pidgincredentialspage.c
@@ -99,7 +99,7 @@
 	id = purple_credential_provider_get_id(provider);
 
 	manager = purple_credential_manager_get_default();
-	if(purple_credential_manager_set_active_provider(manager, id, &error)) {
+	if(purple_credential_manager_set_active(manager, id, &error)) {
 		purple_prefs_set_string("/purple/credentials/active-provider", id);
 
 		return;
@@ -165,7 +165,7 @@
 	purple_prefs_add_string("/purple/credentials/active-provider", NULL);
 
 	manager = purple_credential_manager_get_default();
-	purple_credential_manager_foreach_provider(
+	purple_credential_manager_foreach(
 	    manager,
 	    pidgin_credentials_page_create_row,
 	    page->credential_list);
