Merge lp:~compiz-team/compiz/compiz.split_gsettings_rw_funcs into lp:compiz/0.9.8

[Sam Spilsbury]

Split out the read and write functions to and from variants so that we can re-use them in the tests

Next: lp:~compiz-team/compiz/compiz.gsettings_conformance_test

Unmerged revisions

=== modified file 'compizconfig/gconf/src/gconf.c'
--- compizconfig/gconf/src/gconf.c	2012-08-07 01:05:13 +0000
+++ compizconfig/gconf/src/gconf.c	2012-08-07 01:05:15 +0000
@@ -1835,7 +1835,7 @@
 }
 
 static void
-updateCurrentProfileName (char *profile)
+ccsGSettingsBackendUpdateCurrentProfileName (char *profile)
 {
     GConfSchema *schema;
     GConfValue  *value;
@@ -1940,7 +1940,7 @@
 	}
 
 	/* update current profile name */
-	updateCurrentProfileName (currentProfile);
+	ccsGSettingsBackendUpdateCurrentProfileName (currentProfile);
     }
 
     if (lastProfile)

=== modified file 'compizconfig/gsettings/gsettings_backend_shared/CMakeLists.txt'
--- compizconfig/gsettings/gsettings_backend_shared/CMakeLists.txt	2012-07-05 21:11:17 +0000
+++ compizconfig/gsettings/gsettings_backend_shared/CMakeLists.txt	2012-08-07 01:05:15 +0000
@@ -15,12 +15,26 @@
     link_directories (${GSETTINGS_UTIL_LIBRARY_DIRS}
 		      ${compiz_BINARY_DIR}/compizconfig/libcompizconfig)
 
-    add_library (gsettings_backend_shared STATIC
+    add_library (gsettings_backend_shared SHARED
+		 ${CMAKE_CURRENT_SOURCE_DIR}/ccs_gsettings_interface_wrapper.c
+		 ${CMAKE_CURRENT_SOURCE_DIR}/ccs_gsettings_interface.c
 		 ${CMAKE_CURRENT_SOURCE_DIR}/gsettings_constants.c
 		 ${CMAKE_CURRENT_SOURCE_DIR}/gsettings_util.c)
 
+
     target_link_libraries (gsettings_backend_shared
 			   ${GSETTINGS_UTIL_LIBRARIES}
 			   compizconfig)
 
+    install (TARGETS gsettings_backend_shared
+	     DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
+
+    #
+    # Tell CMake that targets using gsettings_backend_shared should NOT re-import the
+    # libraries that gsettings_backend_shared depends on (contains).
+    #
+    set_target_properties (gsettings_backend_shared PROPERTIES
+	LINK_INTERFACE_LIBRARIES ""
+    )
+
 endif (GSETTINGS_UTIL_FOUND)

=== added file 'compizconfig/gsettings/gsettings_backend_shared/ccs_gsettings_interface.c'
--- compizconfig/gsettings/gsettings_backend_shared/ccs_gsettings_interface.c	1970-01-01 00:00:00 +0000
+++ compizconfig/gsettings/gsettings_backend_shared/ccs_gsettings_interface.c	2012-08-07 01:05:15 +0000
@@ -0,0 +1,65 @@
+#include <gio/gio.h>
+#include "ccs_gsettings_interface.h"
+
+INTERFACE_TYPE (CCSGSettingsWrapperInterface);
+CCSREF_OBJ (GSettingsWrapper, CCSGSettingsWrapper);
+
+void
+ccsGSettingsWrapperSetValue (CCSGSettingsWrapper *wrapper,
+			     const char *key,
+			     GVariant *value)
+{
+    (*(GET_INTERFACE (CCSGSettingsWrapperInterface, wrapper))->gsettingsWrapperSetValue) (wrapper, key, value);
+}
+
+GVariant *
+ccsGSettingsWrapperGetValue (CCSGSettingsWrapper *wrapper,
+			     const char *key)
+{
+    return (*(GET_INTERFACE (CCSGSettingsWrapperInterface, wrapper))->gsettingsWrapperGetValue) (wrapper, key);
+}
+
+void
+ccsGSettingsWrapperResetKey (CCSGSettingsWrapper *wrapper,
+			     const char *key)
+{
+    return (*(GET_INTERFACE (CCSGSettingsWrapperInterface, wrapper))->gsettingsWrapperResetKey) (wrapper, key);
+}
+
+char **
+ccsGSettingsWrapperListKeys (CCSGSettingsWrapper *wrapper)
+{
+    return (*(GET_INTERFACE (CCSGSettingsWrapperInterface, wrapper))->gsettingsWrapperListKeys) (wrapper);
+}
+
+GSettings *
+ccsGSettingsWrapperGetGSettings (CCSGSettingsWrapper *wrapper)
+{
+    return (*(GET_INTERFACE (CCSGSettingsWrapperInterface, wrapper))->gsettingsWrapperGetGSettings) (wrapper);
+}
+
+const char *
+ccsGSettingsWrapperGetSchemaName (CCSGSettingsWrapper *wrapper)
+{
+    return (*(GET_INTERFACE (CCSGSettingsWrapperInterface, wrapper))->gsettingsWrapperGetSchemaName) (wrapper);
+}
+
+const char *
+ccsGSettingsWrapperGetPath (CCSGSettingsWrapper *wrapper)
+{
+    return (*(GET_INTERFACE (CCSGSettingsWrapperInterface, wrapper))->gsettingsWrapperGetPath) (wrapper);
+}
+
+void
+ccsGSettingsWrapperConnectToChangedSignal (CCSGSettingsWrapper *wrapper,
+					   GCallback	       callback,
+					   gpointer	       data)
+{
+    return (*(GET_INTERFACE (CCSGSettingsWrapperInterface, wrapper))->gsettingsWrapperConnectToChangedSignal) (wrapper, callback, data);
+}
+
+void
+ccsFreeGSettingsWrapper (CCSGSettingsWrapper *wrapper)
+{
+    return (*(GET_INTERFACE (CCSGSettingsWrapperInterface, wrapper))->gsettingsWrapperFree) (wrapper);
+}

=== added file 'compizconfig/gsettings/gsettings_backend_shared/ccs_gsettings_interface.h'
--- compizconfig/gsettings/gsettings_backend_shared/ccs_gsettings_interface.h	1970-01-01 00:00:00 +0000
+++ compizconfig/gsettings/gsettings_backend_shared/ccs_gsettings_interface.h	2012-08-07 01:05:15 +0000
@@ -0,0 +1,59 @@
+#ifndef _CCS_GSETTINGS_INTERFACE_H
+#define _CCS_GSETTINGS_INTERFACE_H
+
+#include <ccs-defs.h>
+
+COMPIZCONFIG_BEGIN_DECLS
+
+#include <glib.h>
+#include <gio/gio.h>
+#include <ccs-object.h>
+
+typedef struct _CCSGSettingsWrapper	      CCSGSettingsWrapper;
+typedef struct _CCSGSettingsWrapperInterface  CCSGSettingsWrapperInterface;
+
+typedef void (*CCSGSettingsWrapperSetValue) (CCSGSettingsWrapper *, const char *, GVariant *);
+typedef GVariant * (*CCSGSettingsWrapperGetValue) (CCSGSettingsWrapper *, const char *);
+typedef void (*CCSGSettingsWrapperResetKey) (CCSGSettingsWrapper *, const char *);
+typedef char ** (*CCSGSettingsWrapperListKeys) (CCSGSettingsWrapper *);
+typedef GSettings * (*CCSGSettingsWrapperGetGSettings) (CCSGSettingsWrapper *);
+typedef const char * (*CCSGSettingsWrapperGetSchemaName) (CCSGSettingsWrapper *);
+typedef const char * (*CCSGSettingsWrapperGetPath) (CCSGSettingsWrapper *);
+typedef void (*CCSGSettingsWrapperConnectToChangedSignal) (CCSGSettingsWrapper *, GCallback, gpointer);
+typedef void (*CCSGSettingsWrapperFree) (CCSGSettingsWrapper *);
+
+struct _CCSGSettingsWrapperInterface
+{
+    CCSGSettingsWrapperSetValue gsettingsWrapperSetValue;
+    CCSGSettingsWrapperGetValue gsettingsWrapperGetValue;
+    CCSGSettingsWrapperResetKey gsettingsWrapperResetKey;
+    CCSGSettingsWrapperListKeys gsettingsWrapperListKeys;
+    CCSGSettingsWrapperGetGSettings gsettingsWrapperGetGSettings;
+    CCSGSettingsWrapperGetSchemaName gsettingsWrapperGetSchemaName;
+    CCSGSettingsWrapperGetPath       gsettingsWrapperGetPath;
+    CCSGSettingsWrapperConnectToChangedSignal gsettingsWrapperConnectToChangedSignal;
+    CCSGSettingsWrapperFree gsettingsWrapperFree;
+};
+
+struct _CCSGSettingsWrapper
+{
+    CCSObject object;
+};
+
+void ccsGSettingsWrapperSetValue (CCSGSettingsWrapper *, const char *, GVariant *);
+GVariant * ccsGSettingsWrapperGetValue (CCSGSettingsWrapper *, const char *);
+void ccsGSettingsWrapperResetKey (CCSGSettingsWrapper *, const char *);
+char **ccsGSettingsWrapperListKeys (CCSGSettingsWrapper *);
+GSettings * ccsGSettingsWrapperGetGSettings (CCSGSettingsWrapper *);
+const char * ccsGSettingsWrapperGetSchemaName (CCSGSettingsWrapper *);
+const char * ccsGSettingsWrapperGetPath (CCSGSettingsWrapper *);
+void ccsGSettingsWrapperConnectToChangedSignal (CCSGSettingsWrapper *, GCallback, gpointer);
+void ccsFreeGSettingsWrapper (CCSGSettingsWrapper *wrapper);
+
+unsigned int ccsCCSGSettingsWrapperInterfaceGetType ();
+
+CCSREF_HDR (GSettingsWrapper, CCSGSettingsWrapper);
+
+COMPIZCONFIG_END_DECLS
+
+#endif

=== added file 'compizconfig/gsettings/gsettings_backend_shared/ccs_gsettings_interface_wrapper.c'
--- compizconfig/gsettings/gsettings_backend_shared/ccs_gsettings_interface_wrapper.c	1970-01-01 00:00:00 +0000
+++ compizconfig/gsettings/gsettings_backend_shared/ccs_gsettings_interface_wrapper.c	2012-08-07 01:05:15 +0000
@@ -0,0 +1,260 @@
+#include <gio/gio.h>
+#include "ccs_gsettings_interface_wrapper.h"
+
+typedef struct _CCSGSettingsWrapperPrivate CCSGSettingsWrapperPrivate;
+
+struct _CCSGSettingsWrapperPrivate
+{
+    GSettings *settings;
+    char      *schema;
+    char      *path;
+};
+
+#define GSETTINGS_WRAPPER_PRIVATE(w) \
+    CCSGSettingsWrapperPrivate *gswPrivate = (CCSGSettingsWrapperPrivate *) ccsObjectGetPrivate (w);
+
+static GVariant * ccsGSettingsWrapperGetValueDefault (CCSGSettingsWrapper *wrapper, const char *key)
+{
+    GSETTINGS_WRAPPER_PRIVATE (wrapper);
+
+    return g_settings_get_value (gswPrivate->settings, key);
+}
+
+static void ccsGSettingsWrapperSetValueDefault (CCSGSettingsWrapper *wrapper, const char *key, GVariant *variant)
+{
+    GSETTINGS_WRAPPER_PRIVATE (wrapper);
+
+    g_settings_set_value (gswPrivate->settings, key, variant);
+}
+
+static void ccsGSettingsWrapperResetKeyDefault (CCSGSettingsWrapper *wrapper, const char *key)
+{
+    GSETTINGS_WRAPPER_PRIVATE (wrapper);
+
+    g_settings_reset (gswPrivate->settings, key);
+}
+
+static char ** ccsGSettingsWrapperListKeysDefault (CCSGSettingsWrapper *wrapper)
+{
+    GSETTINGS_WRAPPER_PRIVATE (wrapper);
+
+    return g_settings_list_keys (gswPrivate->settings);
+}
+
+static GSettings * ccsGSettingsWrapperGetGSettingsDefault (CCSGSettingsWrapper *wrapper)
+{
+    GSETTINGS_WRAPPER_PRIVATE (wrapper);
+
+    return gswPrivate->settings;
+}
+
+static const char *
+ccsGSettingsWrapperGetSchemaNameDefault (CCSGSettingsWrapper *wrapper)
+{
+    GSETTINGS_WRAPPER_PRIVATE (wrapper);
+
+    return gswPrivate->schema;
+}
+
+static const char *
+ccsGSettingsWrapperGetPathDefault (CCSGSettingsWrapper *wrapper)
+{
+    GSETTINGS_WRAPPER_PRIVATE (wrapper);
+
+    return gswPrivate->path;
+}
+
+void
+ccsGSettingsWrapperConnectToChangedSignalDefault (CCSGSettingsWrapper *wrapper,
+						  GCallback	       callback,
+						  gpointer	       data)
+{
+    GSETTINGS_WRAPPER_PRIVATE (wrapper);
+
+    g_signal_connect (gswPrivate->settings, "changed", callback, data);
+}
+
+static void
+ccsFreeGSettingsWrapperDefault (CCSGSettingsWrapper *wrapper)
+{
+    GSETTINGS_WRAPPER_PRIVATE (wrapper);
+
+    if (gswPrivate->settings)
+	g_object_unref (gswPrivate->settings);
+
+    if (gswPrivate->path)
+	(*wrapper->object.object_allocation->free_) (wrapper->object.object_allocation->allocator,
+						     gswPrivate->path);
+
+    if (gswPrivate->schema)
+	(*wrapper->object.object_allocation->free_) (wrapper->object.object_allocation->allocator,
+						     gswPrivate->schema);
+
+    ccsObjectFinalize (wrapper);
+
+    (*wrapper->object.object_allocation->free_) (wrapper->object.object_allocation->allocator,
+						 wrapper);
+}
+
+const CCSGSettingsWrapperInterface interface =
+{
+    ccsGSettingsWrapperSetValueDefault,
+    ccsGSettingsWrapperGetValueDefault,
+    ccsGSettingsWrapperResetKeyDefault,
+    ccsGSettingsWrapperListKeysDefault,
+    ccsGSettingsWrapperGetGSettingsDefault,
+    ccsGSettingsWrapperGetSchemaNameDefault,
+    ccsGSettingsWrapperGetPathDefault,
+    ccsGSettingsWrapperConnectToChangedSignalDefault,
+    ccsFreeGSettingsWrapperDefault
+};
+
+static CCSGSettingsWrapperPrivate *
+allocatePrivateWrapper (CCSObjectAllocationInterface *ai, CCSGSettingsWrapper *wrapper)
+{
+    CCSGSettingsWrapperPrivate *priv = (*ai->calloc_) (ai->allocator, 1, sizeof (CCSGSettingsWrapper));
+
+    if (!priv)
+    {
+	(*ai->free_) (ai->allocator, wrapper);
+	return NULL;
+    }
+
+    return priv;
+}
+
+static CCSGSettingsWrapper *
+allocateWrapper (CCSObjectAllocationInterface *ai)
+{
+    CCSGSettingsWrapper *wrapper = (*ai->calloc_) (ai->allocator, 1, sizeof (CCSGSettingsWrapper));
+
+    if (!wrapper)
+	return NULL;
+
+    return wrapper;
+}
+
+static void
+freeWrapperAndPriv (CCSGSettingsWrapper *wrapper,
+		    CCSGSettingsWrapperPrivate *priv,
+		    CCSObjectAllocationInterface *ai)
+{
+    (*ai->free_) (ai->allocator, priv);
+    (*ai->free_) (ai->allocator, wrapper);
+}
+
+static GSettings *
+newGSettingsWithPath (const char *schema,
+		      const char *path,
+		      CCSGSettingsWrapper *wrapper,
+		      CCSGSettingsWrapperPrivate *priv,
+		      CCSObjectAllocationInterface *ai)
+{
+    GSettings *settings = g_settings_new_with_path (schema, path);
+
+    if (!settings)
+    {
+	freeWrapperAndPriv (wrapper, priv, ai);
+	return NULL;
+    }
+
+    return settings;
+}
+
+static GSettings *
+newGSettings (const char *schema,
+	      CCSGSettingsWrapper *wrapper,
+	      CCSGSettingsWrapperPrivate *priv,
+	      CCSObjectAllocationInterface *ai)
+{
+    GSettings *settings = g_settings_new (schema);
+
+    if (!settings)
+    {
+	freeWrapperAndPriv (wrapper, priv, ai);
+	return NULL;
+    }
+
+    return settings;
+}
+
+static Bool
+allocateWrapperData (CCSObjectAllocationInterface *ai,
+		     CCSGSettingsWrapper	  **wrapper,
+		     CCSGSettingsWrapperPrivate   **priv)
+{
+    *wrapper = allocateWrapper (ai);
+
+    if (!*wrapper)
+	return FALSE;
+
+    *priv = allocatePrivateWrapper (ai, *wrapper);
+
+    if (!*priv)
+	return FALSE;
+
+    return TRUE;
+}
+
+static void
+initCCSGSettingsWrapperObject (CCSGSettingsWrapper *wrapper,
+			       CCSGSettingsWrapperPrivate *priv,
+			       CCSObjectAllocationInterface *ai)
+{
+    ccsObjectInit (wrapper, ai);
+    ccsObjectAddInterface (wrapper, (const CCSInterface *) &interface, GET_INTERFACE_TYPE (CCSGSettingsWrapperInterface));
+    ccsObjectSetPrivate (wrapper, (CCSPrivate *) priv);
+    ccsGSettingsWrapperRef (wrapper);
+}
+
+CCSGSettingsWrapper *
+ccsGSettingsWrapperNewForSchemaWithPath (const char *schema,
+					 const char *path,
+					 CCSObjectAllocationInterface *ai)
+{
+    CCSGSettingsWrapper *wrapper = NULL;
+    CCSGSettingsWrapperPrivate *priv = NULL;
+
+    if (!allocateWrapperData (ai, &wrapper, &priv))
+	return NULL;
+
+    priv->schema = g_strdup (schema);
+    priv->path = g_strdup (path);
+    priv->settings = newGSettingsWithPath (schema, path, wrapper, priv, ai);
+
+    if (!priv->settings)
+	return NULL;
+
+    initCCSGSettingsWrapperObject (wrapper, priv, ai);
+
+    return wrapper;
+}
+
+CCSGSettingsWrapper *
+ccsGSettingsWrapperNewForSchema (const char *schema,
+				 CCSObjectAllocationInterface *ai)
+{
+    CCSGSettingsWrapper *wrapper = NULL;
+    CCSGSettingsWrapperPrivate *priv = NULL;
+
+    if (!allocateWrapperData (ai, &wrapper, &priv))
+	return NULL;
+
+    priv->schema = g_strdup (schema);
+    priv->settings = newGSettings (schema, wrapper, priv, ai);
+
+    if (!priv->settings)
+	return NULL;
+
+    GValue pathValue = G_VALUE_INIT;
+    g_value_init (&pathValue, G_TYPE_STRING);
+    g_object_get_property (G_OBJECT (priv->settings), "path", &pathValue);
+
+    priv->path = g_value_dup_string (&pathValue);
+
+    g_value_unset (&pathValue);
+
+    initCCSGSettingsWrapperObject (wrapper, priv, ai);
+
+    return wrapper;
+}

=== added file 'compizconfig/gsettings/gsettings_backend_shared/ccs_gsettings_interface_wrapper.h'
--- compizconfig/gsettings/gsettings_backend_shared/ccs_gsettings_interface_wrapper.h	1970-01-01 00:00:00 +0000
+++ compizconfig/gsettings/gsettings_backend_shared/ccs_gsettings_interface_wrapper.h	2012-08-07 01:05:15 +0000
@@ -0,0 +1,21 @@
+#ifndef _CCS_GSETTINGS_INTERFACE_WRAPPER_H
+#define _CCS_GSETTINGS_INTERFACE_WRAPPER_H
+
+#include <ccs-defs.h>
+
+COMPIZCONFIG_BEGIN_DECLS
+
+#include "ccs_gsettings_interface.h"
+
+CCSGSettingsWrapper *
+ccsGSettingsWrapperNewForSchemaWithPath (const char *schema,
+					 const char *path,
+					 CCSObjectAllocationInterface *ai);
+
+CCSGSettingsWrapper *
+ccsGSettingsWrapperNewForSchema (const char *schema,
+				 CCSObjectAllocationInterface *ai);
+
+COMPIZCONFIG_END_DECLS
+
+#endif

=== added file 'compizconfig/gsettings/gsettings_backend_shared/gsettings_util.'
=== modified file 'compizconfig/gsettings/gsettings_backend_shared/gsettings_util.c'
--- compizconfig/gsettings/gsettings_backend_shared/gsettings_util.c	2012-07-10 10:14:00 +0000
+++ compizconfig/gsettings/gsettings_backend_shared/gsettings_util.c	2012-08-07 01:05:15 +0000
@@ -1,8 +1,21 @@
 #define CCS_LOG_DOMAIN "gsettings"
 #include <string.h>
+#include <stdlib.h>
 #include <stdio.h>
 #include "gsettings_shared.h"
 
+INTERFACE_TYPE (CCSGSettingsBackendInterface);
+
+const CCSBackendInfo gsettingsBackendInfo =
+{
+    "gsettings",
+    "GSettings Configuration Backend",
+    "GSettings Configuration Backend for libccs",
+    TRUE,
+    TRUE,
+    1
+};
+
 GList *
 variantTypeToPossibleSettingType (const gchar *vt)
 {
@@ -38,23 +51,18 @@
     return possibleTypesList;
 }
 
-GObject *
-findObjectInListWithPropertySchemaName (const gchar *schemaName,
-					GList	    *iter)
+CCSGSettingsWrapper *
+findCCSGSettingsWrapperBySchemaName (const gchar *schemaName,
+				     GList	 *iter)
 {
     while (iter)
     {
-	GObject   *obj = (GObject *) iter->data;
-	gchar	  *name = NULL;
+	CCSGSettingsWrapper   *obj = iter->data;
+	const gchar	      *name = ccsGSettingsWrapperGetSchemaName (obj);
 
-	g_object_get (obj,
-		      "schema",
-		      &name, NULL);
 	if (g_strcmp0 (name, schemaName) != 0)
 	    obj = NULL;
 
-	g_free (name);
-
 	if (obj)
 	    return obj;
 	else
@@ -327,6 +335,101 @@
     return found;
 }
 
+Bool
+findSettingAndPluginToUpdateFromPath (CCSGSettingsWrapper  *settings,
+				      const char *path,
+				      const gchar *keyName,
+				      CCSContext *context,
+				      CCSPlugin **plugin,
+				      CCSSetting **setting,
+				      char **uncleanKeyName)
+{
+    char         *pluginName;
+    unsigned int screenNum;
+
+    if (!decomposeGSettingsPath (path, &pluginName, &screenNum))
+	return FALSE;
+
+    *plugin = ccsFindPlugin (context, pluginName);
+
+    if (*plugin)
+    {
+	*uncleanKeyName = translateKeyForCCS (keyName);
+
+	*setting = ccsFindSetting (*plugin, *uncleanKeyName);
+	if (!*setting)
+	{
+	    /* Couldn't find setting straight off the bat,
+	     * try and find the best match */
+	    GVariant *value = ccsGSettingsWrapperGetValue (settings, keyName);
+
+	    if (value)
+	    {
+		GList *possibleSettingTypes = variantTypeToPossibleSettingType (g_variant_get_type_string (value));
+		GList *iter = possibleSettingTypes;
+
+		while (iter)
+		{
+		    *setting = attemptToFindCCSSettingFromLossyName (ccsGetPluginSettings (*plugin),
+								     keyName,
+								     (CCSSettingType) GPOINTER_TO_INT (iter->data));
+
+		    if (*setting)
+			break;
+
+		    iter = iter->next;
+		}
+
+		g_list_free (possibleSettingTypes);
+		g_variant_unref (value);
+	    }
+	}
+    }
+
+    g_free (pluginName);
+
+    if (!*plugin || !*setting)
+	return FALSE;
+
+    return TRUE;
+}
+
+Bool
+updateSettingWithGSettingsKeyName (CCSBackend *backend,
+				   CCSGSettingsWrapper *settings,
+				   const gchar     *keyName,
+				   CCSBackendUpdateFunc updateSetting)
+{
+    CCSContext   *context = ccsGSettingsBackendGetContext (backend);
+    char	 *uncleanKeyName = NULL;
+    char	 *pathOrig;
+    CCSPlugin    *plugin;
+    CCSSetting   *setting;
+    Bool         ret = TRUE;
+
+    pathOrig = strdup (ccsGSettingsWrapperGetPath (settings));
+
+    if (findSettingAndPluginToUpdateFromPath (settings, pathOrig, keyName, context, &plugin, &setting, &uncleanKeyName))
+	(*updateSetting) (backend, context, plugin, setting);
+    else
+    {
+	/* We hit a situation where either the key stored in GSettings couldn't be
+	 * matched at all to a key in the xml file, or where there were multiple matches.
+	 * Unfortunately, there isn't much we can do about this, other than try
+	 * and warn the user and bail out. It just means that if the key was updated
+	 * externally we won't know about the change until the next reload of settings */
+	 ccsWarning ("Unable to find setting %s, for path %s", uncleanKeyName, pathOrig);
+	 ret = FALSE;
+    }
+
+    g_free (pathOrig);
+
+    if (uncleanKeyName)
+	free (uncleanKeyName);
+
+    return ret;
+}
+
 gchar *
 makeCompizProfilePath (const gchar *profilename)
 {
@@ -340,3 +443,825 @@
                          "plugins", pluginName, "/", NULL);
 }
 
+gchar *
+getNameForCCSSetting (CCSSetting *setting)
+{
+    return translateKeyForGSettings (ccsSettingGetName (setting));
+}
+
+Bool
+checkReadVariantIsValid (GVariant *gsettingsValue, CCSSettingType type, const gchar *pathName)
+{
+    /* first check if the key is set */
+    if (!gsettingsValue)
+    {
+	ccsWarning ("There is no key at the path %s. "
+		"Settings from this path won't be read. Try to remove "
+		"that value so that operation can continue properly.",
+		pathName);
+	return FALSE;
+    }
+
+    if (!variantIsValidForCCSType (gsettingsValue, type))
+    {
+	ccsWarning ("There is an unsupported value at path %s. "
+		"Settings from this path won't be read. Try to remove "
+		"that value so that operation can continue properly.",
+		pathName);
+	return FALSE;
+    }
+
+    return TRUE;
+}
+
+GVariant *
+getVariantAtKey (CCSGSettingsWrapper *settings, const char *key, const char *pathName, CCSSettingType type)
+{
+    GVariant *gsettingsValue = ccsGSettingsWrapperGetValue (settings, key);
+
+    if (!checkReadVariantIsValid (gsettingsValue, type, pathName))
+    {
+	g_variant_unref (gsettingsValue);
+	return NULL;
+    }
+
+    return gsettingsValue;
+}
+
+CCSSettingValueList
+readBoolListValue (GVariantIter *iter, guint nItems, CCSSetting *setting, CCSObjectAllocationInterface *ai)
+{
+    CCSSettingValueList list = NULL;
+    Bool *array = (*ai->calloc_) (ai->allocator, 1, nItems * sizeof (Bool));
+    Bool *arrayCounter = array;
+    gboolean value;
+
+    if (!array)
+	return NULL;
+
+    /* Reads each item from the variant into arrayCounter */
+    while (g_variant_iter_loop (iter, "b", &value))
+	*arrayCounter++ = value ? TRUE : FALSE;
+
+    list = ccsGetValueListFromBoolArray (array, nItems, setting);
+    free (array);
+
+    return list;
+}
+
+CCSSettingValueList
+readIntListValue (GVariantIter *iter, guint nItems, CCSSetting *setting, CCSObjectAllocationInterface *ai)
+{
+    CCSSettingValueList list = NULL;
+    int *array = (*ai->calloc_) (ai->allocator, 1, nItems * sizeof (int));
+    int *arrayCounter = array;
+    gint value;
+
+    if (!array)
+	return NULL;
+
+    /* Reads each item from the variant into arrayCounter */
+    while (g_variant_iter_loop (iter, "i", &value))
+	*arrayCounter++ = value;
+
+    list = ccsGetValueListFromIntArray (array, nItems, setting);
+    free (array);
+
+    return list;
+}
+
+CCSSettingValueList
+readFloatListValue (GVariantIter *iter, guint nItems, CCSSetting *setting, CCSObjectAllocationInterface *ai)
+{
+    CCSSettingValueList list = NULL;
+    float *array = (*ai->calloc_) (ai->allocator, 1, nItems * sizeof (float));
+    float *arrayCounter = array;
+    gdouble value;
+
+    if (!array)
+	return NULL;
+
+    /* Reads each item from the variant into arrayCounter */
+    while (g_variant_iter_loop (iter, "d", &value))
+	*arrayCounter++ = value;
+
+    list = ccsGetValueListFromFloatArray (array, nItems, setting);
+    free (array);
+
+    return list;
+}
+
+CCSSettingValueList
+readStringListValue (GVariantIter *iter, guint nItems, CCSSetting *setting, CCSObjectAllocationInterface *ai)
+{
+    CCSSettingValueList list = NULL;
+    const gchar **array = (*ai->calloc_) (ai->allocator, 1, (nItems + 1) * sizeof (gchar *));
+    const gchar **arrayCounter = array;
+    gchar *value;
+
+    if (!array)
+	return NULL;
+
+    array[nItems] = NULL;
+
+    /* Reads each item from the variant into arrayCounter */
+    while (g_variant_iter_next (iter, "s", &value))
+	*arrayCounter++ = value;
+
+    list = ccsGetValueListFromStringArray (array, nItems, setting);
+    g_strfreev ((char **) array);
+
+    return list;
+}
+
+CCSSettingValueList
+readColorListValue (GVariantIter *iter, guint nItems, CCSSetting *setting, CCSObjectAllocationInterface *ai)
+{
+    CCSSettingValueList list = NULL;
+    char		 *colorValue;
+    CCSSettingColorValue *array = (*ai->calloc_) (ai->allocator, 1, nItems * sizeof (CCSSettingColorValue));
+    unsigned int i = 0;
+
+    if (!array)
+	return NULL;
+
+    while (g_variant_iter_loop (iter, "s", &colorValue))
+    {
+	ccsStringToColor (colorValue,
+			  &array[i]);
+	i++;
+    }
+
+    list = ccsGetValueListFromColorArray (array, nItems, setting);
+    free (array);
+
+    return list;
+}
+
+CCSSettingValueList
+readListValue (GVariant *gsettingsValue, CCSSetting *setting, CCSObjectAllocationInterface *ai)
+{
+    CCSSettingType      listType = ccsSettingGetInfo (setting)->forList.listType;
+    gboolean		hasVariantType;
+    unsigned int        nItems;
+    CCSSettingValueList list = NULL;
+    GVariantIter	iter;
+
+    hasVariantType = compizconfigTypeHasVariantType (listType);
+
+    if (!hasVariantType)
+	return NULL;
+
+    g_variant_iter_init (&iter, gsettingsValue);
+    nItems = g_variant_iter_n_children (&iter);
+
+    switch (listType)
+    {
+    case TypeBool:
+	list = readBoolListValue (&iter, nItems, setting, ai);
+	break;
+    case TypeInt:
+	list = readIntListValue (&iter, nItems, setting, ai);
+	break;
+    case TypeFloat:
+	list = readFloatListValue (&iter, nItems, setting, ai);
+	break;
+    case TypeString:
+    case TypeMatch:
+	list = readStringListValue (&iter, nItems, setting, ai);
+	break;
+    case TypeColor:
+	list = readColorListValue (&iter, nItems, setting, ai);
+	break;
+    default:
+	break;
+    }
+
+    return list;
+}
+
+const char * readStringFromVariant (GVariant *gsettingsValue)
+{
+    return g_variant_get_string (gsettingsValue, NULL);
+}
+
+int readIntFromVariant (GVariant *gsettingsValue)
+{
+    return g_variant_get_int32 (gsettingsValue);
+}
+
+Bool readBoolFromVariant (GVariant *gsettingsValue)
+{
+    return g_variant_get_boolean (gsettingsValue) ? TRUE : FALSE;
+}
+
+float readFloatFromVariant (GVariant *gsettingsValue)
+{
+    return (float) g_variant_get_double (gsettingsValue);
+}
+
+CCSSettingColorValue readColorFromVariant (GVariant *gsettingsValue, Bool *success)
+{
+    const char           *value;
+    CCSSettingColorValue color;
+    value = g_variant_get_string (gsettingsValue, NULL);
+
+    if (value)
+	*success = ccsStringToColor (value, &color);
+    else
+	*success = FALSE;
+
+    return color;
+}
+
+CCSSettingKeyValue readKeyFromVariant (GVariant *gsettingsValue, Bool *success)
+{
+    const char         *value;
+    CCSSettingKeyValue key;
+    value = g_variant_get_string (gsettingsValue, NULL);
+
+     if (value)
+	 *success = ccsStringToKeyBinding (value, &key);
+     else
+	 *success = FALSE;
+
+     return key;
+}
+
+CCSSettingButtonValue readButtonFromVariant (GVariant *gsettingsValue, Bool *success)
+{
+    const char            *value;
+    CCSSettingButtonValue button;
+    value = g_variant_get_string (gsettingsValue, NULL);
+
+    if (value)
+	*success = ccsStringToButtonBinding (value, &button);
+    else
+	*success = FALSE;
+
+    return button;
+}
+
+unsigned int readEdgeFromVariant (GVariant *gsettingsValue)
+{
+    const char   *value;
+    value = g_variant_get_string (gsettingsValue, NULL);
+
+    if (value)
+	return ccsStringToEdges (value);
+
+    return 0;
+}
+
+GVariant *
+writeBoolListValue (CCSSettingValueList list)
+{
+    GVariant *value = NULL;
+    GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE ("ab"));
+    while (list)
+    {
+	g_variant_builder_add (builder, "b", list->data->value.asBool);
+	list = list->next;
+    }
+    value = g_variant_new ("ab", builder);
+    g_variant_builder_unref (builder);
+
+    return value;
+}
+
+GVariant *
+writeIntListValue (CCSSettingValueList list)
+{
+    GVariant *value = NULL;
+    GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE ("ai"));
+    while (list)
+    {
+	g_variant_builder_add (builder, "i", list->data->value.asInt);
+	list = list->next;
+    }
+    value = g_variant_new ("ai", builder);
+    g_variant_builder_unref (builder);
+
+    return value;
+}
+
+GVariant *
+writeFloatListValue (CCSSettingValueList list)
+{
+    GVariant *value = NULL;
+    GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE ("ad"));
+    while (list)
+    {
+	g_variant_builder_add (builder, "d", (gdouble) list->data->value.asFloat);
+	list = list->next;
+    }
+    value = g_variant_new ("ad", builder);
+    g_variant_builder_unref (builder);
+
+    return value;
+}
+
+GVariant *
+writeStringListValue (CCSSettingValueList list)
+{
+    GVariant *value = NULL;
+    GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
+    while (list)
+    {
+	g_variant_builder_add (builder, "s", list->data->value.asString);
+	list = list->next;
+    }
+    value = g_variant_new ("as", builder);
+    g_variant_builder_unref (builder);
+
+    return value;
+}
+
+GVariant *
+writeMatchListValue (CCSSettingValueList list)
+{
+    GVariant *value = NULL;
+    GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
+    while (list)
+    {
+	g_variant_builder_add (builder, "s", list->data->value.asMatch);
+	list = list->next;
+    }
+    value = g_variant_new ("as", builder);
+    g_variant_builder_unref (builder);
+
+    return value;
+}
+
+GVariant *
+writeColorListValue (CCSSettingValueList list)
+{
+    GVariant *value = NULL;
+    GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
+    char *item;
+    while (list)
+    {
+	item = ccsColorToString (&list->data->value.asColor);
+	g_variant_builder_add (builder, "s", item);
+	g_free (item);
+	list = list->next;
+    }
+    value = g_variant_new ("as", builder);
+    g_variant_builder_unref (builder);
+
+    return value;
+}
+
+Bool
+writeListValue (CCSSettingValueList list,
+		CCSSettingType	    listType,
+		GVariant	    **gsettingsValue)
+{
+    GVariant *value = NULL;
+
+    switch (listType)
+    {
+    case TypeBool:
+	value = writeBoolListValue (list);
+	break;
+    case TypeInt:
+	value = writeIntListValue (list);
+	break;
+    case TypeFloat:
+	 value = writeFloatListValue (list);
+	break;
+    case TypeString:
+	value = writeStringListValue (list);
+	break;
+    case TypeMatch:
+	value = writeMatchListValue (list);
+	break;
+    case TypeColor:
+	value = writeColorListValue (list);
+	break;
+    default:
+	ccsWarning ("Attempt to write unsupported list type %d!",
+	       listType);
+	return FALSE;
+	break;
+    }
+
+    *gsettingsValue = value;
+    return TRUE;
+}
+
+Bool writeStringToVariant (const char *value, GVariant **variant)
+{
+    *variant = g_variant_new_string (value);
+    return TRUE;
+}
+
+Bool writeFloatToVariant (float value, GVariant **variant)
+{
+    *variant = g_variant_new_double ((double) value);
+    return TRUE;
+}
+
+Bool writeIntToVariant (int value, GVariant **variant)
+{
+    *variant = g_variant_new_int32 (value);
+    return TRUE;
+}
+
+Bool writeBoolToVariant (Bool value, GVariant **variant)
+{
+    *variant = g_variant_new_boolean (value);
+    return TRUE;
+}
+
+Bool writeColorToVariant (CCSSettingColorValue value, GVariant **variant)
+{
+    char                 *colString;
+
+    colString = ccsColorToString (&value);
+    if (!colString)
+	return FALSE;
+
+    *variant = g_variant_new_string (colString);
+    free (colString);
+
+    return TRUE;
+}
+
+Bool writeKeyToVariant (CCSSettingKeyValue key, GVariant **variant)
+{
+    char               *keyString;
+
+    keyString = ccsKeyBindingToString (&key);
+    if (!keyString)
+	return FALSE;
+
+    *variant = g_variant_new_string (keyString);
+    free (keyString);
+
+    return TRUE;
+}
+
+Bool writeButtonToVariant (CCSSettingButtonValue button, GVariant **variant)
+{
+    char                  *buttonString;
+
+    buttonString = ccsButtonBindingToString (&button);
+    if (!buttonString)
+	return FALSE;
+
+    *variant = g_variant_new_string (buttonString);
+    free (buttonString);
+    return TRUE;
+}
+
+Bool writeEdgeToVariant (unsigned int edges, GVariant **variant)
+{
+    char         *edgeString;
+
+    edgeString = ccsEdgesToString (edges);
+    if (!edgeString)
+	return FALSE;
+
+    *variant = g_variant_new_string (edgeString);
+    free (edgeString);
+    return TRUE;
+}
+
+void
+writeVariantToKey (CCSGSettingsWrapper  *settings,
+		   const char *key,
+		   GVariant   *value)
+{
+    ccsGSettingsWrapperSetValue (settings, key, value);
+}
+
+typedef void (*VariantItemCheckAndInsertFunc) (GVariantBuilder *, const char *item, void *userData);
+
+typedef struct _FindItemInVariantData
+{
+    gboolean   found;
+    const char *item;
+} FindItemInVariantData;
+
+static void
+insertIfNotEqual (GVariantBuilder *builder, const char *item, void *userData)
+{
+    const char *cmp = (const char *) userData;
+
+    if (g_strcmp0 (item, cmp))
+	g_variant_builder_add (builder, "s", item);
+}
+
+static void
+findItemForVariantData (GVariantBuilder *builder, const char *item, void *userData)
+{
+    FindItemInVariantData *data = (FindItemInVariantData *) userData;
+
+    if (!data->found)
+	data->found = g_str_equal (data->item, item);
+
+    g_variant_builder_add (builder, "s", item);
+}
+
+static void
+rebuildVariant (GVariantBuilder		      *builder,
+		GVariant		      *originalVariant,
+		VariantItemCheckAndInsertFunc checkAndInsert,
+		void			      *userData)
+{
+    GVariantIter    iter;
+    char	    *str;
+
+    g_variant_iter_init (&iter, originalVariant);
+    while (g_variant_iter_loop (&iter, "s", &str))
+    {
+	(*checkAndInsert) (builder, str, userData);
+    }
+}
+
+gboolean
+appendStringToVariantIfUnique (GVariant	  **variant,
+			       const char *string)
+{
+    GVariantBuilder newVariantBuilder;
+    FindItemInVariantData findItemData;
+
+    memset (&findItemData, 0, sizeof (FindItemInVariantData));
+    g_variant_builder_init (&newVariantBuilder, G_VARIANT_TYPE ("as"));
+
+    findItemData.item = string;
+
+    rebuildVariant  (&newVariantBuilder, *variant, findItemForVariantData, &findItemData);
+
+    if (!findItemData.found)
+	g_variant_builder_add (&newVariantBuilder, "s", string);
+
+    g_variant_unref (*variant);
+    *variant = g_variant_builder_end (&newVariantBuilder);
+
+    return !findItemData.found;
+}
+
+void
+removeItemFromVariant (GVariant	  **variant,
+		       const char *string)
+{
+    GVariantBuilder newVariantBuilder;
+
+    g_variant_builder_init (&newVariantBuilder, G_VARIANT_TYPE ("as"));
+
+    rebuildVariant (&newVariantBuilder, *variant, insertIfNotEqual, (void *) string);
+
+    g_variant_unref (*variant);
+    *variant = g_variant_builder_end (&newVariantBuilder);
+}
+
+void
+resetOptionToDefault (CCSBackend *backend, CCSSetting * setting)
+{
+    CCSGSettingsWrapper  *settings = getSettingsObjectForCCSSetting (backend, setting);
+    char *cleanSettingName = translateKeyForGSettings (ccsSettingGetName (setting));
+
+    ccsGSettingsWrapperResetKey (settings, cleanSettingName);
+
+    free (cleanSettingName);
+}
+
+gchar *
+makeSettingPath (const char *currentProfile, CCSSetting *setting)
+{
+    return makeCompizPluginPath (currentProfile,
+				 ccsPluginGetName (ccsSettingGetParent (setting)));
+}
+
+CCSGSettingsWrapper *
+getSettingsObjectForCCSSetting (CCSBackend *backend, CCSSetting *setting)
+{
+    CCSGSettingsWrapper *ret = NULL;
+    gchar *pathName = makeSettingPath (ccsGSettingsBackendGetCurrentProfile (backend), setting);
+
+    ret = ccsGSettingsGetSettingsObjectForPluginWithPath (backend,
+							  ccsPluginGetName (ccsSettingGetParent (setting)),
+							  pathName,
+							  ccsPluginGetContext (ccsSettingGetParent (setting)));
+
+    g_free (pathName);
+    return ret;
+}
+
+gboolean
+ccsGSettingsBackendAddProfileDefault (CCSBackend *backend, const char *profile)
+{
+    GVariant        *profiles;
+    gboolean	    ret = FALSE;
+
+    profiles = ccsGSettingsBackendGetExistingProfiles (backend);
+    if (appendStringToVariantIfUnique (&profiles, profile))
+    {
+	ret = TRUE;
+	ccsGSettingsBackendSetExistingProfiles (backend, profiles);
+    }
+    else
+	g_variant_unref (profiles);
+
+    return ret;
+}
+
+void
+ccsGSettingsBackendUpdateCurrentProfileNameDefault (CCSBackend *backend, const char *profile)
+{
+    ccsGSettingsBackendAddProfile (backend, profile);
+    ccsGSettingsBackendSetCurrentProfile (backend, profile);
+}
+
+gboolean
+ccsGSettingsBackendUpdateProfileDefault (CCSBackend *backend, CCSContext *context)
+{
+    const char *currentProfile = ccsGSettingsBackendGetCurrentProfile (backend);
+    const char *ccsProfile = ccsGetProfile (context);
+    char *profile = NULL;
+
+    if (!ccsProfile)
+	profile = strdup (DEFAULTPROF);
+    else
+	profile = strdup (ccsProfile);
+
+    if (!strlen (profile))
+    {
+	free (profile);
+	profile = strdup (DEFAULTPROF);
+    }
+
+    if (g_strcmp0 (profile, currentProfile))
+	ccsGSettingsBackendUpdateCurrentProfileName (backend, profile);
+
+    free (profile);
+
+    return TRUE;
+}
+
+gboolean
+deleteProfile (CCSBackend *backend,
+	       CCSContext *context,
+	       const char *profile)
+{
+    GVariant        *plugins;
+    GVariant        *profiles;
+    const char      *currentProfile = ccsGSettingsBackendGetCurrentProfile (backend);
+
+    plugins = ccsGSettingsBackendGetPluginsWithSetKeys (backend);
+    profiles = ccsGSettingsBackendGetExistingProfiles (backend);
+
+    ccsGSettingsBackendUnsetAllChangedPluginKeysInProfile (backend, context, plugins, currentProfile);
+    ccsGSettingsBackendClearPluginsWithSetKeys (backend);
+
+    removeItemFromVariant (&profiles, profile);
+
+    /* Remove the profile from existing-profiles */
+    ccsGSettingsBackendSetExistingProfiles (backend, profiles);
+
+    ccsGSettingsBackendUpdateProfile (backend, context);
+
+    /* Since we do not call g_settings_set_value on
+     * plugins, we must also unref the variant */
+    g_variant_unref (plugins);
+
+    return TRUE;
+}
+
+void
+ccsGSettingsBackendUnsetAllChangedPluginKeysInProfileDefault (CCSBackend *backend,
+							      CCSContext *context,
+							      GVariant *pluginsWithChangedKeys,
+							      const char * profile)
+{
+    GVariantIter    iter;
+    char            *plugin;
+
+    g_variant_iter_init (&iter, pluginsWithChangedKeys);
+    while (g_variant_iter_loop (&iter, "s", &plugin))
+    {
+	CCSGSettingsWrapper *settings;
+	gchar *pathName = makeCompizPluginPath (profile, plugin);
+
+	settings = ccsGSettingsGetSettingsObjectForPluginWithPath (backend, plugin, pathName, context);
+	g_free (pathName);
+
+	/* The GSettings documentation says not to use this API
+	 * because we should know our own schema ... though really
+	 * we don't because we autogenerate schemas ... */
+	if (settings)
+	{
+	    char **keys = ccsGSettingsWrapperListKeys (settings);
+	    char **key_ptr;
+
+	    /* Unset all the keys */
+	    for (key_ptr = keys; *key_ptr; key_ptr++)
+		ccsGSettingsWrapperResetKey (settings, *key_ptr);
+
+	    g_strfreev (keys);
+	}
+    }
+}
+
+CCSContext *
+ccsGSettingsBackendGetContext (CCSBackend *backend)
+{
+    return (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendGetContext) (backend);
+}
+
+
+void
+ccsGSettingsBackendConnectToChangedSignal (CCSBackend *backend,
+					   CCSGSettingsWrapper *object)
+{
+     (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendConnectToChangedSignal) (backend, object);
+}
+
+CCSGSettingsWrapper *
+ccsGSettingsGetSettingsObjectForPluginWithPath (CCSBackend *backend,
+						const char *plugin,
+						const char *path,
+						CCSContext *context)
+{
+    return (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendGetSettingsObjectForPluginWithPath) (backend, plugin, path, context);
+}
+
+void
+ccsGSettingsBackendRegisterGConfClient (CCSBackend *backend)
+{
+    (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendRegisterGConfClient) (backend);
+}
+
+void
+ccsGSettingsBackendUnregisterGConfClient (CCSBackend *backend)
+{
+    (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendUnregisterGConfClient) (backend);
+}
+
+const char *
+ccsGSettingsBackendGetCurrentProfile (CCSBackend *backend)
+{
+    return (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendGetCurrentProfile) (backend);
+}
+
+GVariant *
+ccsGSettingsBackendGetExistingProfiles (CCSBackend *backend)
+{
+    return (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendGetExistingProfiles) (backend);
+}
+
+void
+ccsGSettingsBackendSetExistingProfiles (CCSBackend *backend, GVariant *value)
+{
+    (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendSetExistingProfiles) (backend, value);
+}
+
+void
+ccsGSettingsBackendSetCurrentProfile (CCSBackend *backend, const gchar *value)
+{
+    (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendSetCurrentProfile) (backend, value);
+}
+
+GVariant *
+ccsGSettingsBackendGetPluginsWithSetKeys (CCSBackend *backend)
+{
+    return (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendGetPluginsWithSetKeys) (backend);
+}
+
+void
+ccsGSettingsBackendClearPluginsWithSetKeys (CCSBackend *backend)
+{
+    (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendClearPluginsWithSetKeys) (backend);
+}
+
+void
+ccsGSettingsBackendUnsetAllChangedPluginKeysInProfile (CCSBackend *backend,
+						       CCSContext *context,
+						       GVariant   *pluginKeys,
+						       const char *profile)
+{
+    (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendUnsetAllChangedPluginKeysInProfile) (backend, context, pluginKeys, profile);
+}
+
+gboolean
+ccsGSettingsBackendUpdateProfile (CCSBackend *backend, CCSContext *context)
+{
+    return (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendUpdateProfile) (backend, context);
+}
+
+void
+ccsGSettingsBackendUpdateCurrentProfileName (CCSBackend *backend, const char *profile)
+{
+    (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendUpdateCurrentProfileName) (backend, profile);
+}
+
+void
+ccsGSettingsBackendAddProfile (CCSBackend *backend, const char *profile)
+{
+    (*(GET_INTERFACE (CCSGSettingsBackendInterface, backend))->gsettingsBackendAddProfile) (backend, profile);
+}
+
+CCSContext *
+ccsGSettingsBackendGetContext (CCSBackend *backend);

=== modified file 'compizconfig/gsettings/gsettings_backend_shared/gsettings_util.h'
--- compizconfig/gsettings/gsettings_backend_shared/gsettings_util.h	2012-07-10 10:14:00 +0000
+++ compizconfig/gsettings/gsettings_backend_shared/gsettings_util.h	2012-08-07 01:05:15 +0000
@@ -1,9 +1,67 @@
 #ifndef _COMPIZ_GSETTINGS_UTIL_H
 #define _COMPIZ_GSETTINGS_UTIL_H
 
+#include <ccs.h>
+#include <ccs-backend.h>
+
+COMPIZCONFIG_BEGIN_DECLS
+
 #include <glib.h>
 #include <glib-object.h>
-#include <ccs.h>
+#include <gio/gio.h>
+
+#include "ccs_gsettings_interface.h"
+
+typedef struct _CCSGSettingsBackendPrivate CCSGSettingsBackendPrivate;
+typedef struct _CCSGSettingsBackendInterface CCSGSettingsBackendInterface;
+
+extern const CCSBackendInfo gsettingsBackendInfo;
+
+typedef CCSContext * (*CCSGSettingsBackendGetContext) (CCSBackend *);
+typedef void (*CCSGSettingsBackendConnectToChangedSignal) (CCSBackend *, CCSGSettingsWrapper *);
+typedef CCSGSettingsWrapper * (*CCSGSettingsBackendGetSettingsObjectForPluginWithPath) (CCSBackend *backend,
+											const char *plugin,
+											const char *path,
+											CCSContext *context);
+typedef void (*CCSGSettingsBackendRegisterGConfClient) (CCSBackend *backend);
+typedef void (*CCSGSettingsBackendUnregisterGConfClient) (CCSBackend *backend);
+
+typedef const char * (*CCSGSettingsBackendGetCurrentProfile) (CCSBackend *backend);
+
+typedef GVariant * (*CCSGSettingsBackendGetExistingProfiles) (CCSBackend *backend);
+typedef void (*CCSGSettingsBackendSetExistingProfiles) (CCSBackend *backend, GVariant *value);
+typedef void (*CCSGSettingsBackendSetCurrentProfile) (CCSBackend *backend, const gchar *value);
+
+typedef GVariant * (*CCSGSettingsBackendGetPluginsWithSetKeys) (CCSBackend *backend);
+typedef void (*CCSGSettingsBackendClearPluginsWithSetKeys) (CCSBackend *backend);
+
+typedef void (*CCSGSettingsBackendUnsetAllChangedPluginKeysInProfile) (CCSBackend *backend, CCSContext *, GVariant *, const char *);
+
+typedef gboolean (*CCSGSettingsBackendUpdateProfile) (CCSBackend *, CCSContext *);
+typedef void (*CCSGSettingsBackendUpdateCurrentProfileName) (CCSBackend *backend, const char *profile);
+
+typedef gboolean (*CCSGSettingsBackendAddProfile) (CCSBackend *backend, const char *profile);
+
+struct _CCSGSettingsBackendInterface
+{
+    CCSGSettingsBackendGetContext gsettingsBackendGetContext;
+    CCSGSettingsBackendConnectToChangedSignal gsettingsBackendConnectToChangedSignal;
+    CCSGSettingsBackendGetSettingsObjectForPluginWithPath gsettingsBackendGetSettingsObjectForPluginWithPath;
+    CCSGSettingsBackendRegisterGConfClient gsettingsBackendRegisterGConfClient;
+    CCSGSettingsBackendUnregisterGConfClient gsettingsBackendUnregisterGConfClient;
+    CCSGSettingsBackendGetCurrentProfile   gsettingsBackendGetCurrentProfile;
+    CCSGSettingsBackendGetExistingProfiles gsettingsBackendGetExistingProfiles;
+    CCSGSettingsBackendSetExistingProfiles gsettingsBackendSetExistingProfiles;
+    CCSGSettingsBackendSetCurrentProfile gsettingsBackendSetCurrentProfile;
+    CCSGSettingsBackendGetPluginsWithSetKeys gsettingsBackendGetPluginsWithSetKeys;
+    CCSGSettingsBackendClearPluginsWithSetKeys gsettingsBackendClearPluginsWithSetKeys;
+    CCSGSettingsBackendUnsetAllChangedPluginKeysInProfile gsettingsBackendUnsetAllChangedPluginKeysInProfile;
+    CCSGSettingsBackendUpdateProfile gsettingsBackendUpdateProfile;
+    CCSGSettingsBackendUpdateCurrentProfileName gsettingsBackendUpdateCurrentProfileName;
+    CCSGSettingsBackendAddProfile gsettingsBackendAddProfile;
+};
+
+unsigned int ccsCCSGSettingsBackendInterfaceGetType ();
 
 gchar *
 getSchemaNameForPlugin (const char *plugin);
@@ -41,9 +99,9 @@
 				char	       ***newWrittenPlugins,
 				gsize	       *newWrittenPluginsSize);
 
-GObject *
-findObjectInListWithPropertySchemaName (const gchar *schemaName,
-					GList	    *iter);
+CCSGSettingsWrapper *
+findCCSGSettingsWrapperBySchemaName (const gchar *schemaName,
+				     GList	 *iter);
 
 CCSSettingList
 filterAllSettingsMatchingType (CCSSettingType type,
@@ -56,6 +114,20 @@
 CCSSetting *
 attemptToFindCCSSettingFromLossyName (CCSSettingList settingList, const gchar *lossyName, CCSSettingType type);
 
+Bool
+findSettingAndPluginToUpdateFromPath (CCSGSettingsWrapper *settings,
+				      const char *path,
+				      const gchar *keyName,
+				      CCSContext *context,
+				      CCSPlugin **plugin,
+				      CCSSetting **setting,
+				      char **uncleanKeyName);
+
+Bool updateSettingWithGSettingsKeyName (CCSBackend *backend,
+					CCSGSettingsWrapper *settings,
+					const gchar     *keyName,
+					CCSBackendUpdateFunc updateSetting);
+
 GList *
 variantTypeToPossibleSettingType (const gchar *vt);
 
@@ -65,4 +137,170 @@
 gchar *
 makeCompizPluginPath (const gchar *profileName, const gchar *pluginName);
 
+gchar *
+getNameForCCSSetting (CCSSetting *setting);
+
+Bool
+checkReadVariantIsValid (GVariant *gsettingsValue, CCSSettingType type, const gchar *pathName);
+
+GVariant *
+getVariantAtKey (CCSGSettingsWrapper *settings, const char *key, const char *pathName, CCSSettingType type);
+
+const char * readStringFromVariant (GVariant *gsettingsValue);
+
+int readIntFromVariant (GVariant *gsettingsValue);
+
+Bool readBoolFromVariant (GVariant *gsettingsValue);
+
+float readFloatFromVariant (GVariant *gsettingsValue);
+
+CCSSettingColorValue readColorFromVariant (GVariant *gsettingsValue, Bool *success);
+
+CCSSettingKeyValue readKeyFromVariant (GVariant *gsettingsValue, Bool *success);
+
+CCSSettingButtonValue readButtonFromVariant (GVariant *gsettingsValue, Bool *success);
+
+unsigned int readEdgeFromVariant (GVariant *gsettingsValue);
+
+CCSSettingValueList
+readListValue (GVariant *gsettingsValue, CCSSetting *setting, CCSObjectAllocationInterface *allocator);
+
+Bool
+writeListValue (CCSSettingValueList list,
+		CCSSettingType	    listType,
+		GVariant	    **gsettingsValue);
+
+Bool writeStringToVariant (const char *value, GVariant **variant);
+
+Bool writeFloatToVariant (float value, GVariant **variant);
+
+Bool writeIntToVariant (int value, GVariant **variant);
+
+Bool writeBoolToVariant (Bool value, GVariant **variant);
+
+Bool writeColorToVariant (CCSSettingColorValue value, GVariant **variant);
+
+Bool writeKeyToVariant (CCSSettingKeyValue key, GVariant **variant);
+
+Bool writeButtonToVariant (CCSSettingButtonValue button, GVariant **variant);
+
+Bool writeEdgeToVariant (unsigned int edges, GVariant **variant);
+
+void writeVariantToKey (CCSGSettingsWrapper *settings,
+			const char *key,
+			GVariant   *value);
+
+typedef int (*ComparisonPredicate) (const void *s1, const void *s2);
+
+int voidcmp0 (const void *v1, const void *v2);
+
+gboolean
+deleteProfile (CCSBackend *backend,
+	       CCSContext *context,
+	       const char *profile);
+
+gboolean
+appendStringToVariantIfUnique (GVariant	  **variant,
+			       const char *string);
+
+void
+removeItemFromVariant (GVariant	  **variant,
+		       const char *string);
+
+CCSSettingValueList
+readBoolListValue (GVariantIter *iter, guint nItems, CCSSetting *setting, CCSObjectAllocationInterface *allocator);
+
+CCSSettingValueList
+readIntListValue (GVariantIter *iter, guint nItems, CCSSetting *setting, CCSObjectAllocationInterface *allocator);
+
+CCSSettingValueList
+readFloatListValue (GVariantIter *iter, guint nItems, CCSSetting *setting, CCSObjectAllocationInterface *allocator);
+
+CCSSettingValueList
+readStringListValue (GVariantIter *iter, guint nItems, CCSSetting *setting, CCSObjectAllocationInterface *allocator);
+
+CCSSettingValueList
+readColorListValue (GVariantIter *iter, guint nItems, CCSSetting *setting, CCSObjectAllocationInterface *allocator);
+
+gchar *
+makeSettingPath (const char *currentProfile, CCSSetting *setting);
+
+CCSGSettingsWrapper *
+getSettingsObjectForCCSSetting (CCSBackend *backend, CCSSetting *setting);
+
+void
+resetOptionToDefault (CCSBackend *backend, CCSSetting * setting);
+
+gboolean
+ccsGSettingsBackendUpdateProfile (CCSBackend *backend, CCSContext *context);
+
+void
+ccsGSettingsBackendUpdateCurrentProfileName (CCSBackend *backend, const char *profile);
+
+CCSContext *
+ccsGSettingsBackendGetContext (CCSBackend *backend);
+
+void
+ccsGSettingsBackendConnectToChangedSignal (CCSBackend *backend, CCSGSettingsWrapper *object);
+
+CCSGSettingsWrapper *
+ccsGSettingsGetSettingsObjectForPluginWithPath (CCSBackend *backend,
+						const char *plugin,
+						const char *path,
+						CCSContext *context);
+
+void
+ccsGSettingsBackendRegisterGConfClient (CCSBackend *backend);
+
+void
+ccsGSettingsBackendUnregisterGConfClient (CCSBackend *backend);
+
+const char *
+ccsGSettingsBackendGetCurrentProfile (CCSBackend *backend);
+
+GVariant *
+ccsGSettingsBackendGetExistingProfiles (CCSBackend *backend);
+
+void
+ccsGSettingsBackendSetExistingProfiles (CCSBackend *backend, GVariant *value);
+
+void
+ccsGSettingsBackendSetCurrentProfile (CCSBackend *backend, const gchar *value);
+
+GVariant *
+ccsGSettingsBackendGetPluginsWithSetKeys (CCSBackend *backend);
+
+void
+ccsGSettingsBackendClearPluginsWithSetKeys (CCSBackend *backend);
+
+void
+ccsGSettingsBackendUnsetAllChangedPluginKeysInProfile (CCSBackend *backend,
+						       CCSContext *context,
+						       GVariant   *pluginKeys,
+						       const char *profile);
+
+void
+ccsGSettingsBackendAddProfile (CCSBackend *backend,
+			       const char *profile);
+
+/* Default implementations, should be moved */
+
+void
+ccsGSettingsBackendUpdateCurrentProfileNameDefault (CCSBackend *backend, const char *profile);
+
+gboolean
+ccsGSettingsBackendUpdateProfileDefault (CCSBackend *backend, CCSContext *context);
+
+void
+ccsGSettingsBackendUnsetAllChangedPluginKeysInProfileDefault (CCSBackend *backend,
+							      CCSContext *context,
+							      GVariant *pluginsWithChangedKeys,
+							      const char * profile);
+
+gboolean ccsGSettingsBackendAddProfileDefault (CCSBackend *backend,
+					       const char *profile);
+
+
+COMPIZCONFIG_END_DECLS
+
 #endif

=== modified file 'compizconfig/gsettings/src/gconf-integration.c'
--- compizconfig/gsettings/src/gconf-integration.c	2012-08-07 01:05:13 +0000
+++ compizconfig/gsettings/src/gconf-integration.c	2012-08-07 01:05:15 +0000
@@ -33,8 +33,6 @@
 
 #include "gsettings.h"
 #ifdef USE_GCONF
-GConfClient *client = NULL;
-guint gnomeGConfNotifyIds[NUM_WATCHED_DIRS];
 
 const SpecialOptionGConf specialOptions[] = {
     {"run_key", "gnomecompat", FALSE,
@@ -456,45 +454,48 @@
 }
 
 void
-initGConfClient (CCSContext *context)
+initGConfClient (CCSBackend *backend)
 {
     int i;
 
-    client = gconf_client_get_default ();
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+    priv->client = gconf_client_get_default ();
 
     for (i = 0; i < NUM_WATCHED_DIRS; i++)
     {
-	gnomeGConfNotifyIds[i] = gconf_client_notify_add (client,
-						     watchedGConfGnomeDirectories[i],
-						     gnomeGConfValueChanged, context,
-						     NULL, NULL);
-	gconf_client_add_dir (client, watchedGConfGnomeDirectories[i],
+	priv->gnomeGConfNotifyIds[i] = gconf_client_notify_add (priv->client,
+								watchedGConfGnomeDirectories[i],
+								gnomeGConfValueChanged, priv->context,
+								NULL, NULL);
+	gconf_client_add_dir (priv->client, watchedGConfGnomeDirectories[i],
 			      GCONF_CLIENT_PRELOAD_NONE, NULL);
     }
 }
 
 void
-finiGConfClient (void)
+finiGConfClient (CCSBackend *backend)
 {
     int i;
 
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+
     for (i = 0; i < NUM_WATCHED_DIRS; i++)
     {
-	if (gnomeGConfNotifyIds[i])
+	if (priv->gnomeGConfNotifyIds[i])
 	{
-	    gconf_client_notify_remove (client, gnomeGConfNotifyIds[0]);
-	    gnomeGConfNotifyIds[i] = 0;
+	    gconf_client_notify_remove (priv->client, priv->gnomeGConfNotifyIds[0]);
+	    priv->gnomeGConfNotifyIds[i] = 0;
 	}
-	gconf_client_remove_dir (client, watchedGConfGnomeDirectories[i], NULL);
+	gconf_client_remove_dir (priv->client, watchedGConfGnomeDirectories[i], NULL);
     }
-    gconf_client_suggest_sync (client, NULL);
+    gconf_client_suggest_sync (priv->client, NULL);
 
-    g_object_unref (client);
-    client = NULL;
+    g_object_unref (priv->client);
+    priv->client = NULL;
 }
 
 static unsigned int
-getGnomeMouseButtonModifier(void)
+getGnomeMouseButtonModifier(GConfClient *client)
 {
     unsigned int modMask = 0;
     GError       *err = NULL;
@@ -537,17 +538,23 @@
 }
 
 Bool
-readGConfIntegratedOption (CCSContext *context,
+readGConfIntegratedOption (CCSBackend *backend,
+			   CCSContext *context,
 			   CCSSetting *setting,
 			   int	      index)
 {
     GConfValue *gconfValue;
     GError     *err = NULL;
     Bool       ret = FALSE;
+
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
     
-    ret = readOption (setting);
-
-    gconfValue = gconf_client_get (client,
+    if (!priv->client)
+	ccsGSettingsBackendRegisterGConfClient (backend);
+
+    ret = readOption (backend, setting);
+
+    gconfValue = gconf_client_get (priv->client,
 				   specialOptions[index].gnomeName,
 				   &err);
 
@@ -675,10 +682,10 @@
 		memset (&button, 0, sizeof (CCSSettingButtonValue));
 		ccsGetButton (setting, &button);
 
-		button.buttonModMask = getGnomeMouseButtonModifier ();
+		button.buttonModMask = getGnomeMouseButtonModifier (priv->client);
 		
 		resizeWithRightButton =
-		    gconf_client_get_bool (client, METACITY
+		    gconf_client_get_bool (priv->client, METACITY
 					   "/general/resize_with_right_button",
 					   &err);
 
@@ -704,7 +711,7 @@
 }
 
 static Bool
-setGnomeMouseButtonModifier (unsigned int modMask)
+setGnomeMouseButtonModifier (GConfClient *client, unsigned int modMask)
 {
     char   *modifiers, *currentValue;
     GError *err = NULL;
@@ -765,13 +772,19 @@
 }
 
 void
-writeGConfIntegratedOption (CCSContext *context,
+writeGConfIntegratedOption (CCSBackend *backend,
+			    CCSContext *context,
 			    CCSSetting *setting,
 			    int	       index)
 {
     GError     *err = NULL;
     const char *optionName = specialOptions[index].gnomeName;
     
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+
+    if (!priv->client)
+	ccsGSettingsBackendRegisterGConfClient (backend);
+
     switch (specialOptions[index].type)
     {
     case OptionInt:
@@ -779,10 +792,10 @@
 	    int newValue, currentValue;
 	    if (!ccsGetInt (setting, &newValue))
 		break;
-	    currentValue = gconf_client_get_int (client, optionName, &err);
+	    currentValue = gconf_client_get_int (priv->client, optionName, &err);
 
 	    if (!err && (currentValue != newValue))
-		gconf_client_set_int(client, specialOptions[index].gnomeName,
+		gconf_client_set_int(priv->client, specialOptions[index].gnomeName,
 				     newValue, NULL);
 	}
 	break;
@@ -792,11 +805,11 @@
 	    gboolean currentValue;
 	    if (!ccsGetBool (setting, &newValue))
 		break;
-    	    currentValue = gconf_client_get_bool (client, optionName, &err);
+	    currentValue = gconf_client_get_bool (priv->client, optionName, &err);
 
 	    if (!err && ((currentValue && !newValue) ||
 			 (!currentValue && newValue)))
-		gconf_client_set_bool (client, specialOptions[index].gnomeName,
+		gconf_client_set_bool (priv->client, specialOptions[index].gnomeName,
 				       newValue, NULL);
 	}
 	break;
@@ -806,12 +819,12 @@
 	    gchar *currentValue;
 	    if (!ccsGetString (setting, &newValue))
 		break;
-	    currentValue = gconf_client_get_string (client, optionName, &err);
+	    currentValue = gconf_client_get_string (priv->client, optionName, &err);
 
     	    if (!err && currentValue)
 	    {
 		if (strcmp (currentValue, newValue) != 0)
-		    gconf_client_set_string (client, optionName,
+		    gconf_client_set_string (priv->client, optionName,
 		     			     newValue, NULL);
 		g_free (currentValue);
 	    }
@@ -831,13 +844,13 @@
 		    newValue[0] = 'd';
 		}
 
-		currentValue = gconf_client_get_string (client,
+		currentValue = gconf_client_get_string (priv->client,
 							optionName, &err);
 
 		if (!err && currentValue)
 		{
 		    if (strcmp (currentValue, newValue) != 0)
-			gconf_client_set_string (client, optionName,
+			gconf_client_set_string (priv->client, optionName,
 				 		 newValue, NULL);
     		    g_free (currentValue);
 		}
@@ -857,7 +870,7 @@
 		if (!ccsGetBool (setting, &currentViewport))
 		    break;
 
-		gconf_client_set_bool (client, optionName,
+		gconf_client_set_bool (priv->client, optionName,
 				       !currentViewport, NULL);
 	    }
 	    else if (strcmp (settingName, "fullscreen_visual_bell") == 0)
@@ -868,12 +881,12 @@
 		    break;
 
 		newValue = fullscreen ? "fullscreen" : "frame_flash";
-		currentValue = gconf_client_get_string (client,
+		currentValue = gconf_client_get_string (priv->client,
 							optionName, &err);
 		if (!err && currentValue)
 		{
 		    if (strcmp (currentValue, newValue) != 0)
-			gconf_client_set_string (client, optionName,
+			gconf_client_set_string (priv->client, optionName,
 						 newValue, NULL);
 		    g_free (currentValue);
 		}
@@ -886,13 +899,13 @@
 		    break;
 
 		newValue = clickToFocus ? "click" : "sloppy";
-		currentValue = gconf_client_get_string (client,
+		currentValue = gconf_client_get_string (priv->client,
 							optionName, &err);
 
 		if (!err && currentValue)
 		{
 		    if (strcmp (currentValue, newValue) != 0)
-			gconf_client_set_string (client, optionName,
+			gconf_client_set_string (priv->client, optionName,
 						 newValue, NULL);
 		    g_free (currentValue);
 		}
@@ -916,21 +929,21 @@
 		}
 
 		currentValue =
-		    gconf_client_get_bool (client, METACITY
+		    gconf_client_get_bool (priv->client, METACITY
 					   "/general/resize_with_right_button",
 					   &err);
 
 		if (!err && ((currentValue && !resizeWithRightButton) ||
 			     (!currentValue && resizeWithRightButton)))
 		{
-		    gconf_client_set_bool (client,
+		    gconf_client_set_bool (priv->client,
 					   METACITY
 					   "/general/resize_with_right_button",
 					   resizeWithRightButton, NULL);
 		}
 
 		modMask = ccsSettingGetValue (setting)->value.asButton.buttonModMask;
-		if (setGnomeMouseButtonModifier (modMask))
+		if (setGnomeMouseButtonModifier (priv->client, modMask))
 		{
 		    setButtonBindingForSetting (context, "move",
 						"initiate_button", 1, modMask);

=== modified file 'compizconfig/gsettings/src/gsettings.c'
--- compizconfig/gsettings/src/gsettings.c	2012-08-07 01:05:13 +0000
+++ compizconfig/gsettings/src/gsettings.c	2012-08-07 01:05:15 +0000
@@ -34,35 +34,34 @@
 #define CCS_LOG_DOMAIN "gsettings"
 
 #include "gsettings.h"
+#include <ccs_gsettings_interface_wrapper.h>
 
 static void
 valueChanged (GSettings   *settings,
 	      gchar	  *keyname,
 	      gpointer    user_data);
 
-static GList	   *settingsList = NULL;
-static GSettings   *compizconfigSettings = NULL;
-static GSettings   *currentProfileSettings = NULL;
-
-char *currentProfile = NULL;
-
 /* some forward declarations */
-static void writeIntegratedOption (CCSContext *context,
+static void writeIntegratedOption (CCSBackend *backend,
+				   CCSContext *context,
 				   CCSSetting *setting,
 				   int        index);
 
-static GSettings *
-getSettingsObjectForPluginWithPath (const char *plugin,
-				  const char *path,
-				  CCSContext *context)
+static CCSGSettingsWrapper *
+ccsGSettingsBackendGetSettingsObjectForPluginWithPathDefault (CCSBackend *backend,
+							      const char *plugin,
+							      const char *path,
+							      CCSContext *context)
 {
-    GSettings *settingsObj = NULL;
+    CCSGSettingsWrapper *settingsObj = NULL;
     gchar *schemaName = getSchemaNameForPlugin (plugin);
     GVariant        *writtenPlugins;
     gsize            newWrittenPluginsSize;
     gchar           **newWrittenPlugins;
 
-    settingsObj = (GSettings *) findObjectInListWithPropertySchemaName (schemaName, settingsList);
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+
+    settingsObj = findCCSGSettingsWrapperBySchemaName (schemaName, priv->settingsList);
 
     if (settingsObj)
     {
@@ -72,11 +71,9 @@
 
     /* No existing settings object found for this schema, create one */
     
-    settingsObj = g_settings_new_with_path (schemaName, path);
-
-    g_signal_connect (G_OBJECT (settingsObj), "changed", (GCallback) valueChanged, (gpointer) context);
-
-    settingsList = g_list_append (settingsList, (void *) settingsObj);
+    settingsObj = ccsGSettingsWrapperNewForSchemaWithPath (schemaName, path, &ccsDefaultObjectAllocator);
+    ccsGSettingsBackendConnectToChangedSignal (backend, settingsObj);
+    priv->settingsList = g_list_append (priv->settingsList, (void *) settingsObj);
 
     /* Also write the plugin name to the list of modified plugins so
      * that when we delete the profile the keys for that profile are also
@@ -84,38 +81,22 @@
      * store keys that have changed from their defaults ... though
      * gsettings doesn't seem to give you a way to get all of the schemas */
 
-    writtenPlugins = g_settings_get_value (currentProfileSettings, "plugins-with-set-keys");
+    writtenPlugins = ccsGSettingsWrapperGetValue (priv->currentProfileSettings, "plugins-with-set-keys");
 
     appendToPluginsWithSetKeysList (plugin, writtenPlugins, &newWrittenPlugins, &newWrittenPluginsSize);
 
-    g_settings_set_strv (currentProfileSettings, "plugins-with-set-keys", (const gchar * const *)newWrittenPlugins);
-
+    GVariant *newWrittenPluginsVariant = g_variant_new_strv ((const gchar * const *) newWrittenPlugins, newWrittenPluginsSize);
+
+    ccsGSettingsWrapperSetValue (priv->currentProfileSettings, "plugins-with-set-keys", newWrittenPluginsVariant);
+
+    g_variant_unref (writtenPlugins);
     g_free (schemaName);
     g_strfreev (newWrittenPlugins);
 
     return settingsObj;
 }
 
-static gchar *
-makeSettingPath (CCSSetting *setting)
-{
-    return makeCompizPluginPath (currentProfile,
-                             ccsPluginGetName (ccsSettingGetParent (setting)));
-}
-
-static GSettings *
-getSettingsObjectForCCSSetting (CCSSetting *setting)
-{
-    GSettings *ret = NULL;
-    gchar *pathName = makeSettingPath (setting);
-
-    ret = getSettingsObjectForPluginWithPath (ccsPluginGetName (ccsSettingGetParent (setting)),
-					       pathName,
-					       ccsPluginGetContext (ccsSettingGetParent (setting)));
-
-    g_free (pathName);
-    return ret;
-}
+
 
 static Bool
 isIntegratedOption (CCSSetting *setting,
@@ -134,7 +115,7 @@
     int          index;
 
     readInit (backend, context);
-    if (!readOption (setting))
+    if (!readOption (backend, setting))
     {
 	ccsResetToDefault (setting, TRUE);
     }
@@ -143,7 +124,7 @@
 	isIntegratedOption (setting, &index))
     {
 	writeInit (backend, context);
-	writeIntegratedOption (context, setting, index);
+	writeIntegratedOption (backend, context, setting, index);
     }
 }
 
@@ -152,230 +133,57 @@
 	      gchar	  *keyName,
 	      gpointer    user_data)
 {
-    CCSContext   *context = (CCSContext *)user_data;
-    char	 *uncleanKeyName;
-    char	 *path, *pathOrig;
-    char         *pluginName;
-    unsigned int screenNum;
-    CCSPlugin    *plugin;
-    CCSSetting   *setting;
-
-    g_object_get (G_OBJECT (settings), "path", &pathOrig, NULL);
-
-    path = pathOrig;
-
-    if (!decomposeGSettingsPath (path, &pluginName, &screenNum))
-    {
-	g_free (pathOrig);
-	return;
-    }
-
-    plugin = ccsFindPlugin (context, pluginName);
-
-    uncleanKeyName = translateKeyForCCS (keyName);
-
-    setting = ccsFindSetting (plugin, uncleanKeyName);
-    if (!setting)
-    {
-	/* Couldn't find setting straight off the bat,
-	 * try and find the best match */
-	GVariant *value = g_settings_get_value (settings, keyName);
-
-	if (value)
-	{
-	    GList *possibleSettingTypes = variantTypeToPossibleSettingType (g_variant_get_type_string (value));
-	    GList *iter = possibleSettingTypes;
-
-	    while (iter)
-	    {
-		setting = attemptToFindCCSSettingFromLossyName (ccsGetPluginSettings (plugin),
-								keyName,
-								(CCSSettingType) GPOINTER_TO_INT (iter->data));
-
-		if (setting)
-		    break;
-
-		iter = iter->next;
-	    }
-
-	    g_list_free (possibleSettingTypes);
-	    g_variant_unref (value);
-	}
-
-	/* We hit a situation where either the key stored in GSettings couldn't be
-	 * matched at all to a key in the xml file, or where there were multiple matches.
-	 * Unfortunately, there isn't much we can do about this, other than try
-	 * and warn the user and bail out. It just means that if the key was updated
-	 * externally we won't know about the change until the next reload of settings */
-	if (!setting)
-	{
-	    ccsWarning ("Unable to find setting %s, for path %s", uncleanKeyName, path);
-	    g_free (pluginName);
-	    free (uncleanKeyName);
-	    g_free (pathOrig);
-	    return;
-	}
-    }
-
-    updateSetting (NULL, context, plugin, setting);
-
-    g_free (pluginName);
-    free (uncleanKeyName);
-    g_free (pathOrig);
-}
-
-static Bool
-readListValue (CCSSetting *setting)
-{
-    GSettings		*settings = getSettingsObjectForCCSSetting (setting);
-    gboolean		hasVariantType;
-    unsigned int        nItems, i = 0;
-    CCSSettingValueList list = NULL;
-    GVariant		*value;
-    GVariantIter	iter;
-
-    char *cleanSettingName = translateKeyForGSettings (ccsSettingGetName (setting));
-
-    hasVariantType = compizconfigTypeHasVariantType (ccsSettingGetInfo (setting)->forList.listType);
-
-    if (!hasVariantType)
-	return FALSE;
-
-    value = g_settings_get_value (settings, cleanSettingName);
-    if (!value)
-    {
-	ccsSetList (setting, NULL, TRUE);
-	return TRUE;
-    }
-
-    g_variant_iter_init (&iter, value);
-    nItems = g_variant_iter_n_children (&iter);
-
-    switch (ccsSettingGetInfo (setting)->forList.listType)
-    {
-    case TypeBool:
-	{
-	    Bool *array = malloc (nItems * sizeof (Bool));
-	    Bool *arrayCounter = array;
-	    gboolean value;
-
-	    if (!array)
-		break;
-
-	    /* Reads each item from the variant into arrayCounter */
-	    while (g_variant_iter_loop (&iter, "b", &value))
-		*arrayCounter++ = value;
-
-	    list = ccsGetValueListFromBoolArray (array, nItems, setting);
-	    free (array);
-	}
-	break;
-    case TypeInt:
-	{
-	    int *array = malloc (nItems * sizeof (int));
-	    int *arrayCounter = array;
-	    gint value;
-
-	    if (!array)
-		break;
-
-	    /* Reads each item from the variant into arrayCounter */
-	    while (g_variant_iter_loop (&iter, "i", &value))
-		*arrayCounter++ = value;
-
-	    list = ccsGetValueListFromIntArray (array, nItems, setting);
-	    free (array);
-	}
-	break;
-    case TypeFloat:
-	{
-	    double *array = malloc (nItems * sizeof (double));
-	    double *arrayCounter = array;
-	    gdouble value;
-
-	    if (!array)
-		break;
-
-	    /* Reads each item from the variant into arrayCounter */
-	    while (g_variant_iter_loop (&iter, "d", &value))
-		*arrayCounter++ = value;
-
-	    list = ccsGetValueListFromFloatArray ((float *) array, nItems, setting);
-	    free (array);
-	}
-	break;
-    case TypeString:
-    case TypeMatch:
-	{
-	    const gchar **array = g_malloc0 ((nItems + 1) * sizeof (gchar *));
-	    const gchar **arrayCounter = array;
-	    gchar *value;
-
-	    if (!array)
-		break;
-
-	    array[nItems] = NULL;
-
-	    /* Reads each item from the variant into arrayCounter */
-	    while (g_variant_iter_next (&iter, "s", &value))
-		*arrayCounter++ = value;
-
-	    list = ccsGetValueListFromStringArray (array, nItems, setting);
-	    g_strfreev ((char **) array);
-	}
-	break;
-    case TypeColor:
-	{
-	    CCSSettingColorValue *array;
-	    char		 *colorValue;
-	    array = malloc (nItems * sizeof (CCSSettingColorValue));
-	    if (!array)
-		break;
-
-	    while (g_variant_iter_loop (&iter, "s", &colorValue))
-    	    {
-		memset (&array[i], 0, sizeof (CCSSettingColorValue));
-		ccsStringToColor (colorValue,
-				  &array[i]);
-	    }
-	    list = ccsGetValueListFromColorArray (array, nItems, setting);
-	    free (array);
-	}
-	break;
-    default:
-	break;
-    }
-
-    free (cleanSettingName);
-
-    if (list)
-    {
-	ccsSetList (setting, list, TRUE);
-	ccsSettingValueListFree (list, TRUE);
-	return TRUE;
-    }
-
-    return FALSE;
-}
-
-static Bool
-readIntegratedOption (CCSContext *context,
+    CCSBackend   *backend = (CCSBackend *)user_data;
+    GValue       schemaNameValue = G_VALUE_INIT;
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+
+
+    g_value_init (&schemaNameValue, G_TYPE_STRING);
+    g_object_get_property (G_OBJECT (settings), "schema-id", &schemaNameValue);
+
+    const char *schemaName = g_value_get_string (&schemaNameValue);
+    CCSGSettingsWrapper *wrapper = findCCSGSettingsWrapperBySchemaName (schemaName, priv->settingsList);
+
+    g_value_unset (&schemaNameValue);
+
+    updateSettingWithGSettingsKeyName (backend, wrapper, keyName, updateSetting);
+}
+
+static Bool
+readIntegratedOption (CCSBackend *backend,
+		      CCSContext *context,
 		      CCSSetting *setting,
 		      int        index)
 {
 #ifdef USE_GCONF
-    return readGConfIntegratedOption (context, setting, index);
+    return readGConfIntegratedOption (backend, context, setting, index);
 #else
     return FALSE;
 #endif
 }
 
+static GVariant *
+getVariantForCCSSetting (CCSBackend *backend, CCSSetting *setting)
+{
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+    CCSGSettingsWrapper  *settings = getSettingsObjectForCCSSetting (backend, setting);
+    char *cleanSettingName = getNameForCCSSetting (setting);
+    gchar *pathName = makeSettingPath (priv->currentProfile, setting);
+    GVariant *gsettingsValue = getVariantAtKey (settings,
+						cleanSettingName,
+						pathName,
+						ccsSettingGetType (setting));
+
+    free (cleanSettingName);
+    free (pathName);
+    return gsettingsValue;
+}
+
 Bool
-readOption (CCSSetting * setting)
+readOption (CCSBackend *backend, CCSSetting * setting)
 {
-    GSettings  *settings = getSettingsObjectForCCSSetting (setting);
+    Bool       ret = FALSE;
     GVariant   *gsettingsValue = NULL;
-    Bool       ret = FALSE;
 
     /* It is impossible for certain settings to have a schema,
      * such as actions and read only settings, so in that case
@@ -388,36 +196,14 @@
 	return FALSE;
     }
 
-    char *cleanSettingName = translateKeyForGSettings (ccsSettingGetName (setting));
-
-    /* first check if the key is set */
-    gsettingsValue = g_settings_get_value (settings, cleanSettingName);
-
-    if (!gsettingsValue)
-    {
-	free (cleanSettingName);
-	return FALSE;
-    }
-
-    if (!variantIsValidForCCSType (gsettingsValue, ccsSettingGetType (setting)))
-    {
-	gchar *pathName = makeSettingPath (setting);
-	ccsWarning ("There is an unsupported value at path %s. "
-		"Settings from this path won't be read. Try to remove "
-		"that value so that operation can continue properly.",
-		pathName);
-	g_free (pathName);
-	free (cleanSettingName);
-	g_variant_unref (gsettingsValue);
-	return FALSE;
-    }
+    gsettingsValue = getVariantForCCSSetting (backend, setting);
 
     switch (ccsSettingGetType (setting))
     {
     case TypeString:
 	{
 	    const char *value;
-	    value = g_variant_get_string (gsettingsValue, NULL);
+	    value = readStringFromVariant (gsettingsValue);
 	    if (value)
 	    {
 		ccsSetString (setting, value, TRUE);
@@ -428,7 +214,7 @@
     case TypeMatch:
 	{
 	    const char * value;
-	    value = g_variant_get_string (gsettingsValue, NULL);
+	    value = readStringFromVariant (gsettingsValue);
 	    if (value)
 	    {
 		ccsSetMatch (setting, value, TRUE);
@@ -439,7 +225,7 @@
     case TypeInt:
 	{
 	    int value;
-	    value = g_variant_get_int32 (gsettingsValue);
+	    value = readIntFromVariant (gsettingsValue);
 
 	    ccsSetInt (setting, value, TRUE);
 	    ret = TRUE;
@@ -447,29 +233,28 @@
 	break;
     case TypeBool:
 	{
-	    gboolean value;
-	    value = g_variant_get_boolean (gsettingsValue);
+	    Bool value;
+	    value = readBoolFromVariant (gsettingsValue);
 
-	    ccsSetBool (setting, value ? TRUE : FALSE, TRUE);
+	    ccsSetBool (setting, value, TRUE);
 	    ret = TRUE;
 	}
 	break;
     case TypeFloat:
 	{
-	    double value;
-	    value = g_variant_get_double (gsettingsValue);
+	    float value;
+	    value = readFloatFromVariant (gsettingsValue);
 
-	    ccsSetFloat (setting, (float)value, TRUE);
+	    ccsSetFloat (setting, value, TRUE);
     	    ret = TRUE;
 	}
 	break;
     case TypeColor:
 	{
-	    const char           *value;
-	    CCSSettingColorValue color;
-	    value = g_variant_get_string (gsettingsValue, NULL);
+	    Bool success = FALSE;
+	    CCSSettingColorValue color = readColorFromVariant (gsettingsValue, &success);
 
-	    if (value && ccsStringToColor (value, &color))
+	    if (success)
 	    {
 		ccsSetColor (setting, color, TRUE);
 		ret = TRUE;
@@ -478,11 +263,10 @@
 	break;
     case TypeKey:
 	{
-	    const char         *value;
-	    CCSSettingKeyValue key;
-	    value = g_variant_get_string (gsettingsValue, NULL);
+	    Bool success = FALSE;
+	    CCSSettingKeyValue key = readKeyFromVariant (gsettingsValue, &success);
 
-	    if (value && ccsStringToKeyBinding (value, &key))
+	    if (success)
 	    {
 		ccsSetKey (setting, key, TRUE);
 		ret = TRUE;
@@ -491,11 +275,10 @@
 	break;
     case TypeButton:
 	{
-	    const char            *value;
-	    CCSSettingButtonValue button;
-	    value = g_variant_get_string (gsettingsValue, NULL);
+	    Bool success = FALSE;
+	    CCSSettingButtonValue button = readButtonFromVariant (gsettingsValue, &success);
 
-	    if (value && ccsStringToButtonBinding (value, &button))
+	    if (success)
 	    {
 		ccsSetButton (setting, button, TRUE);
 		ret = TRUE;
@@ -504,29 +287,40 @@
 	break;
     case TypeEdge:
 	{
-	    const char   *value;
-	    value = g_variant_get_string (gsettingsValue, NULL);
+	    unsigned int edges = readEdgeFromVariant (gsettingsValue);
 
-	    if (value)
-	    {
-		unsigned int edges;
-		edges = ccsStringToEdges (value);
-		ccsSetEdge (setting, edges, TRUE);
-		ret = TRUE;
-	    }
+	    ccsSetEdge (setting, edges, TRUE);
+	    ret = TRUE;
 	}
 	break;
     case TypeBell:
 	{
-	    gboolean value;
-	    value = g_variant_get_boolean (gsettingsValue);
+	    Bool value;
+	    value = readBoolFromVariant (gsettingsValue);
 
-	    ccsSetBell (setting, value ? TRUE : FALSE, TRUE);
+	    ccsSetBell (setting, value, TRUE);
 	    ret = TRUE;
 	}
 	break;
     case TypeList:
-	ret = readListValue (setting);
+	{
+	    CCSSettingValueList list = readListValue (gsettingsValue, setting, &ccsDefaultObjectAllocator);
+
+	    if (list)
+	    {
+		CCSSettingValueList iter = list;
+
+		while (iter)
+		{
+		    ((CCSSettingValue *) iter->data)->parent = setting;
+		    iter = iter->next;
+		}
+
+		ccsSetList (setting, list, TRUE);
+		ccsSettingValueListFree (list, TRUE);
+		ret = TRUE;
+	    }
+	}
 	break;
     default:
 	ccsWarning ("Attempt to read unsupported setting type %d!",
@@ -534,145 +328,31 @@
 	break;
     }
 
-    free (cleanSettingName);
     g_variant_unref (gsettingsValue);
 
     return ret;
 }
 
 static void
-writeListValue (CCSSetting *setting,
-		char       *pathName)
-{
-    GSettings  		*settings = getSettingsObjectForCCSSetting (setting);
-    GVariant 		*value = NULL;
-    CCSSettingValueList list;
-
-    char *cleanSettingName = translateKeyForGSettings (ccsSettingGetName (setting));
-    
-    if (!ccsGetList (setting, &list))
-	return;
-
-    switch (ccsSettingGetInfo (setting)->forList.listType)
-    {
-    case TypeBool:
-	{
-	    GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE ("ab"));
-	    while (list)
-	    {
-		g_variant_builder_add (builder, "b", list->data->value.asBool);
-		list = list->next;
-	    }
-	    value = g_variant_new ("ab", builder);
-	    g_variant_builder_unref (builder);
-	}
-	break;
-    case TypeInt:
-	{
-	    GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE ("ai"));
-	    while (list)
-	    {
-		g_variant_builder_add (builder, "i", list->data->value.asInt);
-		list = list->next;
-    	    }
-    	    value = g_variant_new ("ai", builder);
-	    g_variant_builder_unref (builder);
-	}
-	break;
-    case TypeFloat:
-	{
-	    GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE ("ad"));
-	    while (list)
-	    {
-		g_variant_builder_add (builder, "d", (gdouble) list->data->value.asFloat);
-		list = list->next;
-	    }
-	    value = g_variant_new ("ad", builder);
-	    g_variant_builder_unref (builder);
-	}
-	break;
-    case TypeString:
-	{
-	    GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
-	    while (list)
-	    {
-		g_variant_builder_add (builder, "s", list->data->value.asString);
-		list = list->next;
-	    }
-	    value = g_variant_new ("as", builder);
-	    g_variant_builder_unref (builder);
-	}
-	break;
-    case TypeMatch:
-	{
-	    GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
-	    while (list)
-	    {
-		g_variant_builder_add (builder, "s", list->data->value.asMatch);
-		list = list->next;
-	    }
-	    value = g_variant_new ("as", builder);
-	    g_variant_builder_unref (builder);
-	}
-	break;
-    case TypeColor:
-	{
-	    GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
-	    char *item;
-	    while (list)
-	    {
-		item = ccsColorToString (&list->data->value.asColor);
-		g_variant_builder_add (builder, "s", item);
-		list = list->next;
-	    }
-	    value = g_variant_new ("as", builder);
-	    g_variant_builder_unref (builder);
-	}
-	break;
-    default:
-	ccsWarning ("Attempt to write unsupported list type %d!",
-	       ccsSettingGetInfo (setting)->forList.listType);
-	break;
-    }
-
-    if (value)
-    {
-	g_settings_set_value (settings, cleanSettingName, value);
-	g_variant_unref (value);
-    }
-    
-    free (cleanSettingName);
-}
-
-static void
-writeIntegratedOption (CCSContext *context,
+writeIntegratedOption (CCSBackend *backend,
+		       CCSContext *context,
 		       CCSSetting *setting,
 		       int        index)
 {
 #ifdef USE_GCONF
-    writeGConfIntegratedOption (context, setting, index);
+    writeGConfIntegratedOption (backend, context, setting, index);
 #endif
 
     return;
 }
 
-static void
-resetOptionToDefault (CCSSetting * setting)
-{
-    GSettings  *settings = getSettingsObjectForCCSSetting (setting);
-  
-    char *cleanSettingName = translateKeyForGSettings (ccsSettingGetName (setting));
-
-    g_settings_reset (settings, cleanSettingName);
-
-    free (cleanSettingName);
-}
-
 void
-writeOption (CCSSetting * setting)
+writeOption (CCSBackend *backend, CCSSetting * setting)
 {
-    GSettings  *settings = getSettingsObjectForCCSSetting (setting);
+    CCSGSettingsWrapper  *settings = getSettingsObjectForCCSSetting (backend, setting);
     char *cleanSettingName = translateKeyForGSettings (ccsSettingGetName (setting));
+    GVariant *gsettingsValue = NULL;
+    Bool success = FALSE;
 
     switch (ccsSettingGetType (setting))
     {
@@ -681,7 +361,7 @@
 	    char *value;
 	    if (ccsGetString (setting, &value))
 	    {
-		g_settings_set (settings, cleanSettingName, "s", value, NULL);
+		success = writeStringToVariant (value, &gsettingsValue);
 	    }
 	}
 	break;
@@ -690,15 +370,16 @@
 	    char *value;
 	    if (ccsGetMatch (setting, &value))
 	    {
-		g_settings_set (settings, cleanSettingName, "s", value, NULL);
+		success = writeStringToVariant (value, &gsettingsValue);
 	    }
 	}
+	break;
     case TypeFloat:
 	{
 	    float value;
 	    if (ccsGetFloat (setting, &value))
 	    {
-		g_settings_set (settings, cleanSettingName, "d", (double) value, NULL);
+		success = writeFloatToVariant (value, &gsettingsValue);
 	    }
 	}
 	break;
@@ -707,7 +388,7 @@
 	    int value;
 	    if (ccsGetInt (setting, &value))
 	    {
-		g_settings_set (settings, cleanSettingName, "i", value, NULL);
+		success = writeIntToVariant (value, &gsettingsValue);
 	    }
 	}
 	break;
@@ -716,72 +397,48 @@
 	    Bool value;
 	    if (ccsGetBool (setting, &value))
 	    {
-		g_settings_set (settings, cleanSettingName, "b", value, NULL);
+		success = writeBoolToVariant (value, &gsettingsValue);
 	    }
 	}
 	break;
     case TypeColor:
 	{
 	    CCSSettingColorValue value;
-	    char                 *colString;
 
 	    if (!ccsGetColor (setting, &value))
 		break;
 
-	    colString = ccsColorToString (&value);
-	    if (!colString)
-		break;
-
-	    g_settings_set (settings, cleanSettingName, "s", colString, NULL);
-	    free (colString);
+	    success = writeColorToVariant (value, &gsettingsValue);
 	}
 	break;
     case TypeKey:
 	{
 	    CCSSettingKeyValue key;
-	    char               *keyString;
 
 	    if (!ccsGetKey (setting, &key))
 		break;
 
-	    keyString = ccsKeyBindingToString (&key);
-	    if (!keyString)
-		break;
-
-	    g_settings_set (settings, cleanSettingName, "s", keyString, NULL);
-	    free (keyString);
+	    success = writeKeyToVariant (key, &gsettingsValue);
 	}
 	break;
     case TypeButton:
 	{
 	    CCSSettingButtonValue button;
-	    char                  *buttonString;
 
 	    if (!ccsGetButton (setting, &button))
 		break;
 
-	    buttonString = ccsButtonBindingToString (&button);
-	    if (!buttonString)
-		break;
-
-	    g_settings_set (settings, cleanSettingName, "s", buttonString, NULL);
-	    free (buttonString);
+	    success = writeButtonToVariant (button, &gsettingsValue);
 	}
 	break;
     case TypeEdge:
 	{
 	    unsigned int edges;
-	    char         *edgeString;
 
 	    if (!ccsGetEdge (setting, &edges))
 		break;
 
-	    edgeString = ccsEdgesToString (edges);
-	    if (!edgeString)
-		break;
-
-	    g_settings_set (settings, cleanSettingName, "s", edgeString, NULL);
-	    free (edgeString);
+	    success = writeEdgeToVariant (edges, &gsettingsValue);
 	}
 	break;
     case TypeBell:
@@ -789,15 +446,20 @@
 	    Bool value;
 	    if (ccsGetBell (setting, &value))
 	    {
-		g_settings_set (settings, cleanSettingName, "s", value, NULL);
+		success = writeBoolToVariant (value, &gsettingsValue);
 	    }
 	}
 	break;
     case TypeList:
 	{
-	    gchar *pathName = makeSettingPath (setting);
-	    writeListValue (setting, pathName);
-	    g_free (pathName);
+	    CCSSettingValueList  list = NULL;
+
+	    if (!ccsGetList (setting, &list))
+		return;
+
+	    success = writeListValue (list,
+				      ccsSettingGetInfo (setting)->forList.listType,
+				      &gsettingsValue);
 	}
 	break;
     default:
@@ -806,88 +468,33 @@
 	break;
     }
 
+    if (success && gsettingsValue)
+    {
+	/* g_settings_set_value will consume the reference
+	 * so there is no need to unref value here */
+	writeVariantToKey (settings, cleanSettingName, gsettingsValue);
+    }
+
     free (cleanSettingName);
 }
 
-static void
-updateCurrentProfileName (const char *profile)
-{
-    GVariant        *profiles;
-    char	    *prof;
-    gchar           *profilePath = makeCompizProfilePath (profile);
-    GVariant        *newProfiles;
-    GVariantBuilder *newProfilesBuilder;
-    GVariantIter    iter;
-    gboolean        found = FALSE;
-
-    profiles = g_settings_get_value (compizconfigSettings, "existing-profiles");
-
-    newProfilesBuilder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
-
-    g_variant_iter_init (&iter, profiles);
-    while (g_variant_iter_loop (&iter, "s", &prof))
-    {
-	g_variant_builder_add (newProfilesBuilder, "s", prof);
-
-	if (!found)
-	    found = (g_strcmp0 (prof, profile) == 0);
-    }
-
-    if (!found)
-	g_variant_builder_add (newProfilesBuilder, "s", profile);
-
-    newProfiles = g_variant_new ("as", newProfilesBuilder);
-    g_settings_set_value (compizconfigSettings, "existing-profiles", newProfiles);
-
-    g_variant_unref (newProfiles);
-    g_variant_builder_unref (newProfilesBuilder);
-
-    /* Change the current profile and current profile settings */
-    free (currentProfile);
-
-    currentProfile = strdup (profile);
-    currentProfileSettings = g_settings_new_with_path (PROFILE_SCHEMA_ID, profilePath);
-
-    g_settings_set (compizconfigSettings, "current-profile", "s", profile, NULL);
-
-    g_free (profilePath);
-}
-
-static gboolean
-updateProfile (CCSContext *context)
-{
-    char *profile = strdup (ccsGetProfile (context));
-
-    if (!profile)
-	profile = strdup (DEFAULTPROF);
-
-    if (!strlen (profile))
-    {
-	free (profile);
-	profile = strdup (DEFAULTPROF);
-    }
-
-    if (g_strcmp0 (profile, currentProfile))
-	updateCurrentProfileName (profile);
-
-    free (profile);
-
-    return TRUE;
-}
-
 static char*
-getCurrentProfileName (void)
+getCurrentProfileName (CCSBackend *backend)
 {
     GVariant *value;
     char     *ret = NULL;
 
-    value = g_settings_get_value (compizconfigSettings, "current-profile");
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+
+    value = ccsGSettingsWrapperGetValue (priv->compizconfigSettings, "current-profile");
 
     if (value)
 	ret = strdup (g_variant_get_string (value, NULL));
     else
 	ret = strdup (DEFAULTPROF);
 
+    g_variant_unref (value);
+
     return ret;
 }
 
@@ -901,6 +508,120 @@
     }
 }
 
+static CCSContext *
+ccsGSettingsBackendGetContextDefault (CCSBackend *backend)
+{
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+
+    return priv->context;
+}
+
+static void
+ccsGSettingsBackendConnectToValueChangedSignalDefault (CCSBackend *backend, CCSGSettingsWrapper *wrapper)
+{
+    ccsGSettingsWrapperConnectToChangedSignal (wrapper, (GCallback) valueChanged, (gpointer) backend);
+}
+
+static void
+ccsGSettingsBackendRegisterGConfClientDefault (CCSBackend *backend)
+{
+#ifdef USE_GCONF
+    initGConfClient (backend);
+#endif
+}
+
+static void
+ccsGSettingsBackendUnregisterGConfClientDefault (CCSBackend *backend)
+{
+#ifdef USE_GCONF
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+
+    gconf_client_clear_cache (priv->client);
+    finiGConfClient (backend);
+#endif
+}
+
+static const char *
+ccsGSettingsBackendGetCurrentProfileDefault (CCSBackend *backend)
+{
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+
+    return priv->currentProfile;
+}
+
+static GVariant *
+ccsGSettingsBackendGetExistingProfilesDefault (CCSBackend *backend)
+{
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+
+    return ccsGSettingsWrapperGetValue (priv->compizconfigSettings, "existing-profiles");
+}
+
+static void
+ccsGSettingsBackendSetExistingProfilesDefault (CCSBackend *backend, GVariant *value)
+{
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+
+    ccsGSettingsWrapperSetValue (priv->compizconfigSettings, "existing-profiles", value);
+}
+
+static void
+ccsGSettingsBackendSetCurrentProfileDefault (CCSBackend *backend, const gchar *value)
+{
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+    gchar           *profilePath = makeCompizProfilePath (value);
+
+    /* Change the current profile and current profile settings */
+    if (priv->currentProfile)
+	free (priv->currentProfile);
+
+    if (priv->currentProfileSettings)
+	ccsGSettingsWrapperUnref (priv->currentProfileSettings);
+
+    priv->currentProfile = strdup (value);
+    priv->currentProfileSettings = ccsGSettingsWrapperNewForSchemaWithPath (PROFILE_SCHEMA_ID,
+									    profilePath,
+									    backend->object.object_allocation);
+
+    GVariant *currentProfileVariant = g_variant_new ("s", value, NULL);
+
+    ccsGSettingsWrapperSetValue (priv->compizconfigSettings, "current-profile", currentProfileVariant);
+
+    g_free (profilePath);
+}
+
+GVariant *
+ccsGSettingsBackendGetPluginsWithSetKeysDefault (CCSBackend *backend)
+{
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+    return ccsGSettingsWrapperGetValue (priv->currentProfileSettings, "plugins-with-set-keys");
+}
+
+void
+ccsGSettingsBackendClearPluginsWithSetKeysDefault (CCSBackend *backend)
+{
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+    ccsGSettingsWrapperResetKey (priv->currentProfileSettings, "plugins-with-set-keys");
+}
+
+static CCSGSettingsBackendInterface gsettingsAdditionalDefaultInterface = {
+    ccsGSettingsBackendGetContextDefault,
+    ccsGSettingsBackendConnectToValueChangedSignalDefault,
+    ccsGSettingsBackendGetSettingsObjectForPluginWithPathDefault,
+    ccsGSettingsBackendRegisterGConfClientDefault,
+    ccsGSettingsBackendUnregisterGConfClientDefault,
+    ccsGSettingsBackendGetCurrentProfileDefault,
+    ccsGSettingsBackendGetExistingProfilesDefault,
+    ccsGSettingsBackendSetExistingProfilesDefault,
+    ccsGSettingsBackendSetCurrentProfileDefault,
+    ccsGSettingsBackendGetPluginsWithSetKeysDefault,
+    ccsGSettingsBackendClearPluginsWithSetKeysDefault,
+    ccsGSettingsBackendUnsetAllChangedPluginKeysInProfileDefault,
+    ccsGSettingsBackendUpdateProfileDefault,
+    ccsGSettingsBackendUpdateCurrentProfileNameDefault,
+    ccsGSettingsBackendAddProfileDefault
+};
+
 static Bool
 initBackend (CCSBackend *backend, CCSContext * context)
 {
@@ -908,61 +629,75 @@
 
     g_type_init ();
 
-    compizconfigSettings = g_settings_new (COMPIZCONFIG_SCHEMA_ID);
-
-#ifdef USE_GCONF
-    initGConfClient (context);
-#endif
-
-    currentProfile = getCurrentProfileName ();
-    currentProfilePath = makeCompizProfilePath (currentProfile);
-    currentProfileSettings = g_settings_new_with_path (PROFILE_SCHEMA_ID, currentProfilePath);
+    ccsObjectAddInterface (backend, (CCSInterface *) &gsettingsAdditionalDefaultInterface, GET_INTERFACE_TYPE (CCSGSettingsBackendInterface));
+
+    CCSGSettingsBackendPrivate *priv = calloc (1, sizeof (CCSGSettingsBackendPrivate));
+
+    if (!priv)
+	return FALSE;
+
+    ccsObjectSetPrivate (backend, (CCSPrivate *) priv);
+
+    priv->compizconfigSettings = ccsGSettingsWrapperNewForSchema (COMPIZCONFIG_SCHEMA_ID,
+								  backend->object.object_allocation);
+    priv->currentProfile = getCurrentProfileName (backend);
+    currentProfilePath = makeCompizProfilePath (priv->currentProfile);
+    priv->currentProfileSettings = ccsGSettingsWrapperNewForSchemaWithPath (PROFILE_SCHEMA_ID,
+									    currentProfilePath,
+									    backend->object.object_allocation);
+    priv->context = context;
 
     g_free (currentProfilePath);
 
     return TRUE;
 }
 
+static void
+ccsGSettingsWrapperDestroyNotify (gpointer o)
+{
+    ccsGSettingsWrapperUnref ((CCSGSettingsWrapper *) o);
+}
+
 static Bool
 finiBackend (CCSBackend *backend)
 {
-    GList *l = settingsList;
-
-    processEvents (backend, 0);
-
-#ifdef USE_GCONF
-    gconf_client_clear_cache (client);
-    finiGConfClient ();
-#endif
-
-    if (currentProfile)
-    {
-	free (currentProfile);
-	currentProfile = NULL;
-    }
-
-    while (l)
-    {
-	g_object_unref (G_OBJECT (l->data));
-	l = g_list_next (l);
-    }
-
-    if (currentProfileSettings)
-    {
-	g_object_unref (currentProfileSettings);
-	currentProfileSettings = NULL;
-    }
-
-    g_object_unref (G_OBJECT (compizconfigSettings));
-
-    processEvents (backend, 0);
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+
+    processEvents (backend, 0);
+
+    ccsGSettingsBackendUnregisterGConfClient (backend);
+
+    if (priv->currentProfile)
+    {
+	free (priv->currentProfile);
+	priv->currentProfile = NULL;
+    }
+
+    g_list_free_full (priv->settingsList, ccsGSettingsWrapperDestroyNotify);
+    priv->settingsList = NULL;
+
+    if (priv->currentProfileSettings)
+    {
+	ccsGSettingsWrapperUnref (priv->currentProfileSettings);
+	priv->currentProfileSettings = NULL;
+    }
+
+    ccsGSettingsWrapperUnref (priv->compizconfigSettings);
+
+    priv->compizconfigSettings = NULL;
+
+    processEvents (backend, 0);
+
+    free (priv);
+    ccsObjectSetPrivate (backend, NULL);
+
     return TRUE;
 }
 
 Bool
 readInit (CCSBackend *backend, CCSContext * context)
 {
-    return updateProfile (context);
+    return ccsGSettingsBackendUpdateProfile (backend, context);
 }
 
 void
@@ -976,10 +711,10 @@
     if (ccsGetIntegrationEnabled (context) &&
 	isIntegratedOption (setting, &index))
     {
-	status = readIntegratedOption (context, setting, index);
+	status = readIntegratedOption (backend, context, setting, index);
     }
     else
-	status = readOption (setting);
+	status = readOption (backend, setting);
 
     if (!status)
 	ccsResetToDefault (setting, TRUE);
@@ -988,7 +723,7 @@
 Bool
 writeInit (CCSBackend *backend, CCSContext * context)
 {
-    return updateProfile (context);
+    return ccsGSettingsBackendUpdateProfile (backend, context);
 }
 
 void
@@ -1001,14 +736,14 @@
     if (ccsGetIntegrationEnabled (context) &&
 	isIntegratedOption (setting, &index))
     {
-	writeIntegratedOption (context, setting, index);
+	writeIntegratedOption (backend, context, setting, index);
     }
     else if (ccsSettingGetIsDefault (setting))
     {
-	resetOptionToDefault (setting);
+	resetOptionToDefault (backend, setting);
     }
     else
-	writeOption (setting);
+	writeOption (backend, setting);
 
 }
 
@@ -1039,14 +774,16 @@
     GVariantIter  iter;
     CCSStringList ret = NULL;
 
-    value = g_settings_get_value (compizconfigSettings,  "existing-profiles");
+    CCSGSettingsBackendPrivate *priv = (CCSGSettingsBackendPrivate *) ccsObjectGetPrivate (backend);
+
+    value = ccsGSettingsWrapperGetValue (priv->compizconfigSettings,  "existing-profiles");
     g_variant_iter_init (&iter, value);
     while (g_variant_iter_loop (&iter, "s", &profile))
     {
-	CCSString *str = malloc (sizeof (CCSString));
-	
+	CCSString *str = calloc (1, sizeof (CCSString));
 	str->value = strdup (profile);
 
+	ccsStringRef (str);
 	ret = ccsStringListAppend (ret, str);
     }
 
@@ -1055,87 +792,18 @@
     return ret;
 }
 
-static Bool
-deleteProfile (CCSBackend *backend,
-	       CCSContext *context,
-	       char       *profile)
-{
-    GVariant        *plugins;
-    GVariant        *profiles;
-    GVariant        *newProfiles;
-    GVariantBuilder *newProfilesBuilder;
-    char            *plugin, *prof;
-    GVariantIter    iter;
-    char            *profileSettingsPath = makeCompizProfilePath (profile);
-    GSettings       *profileSettings = g_settings_new_with_path (PROFILE_SCHEMA_ID, profileSettingsPath);
-
-    plugins = g_settings_get_value (currentProfileSettings, "plugins-with-set-keys");
-    profiles = g_settings_get_value (compizconfigSettings, "existing-profiles");
-
-    g_variant_iter_init (&iter, plugins);
-    while (g_variant_iter_loop (&iter, "s", &plugin))
-    {
-	GSettings *settings;
-	gchar *pathName = makeCompizPluginPath (currentProfile, plugin);
-
-	settings = getSettingsObjectForPluginWithPath (plugin, pathName, context);
-	g_free (pathName);
-
-	/* The GSettings documentation says not to use this API
-	 * because we should know our own schema ... though really
-	 * we don't because we autogenerate schemas ... */
-	if (settings)
-	{
-	    char **keys = g_settings_list_keys (settings);
-	    char **key_ptr;
-
-	    /* Unset all the keys */
-	    for (key_ptr = keys; *key_ptr; key_ptr++)
-		g_settings_reset (settings, *key_ptr);
-
-	    g_strfreev (keys);
-	}
-    }
-
-    /* Remove the profile from existing-profiles */
-    g_settings_reset (profileSettings, "plugins-with-set-values");
-
-    g_variant_iter_init (&iter, profiles);
-    newProfilesBuilder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
-
-    while (g_variant_iter_loop (&iter, "s", &prof))
-    {
-	if (g_strcmp0 (prof, profile))
-	    g_variant_builder_add (newProfilesBuilder, "s", prof);
-    }
-
-    newProfiles = g_variant_new ("as", newProfilesBuilder);
-    g_settings_set_value (compizconfigSettings, "existing-profiles", newProfiles);
-
-    g_variant_unref (newProfiles);
-    g_variant_builder_unref (newProfilesBuilder);
-
-    g_free (profileSettingsPath);
-
-    updateProfile (context);
-
-    return TRUE;
-}
-
-const CCSBackendInfo gconfBackendInfo =
-{
-    "gsettings",
-    "GSettings Configuration Backend",
-    "GSettings Configuration Backend for libccs",
-    TRUE,
-    TRUE,
-    1
-};
-
 static const CCSBackendInfo *
 getInfo (CCSBackend *backend)
 {
-    return &gconfBackendInfo;
+    return &gsettingsBackendInfo;
+}
+
+static Bool
+ccsGSettingsDeleteProfileWrapper (CCSBackend *backend,
+				  CCSContext *context,
+				  char       *profile)
+{
+    return deleteProfile (backend, context, profile);
 }
 
 static CCSBackendInterface gsettingsVTable = {
@@ -1153,9 +821,11 @@
     getSettingIsIntegrated,
     getSettingIsReadOnly,
     getExistingProfiles,
-    deleteProfile
+    ccsGSettingsDeleteProfileWrapper
 };
 
+
+
 CCSBackendInterface *
 getBackendInfo (void)
 {

=== modified file 'compizconfig/gsettings/src/gsettings.h'
--- compizconfig/gsettings/src/gsettings.h	2012-08-07 01:05:13 +0000
+++ compizconfig/gsettings/src/gsettings.h	2012-08-07 01:05:15 +0000
@@ -56,6 +56,14 @@
 #define _GNU_SOURCE
 #endif
 
+#ifdef USE_GCONF
+#include <gconf/gconf.h>
+#include <gconf/gconf-client.h>
+#include <gconf/gconf-value.h>
+#endif
+
+#include <ccs_gsettings_interface.h>
+
 typedef enum {
     OptionInt,
     OptionBool,
@@ -64,22 +72,31 @@
     OptionSpecial,
 } SpecialOptionType;
 
-char *currentProfile;
+struct _CCSGSettingsBackendPrivate
+{
+    GList	   *settingsList;
+    CCSGSettingsWrapper *compizconfigSettings;
+    CCSGSettingsWrapper *currentProfileSettings;
+
+    char	    *currentProfile;
+    CCSContext  *context;
+
+#ifdef USE_GCONF
+    GConfClient *client;
+    guint       *gnomeGConfNotifyIds;
+#endif
+
+};
 
 Bool readInit (CCSBackend *, CCSContext * context);
 void readSetting (CCSBackend *, CCSContext * context, CCSSetting * setting);
-Bool readOption (CCSSetting * setting);
+Bool readOption (CCSBackend *backend, CCSSetting * setting);
 Bool writeInit (CCSBackend *, CCSContext * context);
-void writeOption (CCSSetting *setting);
+void writeOption (CCSBackend *backend, CCSSetting *setting);
 
 #ifdef USE_GCONF
 
-#include <gconf/gconf.h>
-#include <gconf/gconf-client.h>
-#include <gconf/gconf-value.h>
 
-GConfClient *client;
-guint gnomeGConfNotifyIds[NUM_WATCHED_DIRS];
 
 typedef struct _SpecialOptionGConf {
     const char*       settingName;
@@ -100,18 +117,20 @@
 			gpointer    user_data);
 
 void
-initGConfClient (CCSContext *context);
+initGConfClient (CCSBackend *backend);
 
 void
-finiGConfClient (void);
+finiGConfClient (CCSBackend *backend);
 
 Bool
-readGConfIntegratedOption (CCSContext *context,
+readGConfIntegratedOption (CCSBackend *backend,
+			   CCSContext *context,
 			   CCSSetting *setting,
 			   int	      index);
 
 void
-writeGConfIntegratedOption (CCSContext *context,
+writeGConfIntegratedOption (CCSBackend *backend,
+			    CCSContext *context,
 			    CCSSetting *setting,
 			    int	       index);
 

=== modified file 'compizconfig/gsettings/tests/CMakeLists.txt'
--- compizconfig/gsettings/tests/CMakeLists.txt	2012-08-07 01:05:13 +0000
+++ compizconfig/gsettings/tests/CMakeLists.txt	2012-08-07 01:05:15 +0000
@@ -1,4 +1,7 @@
+include (CompizGSettings)
+
 include_directories (${CMAKE_CURRENT_SOURCE_DIR}
+		     ${CMAKE_CURRENT_BINARY_DIR}
                      ${CMAKE_CURRENT_SOURCE_DIR}/../src
                      ${CMAKE_CURRENT_SOURCE_DIR}/../../libcompizconfig/tests
 		     ${CMAKE_CURRENT_SOURCE_DIR}/../../mocks/libcompizconfig
@@ -7,11 +10,18 @@
 
 pkg_check_modules (COMPIZCONFIG_TEST_GSETTINGS libcompizconfig)
 
+add_library (compizconfig_ccs_gsettings_wrapper_mock STATIC
+	     ${CMAKE_CURRENT_SOURCE_DIR}/ccs_gsettings_wrapper_mock.cpp
+	     ${CMAKE_CURRENT_SOURCE_DIR}/ccs_gsettings_wrapper_mock.h)
+
+add_library (compizconfig_ccs_gsettings_backend_mock STATIC
+	     ${CMAKE_CURRENT_SOURCE_DIR}/ccs_gsettings_backend_mock.cpp
+	     ${CMAKE_CURRENT_SOURCE_DIR}/ccs_gsettings_backend_mock.h)
+
 add_executable (compizconfig_test_gsettings
-		${CMAKE_CURRENT_SOURCE_DIR}/gsettings_mocks.cpp
 		${CMAKE_CURRENT_SOURCE_DIR}/test_gsettings_tests.cpp
+		${CMAKE_CURRENT_SOURCE_DIR}/test_gsettings_wrapper.cpp
 		${CMAKE_CURRENT_SOURCE_DIR}/test_gsettings.cpp
-		${CMAKE_CURRENT_SOURCE_DIR}/gsettings_mocks.h
 		${CMAKE_CURRENT_SOURCE_DIR}/test_gsettings_tests.h)
 
 link_directories (${CMAKE_CURRENT_BINARY_DIR}/../../libcompizconfig/tests)
@@ -19,8 +29,25 @@
 target_link_libraries (compizconfig_test_gsettings
 		       gsettings_backend_shared
 		       compizconfig_ccs_setting_mock
+		       compizconfig_ccs_plugin_mock
+                       compizconfig_ccs_context_mock
+		       compizconfig_ccs_gsettings_backend_mock
+		       compizconfig_ccs_gsettings_wrapper_mock
 		       ${COMPIZCONFIG_TEST_GSETTINGS_LIBRARIES}
 		       ${GTEST_BOTH_LIBRARIES}
 		       ${GMOCK_MAIN_LIBRARY})
 
+add_custom_command (OUTPUT ${CMAKE_BINARY_DIR}/generated/glib-2.0/schemas/org.compiz.mock.gschema.xml
+		    COMMAND cp -r ${CMAKE_CURRENT_SOURCE_DIR}/org.compiz.mock.gschema.xml ${CMAKE_BINARY_DIR}/generated/glib-2.0/schemas/org.compiz.mock.gschema.xml
+		    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/org.compiz.mock.gschema.xml
+		    VERBATIM)
+
+add_custom_target (compiz_gsettings_mock_schema ALL
+		   DEPENDS ${CMAKE_BINARY_DIR}/generated/glib-2.0/schemas/org.compiz.mock.gschema.xml)
+
+add_gsettings_schema_to_recompilation_list (compiz_gsettings_mock_schema)
+
+configure_file (${CMAKE_CURRENT_SOURCE_DIR}/gsettings-mock-schemas-config.h.in
+		${CMAKE_CURRENT_BINARY_DIR}/gsettings-mock-schemas-config.h)
+
 compiz_discover_tests (compizconfig_test_gsettings COVERAGE gsettings_backend_shared)

=== added file 'compizconfig/gsettings/tests/ccs_gsettings_backend_mock.cpp'
--- compizconfig/gsettings/tests/ccs_gsettings_backend_mock.cpp	1970-01-01 00:00:00 +0000
+++ compizconfig/gsettings/tests/ccs_gsettings_backend_mock.cpp	2012-08-07 01:05:15 +0000
@@ -0,0 +1,61 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <ccs.h>
+
+#include "ccs_gsettings_backend_mock.h"
+
+CCSGSettingsBackendInterface ccsGSettingsBackendGMockInterface =
+{
+    CCSGSettingsBackendGMock::ccsGSettingsBackendGetContext,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendConnectToValueChangedSignal,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendGetSettingsObjectForPluginWithPath,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendRegisterGConfClient,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendUnregisterGConfClient,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendGetCurrentProfile,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendGetExistingProfiles,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendSetExistingProfiles,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendSetCurrentProfile,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendGetPluginsWithSetKeys,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendClearPluginsWithSetKeys,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendUnsetAllChangedPluginKeysInProfile,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendUpdateProfile,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendUpdateCurrentProfileName,
+    CCSGSettingsBackendGMock::ccsGSettingsBackendAddProfile
+};
+
+CCSBackend *
+ccsGSettingsBackendGMockNew ()
+{
+    CCSBackend *backend = (CCSBackend *) calloc (1, sizeof (CCSBackend));
+
+    if (!backend)
+	return NULL;
+
+    CCSGSettingsBackendGMock *gmock = new CCSGSettingsBackendGMock (backend);
+
+    if (!gmock)
+    {
+	free (backend);
+	return NULL;
+    }
+
+    ccsObjectInit (backend, &ccsDefaultObjectAllocator);
+    ccsObjectAddInterface (backend, (const CCSInterface *) &ccsGSettingsBackendGMockInterface, GET_INTERFACE_TYPE (CCSGSettingsBackendInterface));
+    ccsObjectSetPrivate (backend, reinterpret_cast <CCSPrivate *> (gmock));
+
+    return backend;
+}
+
+void
+ccsGSettingsBackendGMockFree (CCSBackend *backend)
+{
+    CCSGSettingsBackendGMock *mock = reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend));
+
+    delete mock;
+
+    ccsObjectSetPrivate (backend, NULL);
+    ccsObjectFinalize (backend);
+
+    free (backend);
+}

=== added file 'compizconfig/gsettings/tests/ccs_gsettings_backend_mock.h'
--- compizconfig/gsettings/tests/ccs_gsettings_backend_mock.h	1970-01-01 00:00:00 +0000
+++ compizconfig/gsettings/tests/ccs_gsettings_backend_mock.h	2012-08-07 01:05:15 +0000
@@ -0,0 +1,176 @@
+#ifndef _COMPIZCONFIG_CCS_GSETTINGS_BACKEND_MOCK
+#define _COMPIZCONFIG_CCS_GSETTINGS_BACKEND_MOCK
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <gsettings_shared.h>
+#include <ccs-backend.h>
+
+using ::testing::_;
+using ::testing::Return;
+
+CCSBackend * ccsGSettingsBackendGMockNew ();
+void ccsGSettingsBackendGMockFree (CCSBackend *backend);
+
+class CCSGSettingsBackendGMockInterface
+{
+    public:
+
+	virtual ~CCSGSettingsBackendGMockInterface () {}
+
+	virtual CCSContext * getContext () = 0;
+	virtual void connectToChangedSignal (CCSGSettingsWrapper *) = 0;
+	virtual CCSGSettingsWrapper * getSettingsObjectForPluginWithPath (const char * plugin,
+									  const char * path,
+									  CCSContext * context) = 0;
+	virtual void registerGConfClient () = 0;
+	virtual void unregisterGConfClient () = 0;
+	virtual const char * getCurrentProfile () = 0;
+	virtual GVariant * getExistingProfiles () = 0;
+	virtual void setExistingProfiles (GVariant *) = 0;
+	virtual void setCurrentProfile (const gchar *) = 0;
+	virtual GVariant * getPluginsWithSetKeys () = 0;
+	virtual void clearPluginsWithSetKeys () = 0;
+	virtual void unsetAllChangedPluginKeysInProfile (CCSContext *, GVariant *, const char *) = 0;
+	virtual gboolean updateProfile (CCSContext *) = 0;
+	virtual void updateCurrentProfileName (const char *) = 0;
+	virtual gboolean addProfile (const char *) = 0;
+};
+
+class CCSGSettingsBackendGMock :
+    public CCSGSettingsBackendGMockInterface
+{
+    public:
+
+	CCSGSettingsBackendGMock (CCSBackend *backend) :
+	    mBackend (backend)
+	{
+	}
+
+	MOCK_METHOD0 (getContext, CCSContext * ());
+	MOCK_METHOD1 (connectToChangedSignal, void (CCSGSettingsWrapper *));
+	MOCK_METHOD3 (getSettingsObjectForPluginWithPath, CCSGSettingsWrapper * (const char * plugin,
+										 const char * path,
+										 CCSContext * context));
+	MOCK_METHOD0 (registerGConfClient, void ());
+	MOCK_METHOD0 (unregisterGConfClient, void ());
+	MOCK_METHOD0 (getCurrentProfile, const char * ());
+	MOCK_METHOD0 (getExistingProfiles, GVariant * ());
+	MOCK_METHOD1 (setExistingProfiles, void (GVariant *));
+	MOCK_METHOD1 (setCurrentProfile, void (const gchar *));
+	MOCK_METHOD0 (getPluginsWithSetKeys, GVariant * ());
+	MOCK_METHOD0 (clearPluginsWithSetKeys, void ());
+	MOCK_METHOD3 (unsetAllChangedPluginKeysInProfile, void (CCSContext *, GVariant *, const char *));
+	MOCK_METHOD1 (updateProfile, gboolean (CCSContext *));
+	MOCK_METHOD1 (updateCurrentProfileName, void (const char *));
+	MOCK_METHOD1 (addProfile, gboolean (const char *));
+
+	CCSBackend * getBackend () { return mBackend; }
+
+    private:
+
+	CCSBackend *mBackend;
+
+    public:
+
+	static CCSContext *
+	ccsGSettingsBackendGetContext (CCSBackend *backend)
+	{
+	    return (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->getContext ();
+	}
+
+	static void
+	ccsGSettingsBackendConnectToValueChangedSignal (CCSBackend *backend, CCSGSettingsWrapper *object)
+	{
+	    (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->connectToChangedSignal(object);
+	}
+
+	static CCSGSettingsWrapper *
+	ccsGSettingsBackendGetSettingsObjectForPluginWithPath (CCSBackend *backend,
+							       const char *plugin,
+							       const char *path,
+							       CCSContext *context)
+	{
+	    return (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->getSettingsObjectForPluginWithPath (plugin,
+																	path,
+																	context);
+	}
+
+	static void
+	ccsGSettingsBackendRegisterGConfClient (CCSBackend *backend)
+	{
+	    (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->registerGConfClient ();
+	}
+
+	static void
+	ccsGSettingsBackendUnregisterGConfClient (CCSBackend *backend)
+	{
+	    (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->unregisterGConfClient ();
+	}
+
+	static const char *
+	ccsGSettingsBackendGetCurrentProfile (CCSBackend *backend)
+	{
+	    return (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->getCurrentProfile ();
+	}
+
+	static GVariant *
+	ccsGSettingsBackendGetExistingProfiles (CCSBackend *backend)
+	{
+	    return (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->getExistingProfiles ();
+	}
+
+	static void
+	ccsGSettingsBackendSetExistingProfiles (CCSBackend *backend, GVariant *value)
+	{
+	    (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->setExistingProfiles (value);
+	}
+
+	static void
+	ccsGSettingsBackendSetCurrentProfile (CCSBackend *backend, const gchar *value)
+	{
+	    (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->setCurrentProfile (value);
+	}
+
+	static GVariant *
+	ccsGSettingsBackendGetPluginsWithSetKeys (CCSBackend *backend)
+	{
+	    return (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->getPluginsWithSetKeys ();
+	}
+
+	static void
+	ccsGSettingsBackendClearPluginsWithSetKeys (CCSBackend *backend)
+	{
+	    return (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->clearPluginsWithSetKeys ();
+	}
+
+	static void
+	ccsGSettingsBackendUnsetAllChangedPluginKeysInProfile (CCSBackend *backend,
+							       CCSContext *context,
+							       GVariant   *pluginKeys,
+							       const char *profile)
+	{
+	    return (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->unsetAllChangedPluginKeysInProfile (context, pluginKeys, profile);
+	}
+
+	static gboolean
+	ccsGSettingsBackendUpdateProfile (CCSBackend *backend, CCSContext *context)
+	{
+	    return (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->updateProfile (context);
+	}
+
+	static void
+	ccsGSettingsBackendUpdateCurrentProfileName (CCSBackend *backend, const char *profile)
+	{
+	    return (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->updateCurrentProfileName (profile);
+	}
+
+	static gboolean
+	ccsGSettingsBackendAddProfile (CCSBackend *backend, const char *profile)
+	{
+	    return (reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend)))->addProfile (profile);
+	}
+};
+
+#endif

=== added file 'compizconfig/gsettings/tests/ccs_gsettings_wrapper_mock.cpp'
--- compizconfig/gsettings/tests/ccs_gsettings_wrapper_mock.cpp	1970-01-01 00:00:00 +0000
+++ compizconfig/gsettings/tests/ccs_gsettings_wrapper_mock.cpp	2012-08-07 01:05:15 +0000
@@ -0,0 +1,52 @@
+#include <ccs_gsettings_wrapper_mock.h>
+
+const CCSGSettingsWrapperInterface mockInterface =
+{
+    CCSGSettingsWrapperGMock::ccsGSettingsWrapperSetValue,
+    CCSGSettingsWrapperGMock::ccsGSettingsWrapperGetValue,
+    CCSGSettingsWrapperGMock::ccsGSettingsWrapperResetKey,
+    CCSGSettingsWrapperGMock::ccsGSettingsWrapperListKeys,
+    CCSGSettingsWrapperGMock::ccsGSettingsWrapperGetGSettings,
+    CCSGSettingsWrapperGMock::ccsGSettingsWrapperGetSchemaName,
+    CCSGSettingsWrapperGMock::ccsGSettingsWrapperGetPath,
+    CCSGSettingsWrapperGMock::ccsGSettingsWrapperConnectToChangedSignal,
+    CCSGSettingsWrapperGMock::ccsFreeGSettingsWrapper
+};
+
+CCSGSettingsWrapper *
+ccsMockGSettingsWrapperNew ()
+{
+    CCSGSettingsWrapper *wrapper = (CCSGSettingsWrapper *) calloc (1, sizeof (CCSGSettingsWrapper));
+
+    if (!wrapper)
+	return NULL;
+
+    CCSGSettingsWrapperGMock *gmockWrapper = new CCSGSettingsWrapperGMock (wrapper);
+
+    if (!gmockWrapper)
+    {
+	free (wrapper);
+	return NULL;
+    }
+
+    ccsObjectInit (wrapper, &ccsDefaultObjectAllocator);
+    ccsObjectAddInterface (wrapper, (const CCSInterface *) &mockInterface, GET_INTERFACE_TYPE (CCSGSettingsWrapperInterface));
+    ccsObjectSetPrivate (wrapper, (CCSPrivate *) gmockWrapper);
+
+    ccsGSettingsWrapperRef (wrapper);
+
+    return wrapper;
+}
+
+void
+ccsMockGSettingsWrapperFree (CCSGSettingsWrapper *wrapper)
+{
+    CCSGSettingsWrapperGMock *gmockWrapper = reinterpret_cast <CCSGSettingsWrapperGMock *> (ccsObjectGetPrivate (wrapper));
+
+    delete gmockWrapper;
+
+    ccsObjectSetPrivate (wrapper, NULL);
+    ccsObjectFinalize (wrapper);
+    free (wrapper);
+}
+    

=== added file 'compizconfig/gsettings/tests/ccs_gsettings_wrapper_mock.h'
--- compizconfig/gsettings/tests/ccs_gsettings_wrapper_mock.h	1970-01-01 00:00:00 +0000
+++ compizconfig/gsettings/tests/ccs_gsettings_wrapper_mock.h	2012-08-07 01:05:15 +0000
@@ -0,0 +1,113 @@
+#ifndef _COMPIZCONFIG_CCS_GSETTINGS_WRAPPER_MOCK
+#define _COMPIZCONFIG_CCS_GSETTINGS_WRAPPER_MOCK
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <ccs_gsettings_interface.h>
+
+CCSGSettingsWrapper * ccsMockGSettingsWrapperNew ();
+void ccsMockGSettingsWrapperFree (CCSGSettingsWrapper *);
+
+class CCSGSettingsWrapperMockInterface
+{
+    public:
+
+	virtual ~CCSGSettingsWrapperMockInterface () {}
+	virtual void setValue (const char *, GVariant *) = 0;
+	virtual GVariant * getValue (const char *) = 0;
+	virtual void resetKey (const char *) = 0;
+	virtual char ** listKeys () = 0;
+	virtual GSettings * getGSettings () = 0;
+	virtual const char * getSchemaName () = 0;
+	virtual const char * getPath () = 0;
+	virtual void connectToChangedSignal (GCallback, gpointer) = 0;
+};
+
+class CCSGSettingsWrapperGMock :
+    public CCSGSettingsWrapperMockInterface
+{
+    public:
+
+	CCSGSettingsWrapperGMock (CCSGSettingsWrapper *wrapper) :
+	    mWrapper (wrapper)
+	{
+	}
+
+	MOCK_METHOD2 (setValue, void (const char *, GVariant *));
+	MOCK_METHOD1 (getValue, GVariant * (const char *));
+	MOCK_METHOD1 (resetKey, void (const char *));
+	MOCK_METHOD0 (listKeys, char ** ());
+	MOCK_METHOD0 (getGSettings, GSettings * ());
+	MOCK_METHOD0 (getSchemaName, const char * ());
+	MOCK_METHOD0 (getPath, const char * ());
+	MOCK_METHOD2 (connectToChangedSignal, void (GCallback, gpointer));
+
+    private:
+
+	CCSGSettingsWrapper *mWrapper;
+
+    public:
+
+	static void
+	ccsGSettingsWrapperSetValue (CCSGSettingsWrapper *wrapper,
+				     const char *key,
+				     GVariant *value)
+	{
+	    reinterpret_cast <CCSGSettingsWrapperMockInterface *> (ccsObjectGetPrivate (wrapper))->setValue (key, value);
+	}
+
+	static GVariant *
+	ccsGSettingsWrapperGetValue (CCSGSettingsWrapper *wrapper,
+				     const char *key)
+	{
+	    return reinterpret_cast <CCSGSettingsWrapperMockInterface *> (ccsObjectGetPrivate (wrapper))->getValue (key);
+	}
+
+	static void
+	ccsGSettingsWrapperResetKey (CCSGSettingsWrapper *wrapper,
+				     const char *key)
+	{
+	    reinterpret_cast <CCSGSettingsWrapperMockInterface *> (ccsObjectGetPrivate (wrapper))->resetKey (key);
+	}
+
+	static char **
+	ccsGSettingsWrapperListKeys (CCSGSettingsWrapper *wrapper)
+	{
+	    return reinterpret_cast <CCSGSettingsWrapperMockInterface *> (ccsObjectGetPrivate (wrapper))->listKeys ();
+	}
+
+	static GSettings *
+	ccsGSettingsWrapperGetGSettings (CCSGSettingsWrapper *wrapper)
+	{
+	    return reinterpret_cast <CCSGSettingsWrapperMockInterface *> (ccsObjectGetPrivate (wrapper))->getGSettings ();
+	}
+
+	static const char *
+	ccsGSettingsWrapperGetSchemaName (CCSGSettingsWrapper *wrapper)
+	{
+	    return reinterpret_cast <CCSGSettingsWrapperMockInterface *> (ccsObjectGetPrivate (wrapper))->getSchemaName ();
+	}
+
+	static const char *
+	ccsGSettingsWrapperGetPath (CCSGSettingsWrapper *wrapper)
+	{
+	    return reinterpret_cast <CCSGSettingsWrapperMockInterface *> (ccsObjectGetPrivate (wrapper))->getPath ();
+	}
+
+	static void
+	ccsGSettingsWrapperConnectToChangedSignal (CCSGSettingsWrapper *wrapper,
+						   GCallback	       callback,
+						   gpointer	       data)
+	{
+	    reinterpret_cast <CCSGSettingsWrapperMockInterface *> (ccsObjectGetPrivate (wrapper))->connectToChangedSignal (callback, data);
+	}
+
+	static void
+	ccsFreeGSettingsWrapper (CCSGSettingsWrapper *wrapper)
+	{
+	    ccsMockGSettingsWrapperFree (wrapper);
+	}
+};
+
+#endif

=== added file 'compizconfig/gsettings/tests/gsettings-mock-schemas-config.h.in'
--- compizconfig/gsettings/tests/gsettings-mock-schemas-config.h.in	1970-01-01 00:00:00 +0000
+++ compizconfig/gsettings/tests/gsettings-mock-schemas-config.h.in	2012-08-07 01:05:15 +0000
@@ -0,0 +1,7 @@
+#define MOCK_SCHEMA_PATH "@CMAKE_BINARY_DIR@/generated/glib-2.0/schemas"
+
+namespace
+{
+const std::string MOCK_SCHEMA ("org.compiz.mock");
+const std::string MOCK_PATH (MOCK_SCHEMA_PATH);
+}

=== removed file 'compizconfig/gsettings/tests/gsettings_mocks.cpp'
--- compizconfig/gsettings/tests/gsettings_mocks.cpp	2012-07-06 04:53:09 +0000
+++ compizconfig/gsettings/tests/gsettings_mocks.cpp	1970-01-01 00:00:00 +0000
@@ -1,200 +0,0 @@
-#include <gsettings_mocks.h>
-
-static void compizconfig_gsettings_wrap_gsettings_default_init (CCSGSettingsWrapGSettingsInterface *interface);
-
-G_DEFINE_INTERFACE (CCSGSettingsWrapGSettings, compizconfig_gsettings_wrap_gsettings, G_TYPE_OBJECT)
-
-static void compizconfig_gsettings_wrap_gsettings_default_init (CCSGSettingsWrapGSettingsInterface *klass)
-{
-    g_object_interface_install_property (klass,
-					 g_param_spec_string ("schema",
-							      "schema",
-							      "Schema Name",
-							      "invalid.invalid",
-							      static_cast <GParamFlags> (G_PARAM_CONSTRUCT_ONLY |
-											 G_PARAM_WRITABLE |
-											 G_PARAM_READABLE)));
-}
-
-CCSGSettingsWrapGSettings *
-compizconfig_gsettings_wrap_gsettings_new (GType type, const gchar *name)
-{
-    GValue name_v = G_VALUE_INIT;
-
-    g_value_init (&name_v, G_TYPE_STRING);
-
-    g_value_set_string (&name_v, name);
-
-    GParameter param[1] =
-    {
-	{ "schema", name_v }
-    };
-
-    CCSGSettingsWrapGSettings *wrap_gsettings = COMPIZCONFIG_GSETTINGS_WRAP_GSETTINGS (g_object_newv (type, 1, param));
-
-    g_value_unset (&name_v);
-
-    return wrap_gsettings;
-}
-
-G_BEGIN_DECLS
-
-#define COMPIZCONFIG_GSETTINGS_MOCK_WRAP_GSETTINGS(obj) \
-  (G_TYPE_CHECK_INSTANCE_CAST ((obj), COMPIZCONFIG_GSETTINGS_TYPE_MOCK_WRAP_GSETTINGS, CCSGSettingsMockWrapGSettings))
-
-#define COMPIZCONFIG_GSETTINGS_TYPE_MOCK_GSETTINGS_CONCRETE_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_CAST ((klass), COMPIZCONFIG_GSETTINGS_TYPE_MOCK_WRAP_GSETTINGS, CCSGSettingsMockWrapGSettingsClass))
-
-#define COMPIZCONFIG_GSETTINGS_IS_MOCK_WRAP_GSETTINGS(obj) \
-  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), COMPIZCONFIG_GSETTINGS_TYPE_MOCK_WRAP_GSETTINGS)
-
-#define COMPIZCONFIG_GSETTINGS_IS_MOCK_WRAP_GSETTINGS_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_TYPE ((klass), COMPIZCONFIG_GSETTINGS_TYPE_MOCK_WRAP_GSETTINGS))
-
-#define COMPIZCONFIG_GSETTINGS_TYPE_MOCK_GSETTINGS_CONCRETE_GET_CLASS(obj) \
-  (G_TYPE_INSTANCE_GET_CLASS ((obj), COMPIZCONFIG_GSETTINGS_TYPE_MOCK_WRAP_GSETTINGS, CCSGSettingsMockWrapGSettingsClass))
-
-typedef struct {
-  GObject parent;
-} CCSGSettingsMockWrapGSettings;
-
-typedef struct {
-  GObjectClass parent_class;
-} CCSGSettingsMockWrapGSettingsClass;
-
-G_END_DECLS
-
-static void compizconfig_gsettings_mock_wrap_gsettings_interface_init (CCSGSettingsWrapGSettingsInterface *interface);
-
-G_DEFINE_TYPE_WITH_CODE (CCSGSettingsMockWrapGSettings, compizconfig_gsettings_mock_wrap_gsettings, G_TYPE_OBJECT,
-			 G_IMPLEMENT_INTERFACE (COMPIZCONFIG_GSETTINGS_TYPE_WRAP_GSETTINGS,
-						compizconfig_gsettings_mock_wrap_gsettings_interface_init))
-
-#define GET_PRIVATE(o) \
-  (G_TYPE_INSTANCE_GET_PRIVATE ((o), COMPIZCONFIG_GSETTINGS_TYPE_MOCK_WRAP_GSETTINGS, CCSGSettingsMockWrapGSettingsPrivate))
-
-typedef struct _CCSGSettingsMockWrapGSettingsPrivate CCSGSettingsMockWrapGSettingsPrivate;
-
-struct _CCSGSettingsMockWrapGSettingsPrivate
-{
-    gchar *name;
-};
-
-static void
-compizconfig_gsettings_mock_wrap_gsettings_dispose (GObject *object)
-{
-    CCSGSettingsMockWrapGSettingsPrivate *priv = GET_PRIVATE (object);
-    G_OBJECT_CLASS (compizconfig_gsettings_mock_wrap_gsettings_parent_class)->dispose (object);
-
-    if (priv->name)
-	g_free (priv->name);
-
-    priv->name = NULL;
-}
-
-static void
-compizconfig_gsettings_mock_wrap_gsettings_finalize (GObject *object)
-{
-    G_OBJECT_CLASS (compizconfig_gsettings_mock_wrap_gsettings_parent_class)->finalize (object);
-}
-
-static void
-compizconfig_gsettings_mock_wrap_gsettings_interface_init (CCSGSettingsWrapGSettingsInterface *interface)
-{
-}
-
-static void
-compizconfig_gsettings_mock_wrap_gsettings_set_property (GObject *object,
-							 guint   property_id,
-							 const   GValue *value,
-							 GParamSpec *pspec)
-{
-    CCSGSettingsMockWrapGSettingsPrivate *priv = GET_PRIVATE (object);
-
-    switch (property_id)
-    {
-	case COMPIZCONFIG_GSETTINGS_WRAP_GSETTINGS_PROPERTY_SCHEMA_NAME:
-	    if (priv->name)
-		g_free (priv->name);
-
-	    priv->name = g_value_dup_string (value);
-	    break;
-	default:
-	    g_assert_not_reached ();
-	    break;
-    }
-}
-
-static void
-compizconfig_gsettings_mock_wrap_gsettings_get_property (GObject *object,
-							 guint   property_id,
-							 GValue  *value,
-							 GParamSpec *pspec)
-{
-    CCSGSettingsMockWrapGSettingsPrivate *priv = GET_PRIVATE (object);
-
-    switch (property_id)
-    {
-	case COMPIZCONFIG_GSETTINGS_WRAP_GSETTINGS_PROPERTY_SCHEMA_NAME:
-	    g_value_set_string (value, priv->name);
-	    break;
-	default:
-	    g_assert_not_reached ();
-	    break;
-    }
-}
-
-static GObject *
-compizconfig_gsettings_mock_wrap_gsettings_constructor (GType		      type,
-							guint		      n_construct_properties,
-							GObjectConstructParam *construction_properties)
-{
-    GObject *object;
-    CCSGSettingsMockWrapGSettingsPrivate *priv;
-
-    {
-	object = G_OBJECT_CLASS (compizconfig_gsettings_mock_wrap_gsettings_parent_class)->constructor (type,
-													n_construct_properties,
-													construction_properties);
-    }
-
-    priv = GET_PRIVATE (object);
-
-    for (guint i = 0; i < n_construct_properties; i++)
-    {
-	if (g_strcmp0 (construction_properties[i].pspec->name, "schema") == 0)
-	{
-	    if (!priv->name)
-		priv->name = g_value_dup_string (construction_properties[i].value);
-	}
-	else
-	{
-	    g_assert_not_reached ();
-	}
-    }
-
-    return object;
-}
-
-static void
-compizconfig_gsettings_mock_wrap_gsettings_class_init (CCSGSettingsMockWrapGSettingsClass *klass)
-{
-    GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-    g_type_class_add_private (klass, sizeof (CCSGSettingsMockWrapGSettingsPrivate));
-
-    object_class->dispose = compizconfig_gsettings_mock_wrap_gsettings_dispose;
-    object_class->finalize = compizconfig_gsettings_mock_wrap_gsettings_finalize;
-    object_class->set_property = compizconfig_gsettings_mock_wrap_gsettings_set_property;
-    object_class->get_property = compizconfig_gsettings_mock_wrap_gsettings_get_property;
-    object_class->constructor = compizconfig_gsettings_mock_wrap_gsettings_constructor;
-
-    g_object_class_override_property (G_OBJECT_CLASS (klass),
-				      COMPIZCONFIG_GSETTINGS_WRAP_GSETTINGS_PROPERTY_SCHEMA_NAME,
-				      "schema");
-}
-
-static void
-compizconfig_gsettings_mock_wrap_gsettings_init (CCSGSettingsMockWrapGSettings *self)
-{
-}

=== removed file 'compizconfig/gsettings/tests/gsettings_mocks.h'
--- compizconfig/gsettings/tests/gsettings_mocks.h	2012-08-07 01:05:13 +0000
+++ compizconfig/gsettings/tests/gsettings_mocks.h	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-#ifndef _COMPIZ_COMPIZCONFIG_GSETTINGS_MOCKS
-#define _COMPIZ_COMPIZCONFIG_GSETTINGS_MOCKS
-
-#include <glib-object.h>
-#include <compizconfig_ccs_setting_mock.h>
-
-G_BEGIN_DECLS
-
-#define COMPIZCONFIG_GSETTINGS_WRAP_GSETTINGS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), COMPIZCONFIG_GSETTINGS_TYPE_WRAP_GSETTINGS, CCSGSettingsWrapGSettings))
-
-#define COMPIZCONFIG_GSETTINGS_WRAP_GSETTINGS_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), COMPIZCONFIG_GSETTINGS_TYPE_WRAP_GSETTINGS, CCSGSettingsWrapGSettingsInterface))
-
-#define COMPIZCONFIG_GSETTINGS_TYPE_WRAP_GSETTINGS (compizconfig_gsettings_wrap_gsettings_get_type())
-
-GType compizconfig_gsettings_wrap_gsettings_get_type (void);
-
-typedef struct _CCSGSettingsWrapGSettings CCSGSettingsWrapGSettings; /* dummy typedef */
-typedef struct _CCSGSettingsWrapGSettingsInterface CCSGSettingsWrapGSettingsInterface;
-
-struct _CCSGSettingsWrapGSettingsInterface {
-  GTypeInterface parent;
-
-};
-
-enum
-{
-    COMPIZCONFIG_GSETTINGS_WRAP_GSETTINGS_PROPERTY_SCHEMA_NAME = 1,
-    COMPIZCONFIG_GSETTINGS_WRAP_GSETTINGS_PROPERTY_NUM = 2
-};
-
-#define COMPIZCONFIG_GSETTINGS_TYPE_MOCK_WRAP_GSETTINGS (compizconfig_gsettings_mock_wrap_gsettings_get_type ())
-
-GType compizconfig_gsettings_mock_wrap_gsettings_get_type ();
-
-/**
- * compizconfig_gsettings_wrap_gsettings_new:
- * @type: (in) (transfer none): a GType of the object type to be created
- * @name: (in) (transfer none): schema name
- * Return value: (transfer full): a new CCSGSettingsWrapGSettings
- */
-CCSGSettingsWrapGSettings * compizconfig_gsettings_wrap_gsettings_new (GType type, const gchar *name);
-
-G_END_DECLS
-
-#endif

=== added file 'compizconfig/gsettings/tests/org.compiz.mock.gschema.xml'
--- compizconfig/gsettings/tests/org.compiz.mock.gschema.xml	1970-01-01 00:00:00 +0000
+++ compizconfig/gsettings/tests/org.compiz.mock.gschema.xml	2012-08-07 01:05:15 +0000
@@ -0,0 +1,53 @@
+<?xml version="1.0"?>
+<schemalist>
+  <schema id="org.compiz.mock" gettext-domain="compiz">
+    <key type="i" name="integer-setting">
+      <default>0</default>
+    </key>
+    <key type="b" name="boolean-setting">
+      <default>false</default>
+    </key>
+    <key type="d" name="float-setting">
+      <default>0.0</default>
+    </key>
+    <key type="s" name="string-setting">
+      <default>""</default>
+    </key>
+    <key type="s" name="match-setting">
+      <default>""</default>
+    </key>
+    <key type="b" name="bell-setting">
+      <default>false</default>
+    </key>
+    <key type="s" name="color-setting">
+      <default>""</default>
+    </key>
+    <key type="s" name="key-setting">
+      <default>""</default>
+    </key>
+    <key type="s" name="button-setting">
+      <default>""</default>
+    </key>
+    <key type="s" name="edge-setting">
+      <default>""</default>
+    </key>
+    <key type="ai" name="int-list-setting">
+      <default>[0]</default>
+    </key>
+    <key type="ad" name="float-list-setting">
+      <default>[0.0]</default>
+    </key>
+    <key type="ab" name="bool-list-setting">
+      <default>[true]</default>
+    </key>
+    <key type="as" name="string-list-setting">
+      <default>[""]</default>
+    </key>
+    <key type="as" name="match-list-setting">
+      <default>[""]</default>
+    </key>
+    <key type="as" name="color-list-setting">
+      <default>[""]</default>
+    </key>
+  </schema>
+</schemalist>

=== modified file 'compizconfig/gsettings/tests/test_gsettings_tests.cpp'
--- compizconfig/gsettings/tests/test_gsettings_tests.cpp	2012-07-10 10:35:16 +0000
+++ compizconfig/gsettings/tests/test_gsettings_tests.cpp	2012-08-07 01:05:15 +0000
@@ -1,13 +1,114 @@
 #include <boost/function.hpp>
 #include <boost/bind.hpp>
 
+#include <boost/shared_ptr.hpp>
+#include <boost/scoped_array.hpp>
+
 #include "test_gsettings_tests.h"
 #include "gsettings.h"
-#include "gsettings_mocks.h"
+#include "ccs_gsettings_backend_mock.h"
+#include "compizconfig_ccs_context_mock.h"
+#include "compizconfig_ccs_plugin_mock.h"
+#include "compizconfig_ccs_setting_mock.h"
+#include "gtest_shared_characterwrapper.h"
+#include "compizconfig_test_value_combiners.h"
+#include "compizconfig_ccs_mocked_allocator.h"
+#include "ccs_gsettings_wrapper_mock.h"
 
 using ::testing::Values;
 using ::testing::ValuesIn;
 using ::testing::Return;
+using ::testing::ReturnNull;
+using ::testing::Invoke;
+using ::testing::WithArgs;
+using ::testing::MatcherInterface;
+using ::testing::MatchResultListener;
+using ::testing::AllOf;
+using ::testing::Not;
+using ::testing::Matcher;
+using ::testing::Eq;
+using ::testing::NiceMock;
+using ::testing::StrictMock;
+using ::testing::IsNull;
+
+class GVariantSubtypeMatcher :
+    public ::testing::MatcherInterface<GVariant *>
+{
+    public:
+	GVariantSubtypeMatcher (const std::string &type) :
+	    mType (type)
+	{
+	}
+
+	virtual ~GVariantSubtypeMatcher () {}
+	virtual bool MatchAndExplain (GVariant *x, MatchResultListener *listener) const
+	{
+	    return g_variant_type_is_subtype_of (G_VARIANT_TYPE (mType.c_str ()), g_variant_get_type (x));
+	}
+
+	virtual void DescribeTo (std::ostream *os) const
+	{
+	    *os << "is subtype of " << mType;
+	}
+    private:
+
+	std::string mType;
+};
+
+template <typename T>
+class GVariantHasValueInArrayMatcher :
+    public ::testing::MatcherInterface<GVariant *>
+{
+    public:
+	GVariantHasValueInArrayMatcher (const std::string &type,
+					const T &t,
+					const boost::function <bool (T const&, T const&)> &eq) :
+	    mType (type),
+	    mT (t),
+	    mEq (eq)
+	{
+	}
+
+	virtual ~GVariantHasValueInArrayMatcher () {}
+	virtual bool MatchAndExplain (GVariant *x, MatchResultListener *listener) const
+	{
+	    GVariantIter iter;
+	    T            match;
+	    bool         found = false;
+
+	    g_variant_iter_init (&iter, x);
+	    while (g_variant_iter_loop (&iter, mType.c_str (), &match))
+	    {
+		if (mEq (match, mT))
+		    found = true;
+	    }
+
+	    return found;
+	}
+
+	virtual void DescribeTo (std::ostream *os) const
+	{
+	    *os << "contains " << mT;
+	}
+    private:
+
+	std::string mType;
+	T           mT;
+	boost::function <bool (T const&, T const&)> mEq;
+};
+
+template <typename T>
+inline Matcher<GVariant *> GVariantHasValueInArray (const std::string &type,
+						    const T &t,
+						    const boost::function <bool (T const &, T const &)> &eq)
+{
+    return MakeMatcher (new GVariantHasValueInArrayMatcher<T> (type, t, eq));
+}
+
+inline Matcher<GVariant *> IsVariantSubtypeOf (const std::string &type)
+{
+    return MakeMatcher (new GVariantSubtypeMatcher (type));
+}
 
 TEST_P(CCSGSettingsTest, TestTestFixtures)
 {
@@ -17,6 +118,115 @@
 {
 }
 
+namespace
+{
+bool streq (const char * const &s1, const char * const &s2)
+{
+    return g_str_equal (s1, s2);
+}
+
+}
+
+class CCSGSettingsTestProfiles :
+    public CCSGSettingsTestIndependent
+{
+    public:
+
+	static const std::string newProfileName;
+	static const std::string existingProfileName;
+};
+
+const std::string CCSGSettingsTestProfiles::existingProfileName ("ExistingProfile");
+const std::string CCSGSettingsTestProfiles::newProfileName ("NewProfile");
+
+TEST_F(CCSGSettingsTestProfiles, TestAddProfile)
+{
+    boost::shared_ptr <CCSBackend> backend (ccsGSettingsBackendGMockNew (),
+					    boost::bind (ccsGSettingsBackendGMockFree, _1));
+    CCSGSettingsBackendGMock *gmock = reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend.get ()));
+
+    GVariantBuilder builder;
+
+    g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));
+    g_variant_builder_add (&builder, "s", existingProfileName.c_str ());
+
+    GVariant *existingProfiles = g_variant_builder_end (&builder);
+
+    EXPECT_CALL (*gmock, getExistingProfiles ()).WillOnce (Return (existingProfiles));
+    EXPECT_CALL (*gmock, setExistingProfiles (AllOf (IsVariantSubtypeOf ("as"),
+						     GVariantHasValueInArray<const gchar *> ("s",
+											     newProfileName.c_str (),
+											     boost::bind (streq, _1, _2)))))
+	    .WillOnce (WithArgs <0> (Invoke (g_variant_unref)));
+
+    ccsGSettingsBackendAddProfileDefault (backend.get (), newProfileName.c_str ());
+}
+
+TEST_F(CCSGSettingsTestProfiles, TestUpdateCurrentProfileNameAppendNew)
+{
+    boost::shared_ptr <CCSBackend> backend (ccsGSettingsBackendGMockNew (),
+					    boost::bind (ccsGSettingsBackendGMockFree, _1));
+    CCSGSettingsBackendGMock *gmock = reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend.get ()));
+
+    EXPECT_CALL (*gmock, addProfile (Eq (newProfileName)));
+    EXPECT_CALL (*gmock, setCurrentProfile (Eq (newProfileName)));
+
+    ccsGSettingsBackendUpdateCurrentProfileNameDefault (backend.get (), newProfileName.c_str ());
+}
+
+TEST_F(CCSGSettingsTestProfiles, TestUpdateCurrentProfileNameExisting)
+{
+    boost::shared_ptr <CCSBackend> backend (ccsGSettingsBackendGMockNew (),
+					    boost::bind (ccsGSettingsBackendGMockFree, _1));
+    CCSGSettingsBackendGMock *gmock = reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend.get ()));
+
+    EXPECT_CALL (*gmock, addProfile (Eq (existingProfileName)));
+    EXPECT_CALL (*gmock, setCurrentProfile (Eq (existingProfileName)));
+
+    ccsGSettingsBackendUpdateCurrentProfileNameDefault (backend.get (), existingProfileName.c_str ());
+}
+
+TEST_F(CCSGSettingsTestProfiles, TestDeleteProfileExistingProfile)
+{
+    boost::shared_ptr <CCSBackend> backend (ccsGSettingsBackendGMockNew (),
+					    boost::bind (ccsGSettingsBackendGMockFree, _1));
+    boost::shared_ptr <CCSContext> context (ccsMockContextNew (),
+					    boost::bind (ccsFreeMockContext, _1));
+
+    CCSGSettingsBackendGMock *mockBackend = reinterpret_cast <CCSGSettingsBackendGMock *> (ccsObjectGetPrivate (backend.get ()));
+
+    std::string currentProfile ("foo");
+    std::string otherProfile ("other");
+
+    GVariant *existingProfiles = NULL;
+    GVariantBuilder existingProfilesBuilder;
+
+    g_variant_builder_init (&existingProfilesBuilder, G_VARIANT_TYPE ("as"));
+    g_variant_builder_add (&existingProfilesBuilder, "s", currentProfile.c_str ());
+    g_variant_builder_add (&existingProfilesBuilder, "s", otherProfile.c_str ());
+
+    existingProfiles = g_variant_builder_end (&existingProfilesBuilder);
+
+    EXPECT_CALL (*mockBackend, getPluginsWithSetKeys ()).WillOnce (ReturnNull ());
+    EXPECT_CALL (*mockBackend, unsetAllChangedPluginKeysInProfile (context.get (), NULL, Eq (currentProfile)));
+    EXPECT_CALL (*mockBackend, clearPluginsWithSetKeys ());
+
+    EXPECT_CALL (*mockBackend, getCurrentProfile ()).WillOnce (Return (currentProfile.c_str ()));
+    EXPECT_CALL (*mockBackend, getExistingProfiles ()).WillOnce (Return (existingProfiles));
+    EXPECT_CALL (*mockBackend, setExistingProfiles (AllOf (IsVariantSubtypeOf ("as"),
+							   Not (GVariantHasValueInArray<const gchar *> ("s",
+													currentProfile.c_str (),
+													boost::bind (streq, _1, _2))),
+							   GVariantHasValueInArray<const gchar *> ("s",
+												   otherProfile.c_str (),
+												   boost::bind (streq, _1, _2)))))
+	    .WillOnce (WithArgs <0> (Invoke (g_variant_unref)));
+
+    EXPECT_CALL (*mockBackend, updateProfile (context.get ()));
+
+    deleteProfile (backend.get (), context.get (), currentProfile.c_str ());
+}
+
 TEST_F(CCSGSettingsTestIndependent, TestGetSchemaNameForPlugin)
 {
     const gchar *plugin = "foo";
@@ -88,6 +298,32 @@
     EXPECT_EQ (std::string (keyname), "plugin-option");
 }
 
+TEST_F(CCSGSettingsTestIndependent, TestTranslateKeyForGSettingsNoTrunc)
+{
+    std::string keyname ("FoO_BaR");
+    std::string expected ("foo-bar");
+
+    CharacterWrapper translated (translateKeyForGSettings (keyname.c_str ()));
+
+    EXPECT_EQ (std::string (translated), expected);
+}
+
+TEST_F(CCSGSettingsTestIndependent, TestTranslateKeyForGSettingsTrunc)
+{
+    const unsigned int OVER_KEY_SIZE = MAX_GSETTINGS_KEY_SIZE + 1;
+    std::string keyname;
+
+    for (unsigned int i = 0; i <= OVER_KEY_SIZE - 1; i++)
+	keyname.push_back ('a');
+
+    ASSERT_EQ (keyname.size (), OVER_KEY_SIZE);
+
+    CharacterWrapper translated (translateKeyForGSettings (keyname.c_str ()));
+    std::string      stringOfTranslated (translated);
+
+    EXPECT_EQ (stringOfTranslated.size (), MAX_GSETTINGS_KEY_SIZE);
+}
+
 TEST_F(CCSGSettingsTestIndependent, TestTranslateKeyForCCS)
 {
     std::string keyname ("plugin-option");
@@ -165,6 +401,22 @@
     g_free (pluginName);
 }
 
+TEST_F(CCSGSettingsTestIndependent, TestDecomposeGSettingsPathBadPathname)
+{
+    std::string compiz_gsettings_path ("org/this/path/is/wrong/");
+    std::string fake_option_path ("PROFILENAME/plugins/PLUGINNAME");
+
+    compiz_gsettings_path += fake_option_path;
+
+    CharacterWrapper pluginName (strdup ("aaa"));
+    char             *pluginNameC = pluginName;
+    unsigned int screenNum = 1;
+
+    EXPECT_FALSE (decomposeGSettingsPath (compiz_gsettings_path.c_str (), &pluginNameC, &screenNum));
+    EXPECT_EQ (std::string (pluginNameC), "aaa");
+    EXPECT_EQ (screenNum, 1);
+}
+
 TEST_F(CCSGSettingsTestIndependent, TestMakeCompizProfilePath)
 {
     gchar *a = makeCompizProfilePath ("alpha");
@@ -259,6 +511,11 @@
     {
 	return g_variant_type_is_array (g_variant_get_type (v));
     }
+
+    gboolean unknown (GVariant *)
+    {
+	return FALSE;
+    }
 }
 
 struct ArrayVariantInfo
@@ -275,6 +532,7 @@
     const char *vInt = "i";
     const char *vDouble = "d";
     const char *vArray = "as";
+    const char *vUnknown = "";
 
     ArrayVariantInfo arrayVariantInfo[] =
     {
@@ -288,7 +546,8 @@
 	{ &GVariantSubtypeWrappers::edge, TypeEdge, vString },
 	{ &GVariantSubtypeWrappers::integer, TypeInt, vInt },
 	{ &GVariantSubtypeWrappers::doubleprecision, TypeFloat, vDouble },
-	{ &GVariantSubtypeWrappers::list, TypeList, vArray }
+	{ &GVariantSubtypeWrappers::list, TypeList, vArray },
+	{ &GVariantSubtypeWrappers::unknown, TypeNum, vUnknown }
     };
 }
 
@@ -365,6 +624,7 @@
 
 	virtual void SetUp ()
 	{
+	    CCSGSettingsTestIndependent::SetUp ();
 	    builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
 
 	    g_variant_builder_add (builder, "s", "foo");
@@ -382,6 +642,7 @@
 	{
 	    g_variant_unref (writtenPlugins);
 	    g_strfreev (newWrittenPlugins);
+	    CCSGSettingsTestIndependent::TearDown ();
 	}
 
     protected:
@@ -418,58 +679,72 @@
     EXPECT_EQ (std::string (newWrittenPlugins[1]), std::string ("bar"));
 }
 
-class CCSGSettingsTestGObjectListWithProperty :
+class CCSGSettingsTestGSettingsWrapperWithSchemaName :
     public CCSGSettingsTestIndependent
 {
     public:
 
-	virtual void SetUp ()
-	{
-	    g_type_init ();
-
-	    objectSchemaList = NULL;
-	}
-
-	virtual void TearDown ()
-	{
-	    GList *iter = objectSchemaList;
-
-	    while (iter)
-	    {
-		g_object_unref ((GObject *) iter->data);
-		iter = g_list_next (iter);
-	    }
-
-	    g_list_free (objectSchemaList);
-	    objectSchemaList = NULL;
-	}
-
-	CCSGSettingsWrapGSettings * AddObjectWithSchemaName (const std::string &schemaName)
-	{
-	    CCSGSettingsWrapGSettings *wrapGSettingsObject =
-		    compizconfig_gsettings_wrap_gsettings_new (COMPIZCONFIG_GSETTINGS_TYPE_MOCK_WRAP_GSETTINGS, schemaName.c_str ());
-	    objectSchemaList = g_list_append (objectSchemaList, wrapGSettingsObject);
-
-	    return wrapGSettingsObject;
-	}
+	typedef std::tr1::tuple <boost::shared_ptr <CCSGSettingsWrapper>, CCSGSettingsWrapperGMock *> WrapperMock;
+
+	CCSGSettingsTestGSettingsWrapperWithSchemaName () :
+	    objectSchemaGList (NULL)
+	{
+	    CCSGSettingsTestIndependent::SetUp ();
+	}
+
+	~CCSGSettingsTestGSettingsWrapperWithSchemaName ()
+	{
+	    g_list_free (objectSchemaGList);
+	    CCSGSettingsTestIndependent::TearDown ();
+	}
+
+	WrapperMock
+	AddObject ()
+	{
+	    boost::shared_ptr <CCSGSettingsWrapper> wrapper (ccsMockGSettingsWrapperNew (),
+							     boost::bind (ccsGSettingsWrapperUnref, _1));
+	    CCSGSettingsWrapperGMock			  *gmockWrapper = reinterpret_cast <CCSGSettingsWrapperGMock *> (ccsObjectGetPrivate (wrapper.get ()));
+
+	    objectSchemaGList = g_list_append (objectSchemaGList, wrapper.get ());
+	    objectSchemaList.push_back (wrapper);
+
+	    return WrapperMock (wrapper, gmockWrapper);
+	}
+
+	static const std::string VALUE_FOO;
+	static const std::string VALUE_BAR;
+	static const std::string VALUE_BAZ;
 
     protected:
 
-	GList *objectSchemaList;
+	GList						       *objectSchemaGList;
+	std::vector <boost::shared_ptr <CCSGSettingsWrapper> > objectSchemaList;
 };
 
-TEST_F(CCSGSettingsTestGObjectListWithProperty, TestFindExistingObjectWithSchema)
+const std::string CCSGSettingsTestGSettingsWrapperWithSchemaName::VALUE_FOO = "foo";
+const std::string CCSGSettingsTestGSettingsWrapperWithSchemaName::VALUE_BAR = "bar";
+const std::string CCSGSettingsTestGSettingsWrapperWithSchemaName::VALUE_BAZ = "baz";
+
+TEST_F(CCSGSettingsTestGSettingsWrapperWithSchemaName, TestFindExistingObjectWithSchema)
 {
-    GObject *obj = reinterpret_cast <GObject *> (AddObjectWithSchemaName ("foo"));
-
-    EXPECT_EQ (findObjectInListWithPropertySchemaName ("foo", objectSchemaList), obj);
+    WrapperMock wr1 (AddObject ());
+    WrapperMock wr2 (AddObject ());
+
+    EXPECT_CALL (*(std::tr1::get <1> (wr1)), getSchemaName ()).WillRepeatedly (Return (VALUE_BAR.c_str ()));
+    EXPECT_CALL (*(std::tr1::get <1> (wr2)), getSchemaName ()).WillRepeatedly (Return (VALUE_FOO.c_str ()));
+
+    EXPECT_EQ (findCCSGSettingsWrapperBySchemaName (VALUE_FOO.c_str (), objectSchemaGList), (std::tr1::get <0> (wr2)).get ());
 }
 
-TEST_F(CCSGSettingsTestGObjectListWithProperty, TestNoFindNonexistingObjectWithSchema)
+TEST_F(CCSGSettingsTestGSettingsWrapperWithSchemaName, TestNoFindNonexistingObjectWithSchema)
 {
-    AddObjectWithSchemaName ("bar");
-
-    EXPECT_EQ (NULL, findObjectInListWithPropertySchemaName ("foo", objectSchemaList));
+    WrapperMock wr1 (AddObject ());
+    WrapperMock wr2 (AddObject ());
+
+    EXPECT_CALL (*(std::tr1::get <1> (wr1)), getSchemaName ()).WillRepeatedly (Return (VALUE_BAR.c_str ()));
+    EXPECT_CALL (*(std::tr1::get <1> (wr2)), getSchemaName ()).WillRepeatedly (Return (VALUE_BAZ.c_str ()));
+
+    EXPECT_THAT (findCCSGSettingsWrapperBySchemaName (VALUE_FOO.c_str (), objectSchemaGList), IsNull ());
 }
 
 class CCSGSettingsTestFindSettingLossy :
@@ -479,6 +754,7 @@
 
 	virtual void SetUp ()
 	{
+	    CCSGSettingsTestIndependent::SetUp ();
 	    settingList = NULL;
 	}
 
@@ -486,6 +762,7 @@
 	{
 	    ccsSettingListFree (settingList, TRUE);
 	    settingList = NULL;
+	    CCSGSettingsTestIndependent::TearDown ();
 	}
 
 	CCSSetting * AddMockSettingWithNameAndType (char	      *name,
@@ -726,14 +1003,18 @@
 
 	    typedef boost::function <GList * (void)> PopulateFunc;
 
-	    GListContainerEqualityBase (const PopulateFunc &populateGList) :
-		mList (populateGList ())
+	    GListContainerEqualityBase (const PopulateFunc &populateGList)
 	    {
+		g_setenv ("G_SLICE", "always-malloc", 1);
+		mList = populateGList ();
+		g_unsetenv ("G_SLICE");
 	    }
 
-	    GListContainerEqualityBase (const GListContainerEqualityBase &other) :
-		mList (g_list_copy (other.mList))
+	    GListContainerEqualityBase (const GListContainerEqualityBase &other)
 	    {
+		g_setenv ("G_SLICE", "always-malloc", 1);
+		mList = g_list_copy (other.mList);
+		g_unsetenv ("G_SLICE");
 	    }
 
 	    GListContainerEqualityBase &
@@ -869,3 +1150,872 @@
 
 INSTANTIATE_TEST_CASE_P(CCSGSettingsTestVariantTypeToCCSTypeListInstantiation, CCSGSettingsTestVariantTypeToCCSTypeListFixture,
 			ValuesIn (variantTypeToListOfCCSTypes));
+
+TEST_F(CCSGSettingsTestIndependent, TestGetNameForCCSSetting)
+{
+    CCSSetting *setting = ccsMockSettingNew ();
+    CCSSettingGMock *gmock = (CCSSettingGMock *) ccsObjectGetPrivate (setting);
+    char *rawSettingName = strdup ("FoO_BaR");
+    char *properSettingName = translateKeyForGSettings (rawSettingName);
+
+    EXPECT_CALL (*gmock, getName ()).WillOnce (Return (rawSettingName));
+
+    char *translatedSettingName = getNameForCCSSetting (setting);
+
+    EXPECT_EQ (std::string (translatedSettingName), std::string (properSettingName));
+    EXPECT_NE (std::string (translatedSettingName), std::string (rawSettingName));
+
+    free (translatedSettingName);
+    free (properSettingName);
+    free (rawSettingName);
+
+    ccsSettingUnref (setting);
+}
+
+TEST_F(CCSGSettingsTestIndependent, TestReadVariantIsValidNULL)
+{
+    EXPECT_FALSE (checkReadVariantIsValid (NULL, TypeNum, "foo/bar"));
+}
+
+TEST_F(CCSGSettingsTestIndependent, TestReadVariantIsValidTypeBad)
+{
+    GVariant *v = g_variant_new ("i", 1);
+
+    EXPECT_FALSE (checkReadVariantIsValid (v, TypeString, "foo/bar"));
+
+    g_variant_unref (v);
+}
+
+TEST_F(CCSGSettingsTestIndependent, TestReadVariantIsValidTypeGood)
+{
+    GVariant *v = g_variant_new ("i", 1);
+
+    EXPECT_TRUE (checkReadVariantIsValid (v, TypeInt, "foo/bar"));
+
+    g_variant_unref (v);
+}
+
+typedef CCSSettingValueList (*ReadValueListOfDataTypeFunc) (GVariantIter *, guint nItems, CCSSetting *setting);
+
+class ReadListValueTypeTestParam
+{
+    public:
+
+	typedef boost::function <CCSSettingValueList (GVariantIter *,
+						      guint nItems,
+						      CCSSetting *setting,
+						      CCSObjectAllocationInterface *allocator)> ReadValueListFunc;
+	typedef boost::function <GVariant * ()> GVariantPopulator;
+	typedef boost::function <CCSSettingValueList (CCSSetting *)> CCSSettingValueListPopulator;
+
+	ReadListValueTypeTestParam (const ReadValueListFunc &readFunc,
+				    const GVariantPopulator &variantPopulator,
+				    const CCSSettingValueListPopulator &listPopulator,
+				    const CCSSettingType    &type) :
+	    mReadFunc (readFunc),
+	    mVariantPopulator (variantPopulator),
+	    mListPopulator (listPopulator),
+	    mType (type)
+	{
+	}
+
+	CCSSettingValueList read (GVariantIter *iter,
+				  guint        nItems,
+				  CCSSetting   *setting,
+				  CCSObjectAllocationInterface *allocator) const
+	{
+	    return mReadFunc (iter, nItems, setting, allocator);
+	}
+
+	boost::shared_ptr <GVariant> populateVariant () const
+	{
+	    return boost::shared_ptr <GVariant> (mVariantPopulator (), boost::bind (g_variant_unref, _1));
+	}
+
+	boost::shared_ptr <_CCSSettingValueList> populateList (CCSSetting *setting) const
+	{
+	    return boost::shared_ptr <_CCSSettingValueList> (mListPopulator (setting), boost::bind (ccsSettingValueListFree, _1, TRUE));
+	}
+
+	CCSSettingType type () const { return mType; }
+
+    private:
+
+	ReadValueListFunc mReadFunc;
+	GVariantPopulator mVariantPopulator;
+	CCSSettingValueListPopulator mListPopulator;
+	CCSSettingType    mType;
+
+};
+
+namespace compizconfig
+{
+    namespace test
+    {
+	namespace impl
+	{
+	    namespace populators
+	    {
+		namespace variant
+		{
+		    GVariant * boolean ()
+		    {
+			GVariantBuilder vb;
+			g_variant_builder_init (&vb, G_VARIANT_TYPE ("ab"));
+			g_variant_builder_add (&vb, "b", boolValues[0]);
+			g_variant_builder_add (&vb, "b", boolValues[1]);
+			g_variant_builder_add (&vb, "b", boolValues[2]);
+			return g_variant_builder_end (&vb);
+		    }
+
+		    GVariant * integer ()
+		    {
+			GVariantBuilder vb;
+			g_variant_builder_init (&vb, G_VARIANT_TYPE ("ai"));
+			g_variant_builder_add (&vb, "i", intValues[0]);
+			g_variant_builder_add (&vb, "i", intValues[1]);
+			g_variant_builder_add (&vb, "i", intValues[2]);
+			return g_variant_builder_end (&vb);
+		    }
+
+		    GVariant * doubleprecision ()
+		    {
+			GVariantBuilder vb;
+			g_variant_builder_init (&vb, G_VARIANT_TYPE ("ad"));
+			g_variant_builder_add (&vb, "d", floatValues[0]);
+			g_variant_builder_add (&vb, "d", floatValues[1]);
+			g_variant_builder_add (&vb, "d", floatValues[2]);
+			return g_variant_builder_end (&vb);
+		    }
+
+		    GVariant * string ()
+		    {
+			GVariantBuilder vb;
+			g_variant_builder_init (&vb, G_VARIANT_TYPE ("as"));
+			g_variant_builder_add (&vb, "s", stringValues[0]);
+			g_variant_builder_add (&vb, "s", stringValues[1]);
+			g_variant_builder_add (&vb, "s", stringValues[2]);
+			return g_variant_builder_end (&vb);
+		    }
+
+		    GVariant * color ()
+		    {
+			GVariantBuilder vb;
+
+			CharacterWrapper s1 (ccsColorToString (&(getColorValueList ()[0])));
+			CharacterWrapper s2 (ccsColorToString (&(getColorValueList ()[1])));
+			CharacterWrapper s3 (ccsColorToString (&(getColorValueList ()[2])));
+
+			char * c1 = s1;
+			char * c2 = s2;
+			char * c3 = s3;
+
+			g_variant_builder_init (&vb, G_VARIANT_TYPE ("as"));
+			g_variant_builder_add (&vb, "s", c1);
+			g_variant_builder_add (&vb, "s", c2);
+			g_variant_builder_add (&vb, "s", c3);
+			return g_variant_builder_end (&vb);
+		    }
+		}
+	    }
+	}
+    }
+}
+
+class CCSGSettingsTestReadListValueTypes :
+    public ::testing::TestWithParam <ReadListValueTypeTestParam>
+{
+};
+
+TEST_P(CCSGSettingsTestReadListValueTypes, TestListValueGoodAllocation)
+{
+    boost::shared_ptr <GVariant>   variant = GetParam ().populateVariant ();
+    boost::shared_ptr <CCSSetting> mockSetting (ccsNiceMockSettingNew (), boost::bind (ccsFreeMockSetting, _1));
+    NiceMock <CCSSettingGMock>     *gmockSetting = reinterpret_cast <NiceMock <CCSSettingGMock> *> (ccsObjectGetPrivate (mockSetting.get ()));
+
+    ON_CALL (*gmockSetting, getType ()).WillByDefault (Return (TypeList));
+
+    CCSSettingInfo			    info =
+    {
+	.forList =
+	{
+	    GetParam ().type (),
+	    NULL
+	}
+    };
+
+    boost::shared_ptr <_CCSSettingValueList> valueList (GetParam ().populateList (mockSetting.get ()));
+    GVariantIter			    iter;
+
+    g_variant_iter_init (&iter, variant.get ());
+
+    ON_CALL (*gmockSetting, getInfo ()).WillByDefault (Return (&info));
+    ON_CALL (*gmockSetting, getDefaultValue ()).WillByDefault (ReturnNull ());
+
+    boost::shared_ptr <_CCSSettingValueList> readValueList (GetParam ().read (&iter,
+									      3,
+									      mockSetting.get (),
+									      &ccsDefaultObjectAllocator),
+							    boost::bind (ccsSettingValueListFree, _1, TRUE));
+
+    EXPECT_TRUE (ccsCompareLists (valueList.get (), readValueList.get (), info.forList));
+}
+
+TEST_P(CCSGSettingsTestReadListValueTypes, TestListValueThroughListValueDispatch)
+{
+    boost::shared_ptr <GVariant>   variant = GetParam ().populateVariant ();
+    boost::shared_ptr <CCSSetting> mockSetting (ccsNiceMockSettingNew (), boost::bind (ccsFreeMockSetting, _1));
+    NiceMock <CCSSettingGMock>     *gmockSetting = reinterpret_cast <NiceMock <CCSSettingGMock> *> (ccsObjectGetPrivate (mockSetting.get ()));
+
+    ON_CALL (*gmockSetting, getType ()).WillByDefault (Return (TypeList));
+
+    CCSSettingInfo			    info =
+    {
+	.forList =