Rename all non-autogenerated symbols to flatpak

13 files changed, 1428 insertions, 1428 deletions

diff --git a/common/xdg-app-chain-input-stream.c b/common/xdg-app-chain-input-stream.c
index ae1360f..d7be407 100644
--- a/common/xdg-app-chain-input-stream.c
+++ b/common/xdg-app-chain-input-stream.c
@@ -27,49 +27,49 @@ enum {
   PROP_STREAMS
 };
 
-G_DEFINE_TYPE (XdgAppChainInputStream, xdg_app_chain_input_stream, G_TYPE_INPUT_STREAM)
+G_DEFINE_TYPE (FlatpakChainInputStream, flatpak_chain_input_stream, G_TYPE_INPUT_STREAM)
 
-struct _XdgAppChainInputStreamPrivate
+struct _FlatpakChainInputStreamPrivate
 {
   GPtrArray *streams;
   guint      index;
 };
 
-static void     xdg_app_chain_input_stream_set_property (GObject      *object,
+static void     flatpak_chain_input_stream_set_property (GObject      *object,
                                                          guint         prop_id,
                                                          const GValue *value,
                                                          GParamSpec   *pspec);
-static void     xdg_app_chain_input_stream_get_property (GObject    *object,
+static void     flatpak_chain_input_stream_get_property (GObject    *object,
                                                          guint       prop_id,
                                                          GValue     *value,
                                                          GParamSpec *pspec);
-static void     xdg_app_chain_input_stream_finalize (GObject *object);
-static gssize   xdg_app_chain_input_stream_read (GInputStream *stream,
+static void     flatpak_chain_input_stream_finalize (GObject *object);
+static gssize   flatpak_chain_input_stream_read (GInputStream *stream,
                                                  void         *buffer,
                                                  gsize         count,
                                                  GCancellable *cancellable,
                                                  GError      **error);
-static gboolean xdg_app_chain_input_stream_close (GInputStream *stream,
+static gboolean flatpak_chain_input_stream_close (GInputStream *stream,
                                                   GCancellable *cancellable,
                                                   GError      **error);
 
 static void
-xdg_app_chain_input_stream_class_init (XdgAppChainInputStreamClass *klass)
+flatpak_chain_input_stream_class_init (FlatpakChainInputStreamClass *klass)
 {
   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
   GInputStreamClass *stream_class = G_INPUT_STREAM_CLASS (klass);
 
-  g_type_class_add_private (klass, sizeof (XdgAppChainInputStreamPrivate));
+  g_type_class_add_private (klass, sizeof (FlatpakChainInputStreamPrivate));
 
-  gobject_class->get_property = xdg_app_chain_input_stream_get_property;
-  gobject_class->set_property = xdg_app_chain_input_stream_set_property;
-  gobject_class->finalize     = xdg_app_chain_input_stream_finalize;
+  gobject_class->get_property = flatpak_chain_input_stream_get_property;
+  gobject_class->set_property = flatpak_chain_input_stream_set_property;
+  gobject_class->finalize     = flatpak_chain_input_stream_finalize;
 
-  stream_class->read_fn = xdg_app_chain_input_stream_read;
-  stream_class->close_fn = xdg_app_chain_input_stream_close;
+  stream_class->read_fn = flatpak_chain_input_stream_read;
+  stream_class->close_fn = flatpak_chain_input_stream_close;
 
   /*
-   * XdgAppChainInputStream:streams: (element-type GInputStream)
+   * FlatpakChainInputStream:streams: (element-type GInputStream)
    *
    * Chain of input streams read in order.
    */
@@ -84,14 +84,14 @@ xdg_app_chain_input_stream_class_init (XdgAppChainInputStreamClass *klass)
 }
 
 static void
-xdg_app_chain_input_stream_set_property (GObject      *object,
+flatpak_chain_input_stream_set_property (GObject      *object,
                                          guint         prop_id,
                                          const GValue *value,
                                          GParamSpec   *pspec)
 {
-  XdgAppChainInputStream *self;
+  FlatpakChainInputStream *self;
 
-  self = XDG_APP_CHAIN_INPUT_STREAM (object);
+  self = FLATPAK_CHAIN_INPUT_STREAM (object);
 
   switch (prop_id)
     {
@@ -106,14 +106,14 @@ xdg_app_chain_input_stream_set_property (GObject      *object,
 }
 
 static void
-xdg_app_chain_input_stream_get_property (GObject    *object,
+flatpak_chain_input_stream_get_property (GObject    *object,
                                          guint       prop_id,
                                          GValue     *value,
                                          GParamSpec *pspec)
 {
-  XdgAppChainInputStream *self;
+  FlatpakChainInputStream *self;
 
-  self = XDG_APP_CHAIN_INPUT_STREAM (object);
+  self = FLATPAK_CHAIN_INPUT_STREAM (object);
 
   switch (prop_id)
     {
@@ -127,46 +127,46 @@ xdg_app_chain_input_stream_get_property (GObject    *object,
 }
 
 static void
-xdg_app_chain_input_stream_finalize (GObject *object)
+flatpak_chain_input_stream_finalize (GObject *object)
 {
-  XdgAppChainInputStream *stream;
+  FlatpakChainInputStream *stream;
 
-  stream = (XdgAppChainInputStream *) (object);
+  stream = (FlatpakChainInputStream *) (object);
 
   g_ptr_array_unref (stream->priv->streams);
 
-  G_OBJECT_CLASS (xdg_app_chain_input_stream_parent_class)->finalize (object);
+  G_OBJECT_CLASS (flatpak_chain_input_stream_parent_class)->finalize (object);
 }
 
 static void
-xdg_app_chain_input_stream_init (XdgAppChainInputStream *self)
+flatpak_chain_input_stream_init (FlatpakChainInputStream *self)
 {
   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
-                                            XDG_APP_TYPE_CHAIN_INPUT_STREAM,
-                                            XdgAppChainInputStreamPrivate);
+                                            FLATPAK_TYPE_CHAIN_INPUT_STREAM,
+                                            FlatpakChainInputStreamPrivate);
 
 }
 
-XdgAppChainInputStream *
-xdg_app_chain_input_stream_new (GPtrArray *streams)
+FlatpakChainInputStream *
+flatpak_chain_input_stream_new (GPtrArray *streams)
 {
-  XdgAppChainInputStream *stream;
+  FlatpakChainInputStream *stream;
 
-  stream = g_object_new (XDG_APP_TYPE_CHAIN_INPUT_STREAM,
+  stream = g_object_new (FLATPAK_TYPE_CHAIN_INPUT_STREAM,
                          "streams", streams,
                          NULL);
 
-  return (XdgAppChainInputStream *) (stream);
+  return (FlatpakChainInputStream *) (stream);
 }
 
 static gssize
-xdg_app_chain_input_stream_read (GInputStream *stream,
+flatpak_chain_input_stream_read (GInputStream *stream,
                                  void         *buffer,
                                  gsize         count,
                                  GCancellable *cancellable,
                                  GError      **error)
 {
-  XdgAppChainInputStream *self = (XdgAppChainInputStream *) stream;
+  FlatpakChainInputStream *self = (FlatpakChainInputStream *) stream;
   GInputStream *child;
   gssize res = -1;
 
@@ -193,12 +193,12 @@ xdg_app_chain_input_stream_read (GInputStream *stream,
 }
 
 static gboolean
-xdg_app_chain_input_stream_close (GInputStream *stream,
+flatpak_chain_input_stream_close (GInputStream *stream,
                                   GCancellable *cancellable,
                                   GError      **error)
 {
   gboolean ret = FALSE;
-  XdgAppChainInputStream *self = (gpointer) stream;
+  FlatpakChainInputStream *self = (gpointer) stream;
   guint i;
 
   for (i = 0; i < self->priv->streams->len; i++)
diff --git a/common/xdg-app-chain-input-stream.h b/common/xdg-app-chain-input-stream.h
index 0d3b793..ed66560 100644
--- a/common/xdg-app-chain-input-stream.h
+++ b/common/xdg-app-chain-input-stream.h
@@ -27,26 +27,26 @@
 
 G_BEGIN_DECLS
 
-#define XDG_APP_TYPE_CHAIN_INPUT_STREAM (xdg_app_chain_input_stream_get_type ())
-#define XDG_APP_CHAIN_INPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), XDG_APP_TYPE_CHAIN_INPUT_STREAM, XdgAppChainInputStream))
-#define XDG_APP_CHAIN_INPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), XDG_APP_TYPE_CHAIN_INPUT_STREAM, XdgAppChainInputStreamClass))
-#define XDG_APP_IS_CHAIN_INPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDG_APP_TYPE_CHAIN_INPUT_STREAM))
-#define XDG_APP_IS_CHAIN_INPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), XDG_APP_TYPE_CHAIN_INPUT_STREAM))
-#define XDG_APP_CHAIN_INPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDG_APP_TYPE_CHAIN_INPUT_STREAM, XdgAppChainInputStreamClass))
+#define FLATPAK_TYPE_CHAIN_INPUT_STREAM (flatpak_chain_input_stream_get_type ())
+#define FLATPAK_CHAIN_INPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), FLATPAK_TYPE_CHAIN_INPUT_STREAM, FlatpakChainInputStream))
+#define FLATPAK_CHAIN_INPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), FLATPAK_TYPE_CHAIN_INPUT_STREAM, FlatpakChainInputStreamClass))
+#define FLATPAK_IS_CHAIN_INPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), FLATPAK_TYPE_CHAIN_INPUT_STREAM))
+#define FLATPAK_IS_CHAIN_INPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), FLATPAK_TYPE_CHAIN_INPUT_STREAM))
+#define FLATPAK_CHAIN_INPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FLATPAK_TYPE_CHAIN_INPUT_STREAM, FlatpakChainInputStreamClass))
 
-typedef struct _XdgAppChainInputStream        XdgAppChainInputStream;
-typedef struct _XdgAppChainInputStreamClass   XdgAppChainInputStreamClass;
-typedef struct _XdgAppChainInputStreamPrivate XdgAppChainInputStreamPrivate;
+typedef struct _FlatpakChainInputStream        FlatpakChainInputStream;
+typedef struct _FlatpakChainInputStreamClass   FlatpakChainInputStreamClass;
+typedef struct _FlatpakChainInputStreamPrivate FlatpakChainInputStreamPrivate;
 
-struct _XdgAppChainInputStream
+struct _FlatpakChainInputStream
 {
   GInputStream parent_instance;
 
   /*< private >*/
-  XdgAppChainInputStreamPrivate *priv;
+  FlatpakChainInputStreamPrivate *priv;
 };
 
-struct _XdgAppChainInputStreamClass
+struct _FlatpakChainInputStreamClass
 {
   GInputStreamClass parent_class;
 
@@ -59,9 +59,9 @@ struct _XdgAppChainInputStreamClass
   void (*_g_reserved5) (void);
 };
 
-GType          xdg_app_chain_input_stream_get_type (void) G_GNUC_CONST;
+GType          flatpak_chain_input_stream_get_type (void) G_GNUC_CONST;
 
-XdgAppChainInputStream * xdg_app_chain_input_stream_new (GPtrArray *streams);
+FlatpakChainInputStream * flatpak_chain_input_stream_new (GPtrArray *streams);
 
 G_END_DECLS
 
diff --git a/common/xdg-app-common-types.h b/common/xdg-app-common-types.h
index 9e2e8d3..0243eca 100644
--- a/common/xdg-app-common-types.h
+++ b/common/xdg-app-common-types.h
@@ -18,11 +18,11 @@
  *       Alexander Larsson <alexl@redhat.com>
  */
 
-#ifndef __XDG_APP_COMMON_TYPES_H__
-#define __XDG_APP_COMMON_TYPES_H__
+#ifndef __FLATPAK_COMMON_TYPES_H__
+#define __FLATPAK_COMMON_TYPES_H__
 
-typedef struct XdgAppDir     XdgAppDir;
-typedef struct XdgAppDeploy  XdgAppDeploy;
-typedef struct XdgAppContext XdgAppContext;
+typedef struct FlatpakDir     FlatpakDir;
+typedef struct FlatpakDeploy  FlatpakDeploy;
+typedef struct FlatpakContext FlatpakContext;
 
-#endif /* __XDG_APP_COMMON_TYPES_H__ */
+#endif /* __FLATPAK_COMMON_TYPES_H__ */
diff --git a/common/xdg-app-db.c b/common/xdg-app-db.c
index 8f8468f..9e8af7c 100644
--- a/common/xdg-app-db.c
+++ b/common/xdg-app-db.c
@@ -31,7 +31,7 @@
 #include "gvdb/gvdb-reader.h"
 #include "gvdb/gvdb-builder.h"
 
-struct XdgAppDb
+struct FlatpakDb
 {
   GObject    parent;
 
@@ -55,11 +55,11 @@ struct XdgAppDb
 typedef struct
 {
   GObjectClass parent_class;
-} XdgAppDbClass;
+} FlatpakDbClass;
 
 static void initable_iface_init (GInitableIface *initable_iface);
 
-G_DEFINE_TYPE_WITH_CODE (XdgAppDb, xdg_app_db, G_TYPE_OBJECT,
+G_DEFINE_TYPE_WITH_CODE (FlatpakDb, flatpak_db, G_TYPE_OBJECT,
                          G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, initable_iface_init));
 
 enum {
@@ -102,29 +102,29 @@ str_ptr_array_contains (GPtrArray  *array,
 }
 
 const char *
-xdg_app_db_get_path (XdgAppDb *self)
+flatpak_db_get_path (FlatpakDb *self)
 {
-  g_return_val_if_fail (XDG_APP_IS_DB (self), NULL);
+  g_return_val_if_fail (FLATPAK_IS_DB (self), NULL);
 
   return self->path;
 }
 
 void
-xdg_app_db_set_path (XdgAppDb   *self,
+flatpak_db_set_path (FlatpakDb  *self,
                      const char *path)
 {
-  g_return_if_fail (XDG_APP_IS_DB (self));
+  g_return_if_fail (FLATPAK_IS_DB (self));
 
   g_clear_pointer (&self->path, g_free);
   self->path = g_strdup (path);
 }
 
-XdgAppDb *
-xdg_app_db_new (const char *path,
+FlatpakDb *
+flatpak_db_new (const char *path,
                 gboolean    fail_if_not_found,
                 GError    **error)
 {
-  return g_initable_new (XDG_APP_TYPE_DB,
+  return g_initable_new (FLATPAK_TYPE_DB,
                          NULL,
                          error,
                          "path", path,
@@ -133,9 +133,9 @@ xdg_app_db_new (const char *path,
 }
 
 static void
-xdg_app_db_finalize (GObject *object)
+flatpak_db_finalize (GObject *object)
 {
-  XdgAppDb *self = (XdgAppDb *) object;
+  FlatpakDb *self = (FlatpakDb *) object;
 
   g_clear_pointer (&self->path, g_free);
   g_clear_pointer (&self->gvdb_contents, g_bytes_unref);
@@ -146,16 +146,16 @@ xdg_app_db_finalize (GObject *object)
   g_clear_pointer (&self->app_additions, g_hash_table_unref);
   g_clear_pointer (&self->app_removals, g_hash_table_unref);
 
-  G_OBJECT_CLASS (xdg_app_db_parent_class)->finalize (object);
+  G_OBJECT_CLASS (flatpak_db_parent_class)->finalize (object);
 }
 
 static void
-xdg_app_db_get_property (GObject    *object,
+flatpak_db_get_property (GObject    *object,
                          guint       prop_id,
                          GValue     *value,
                          GParamSpec *pspec)
 {
-  XdgAppDb *self = XDG_APP_DB (object);
+  FlatpakDb *self = FLATPAK_DB (object);
 
   switch (prop_id)
     {
@@ -173,12 +173,12 @@ xdg_app_db_get_property (GObject    *object,
 }
 
 static void
-xdg_app_db_set_property (GObject      *object,
+flatpak_db_set_property (GObject      *object,
                          guint         prop_id,
                          const GValue *value,
                          GParamSpec   *pspec)
 {
-  XdgAppDb *self = XDG_APP_DB (object);
+  FlatpakDb *self = FLATPAK_DB (object);
 
   switch (prop_id)
     {
@@ -197,13 +197,13 @@ xdg_app_db_set_property (GObject      *object,
 }
 
 static void
-xdg_app_db_class_init (XdgAppDbClass *klass)
+flatpak_db_class_init (FlatpakDbClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  object_class->finalize = xdg_app_db_finalize;
-  object_class->get_property = xdg_app_db_get_property;
-  object_class->set_property = xdg_app_db_set_property;
+  object_class->finalize = flatpak_db_finalize;
+  object_class->get_property = flatpak_db_get_property;
+  object_class->set_property = flatpak_db_set_property;
 
   g_object_class_install_property (object_class,
                                    PROP_PATH,
@@ -222,7 +222,7 @@ xdg_app_db_class_init (XdgAppDbClass *klass)
 }
 
 static void
-xdg_app_db_init (XdgAppDb *self)
+flatpak_db_init (FlatpakDb *self)
 {
   self->fail_if_not_found = TRUE;
 
@@ -258,7 +258,7 @@ initable_init (GInitable    *initable,
                GCancellable *cancellable,
                GError      **error)
 {
-  XdgAppDb *self = (XdgAppDb *) initable;
+  FlatpakDb *self = (FlatpakDb *) initable;
   GError *my_error = NULL;
 
   if (self->path == NULL)
@@ -332,14 +332,14 @@ initable_iface_init (GInitableIface *initable_iface)
 
 /* Transfer: full */
 char **
-xdg_app_db_list_ids (XdgAppDb *self)
+flatpak_db_list_ids (FlatpakDb *self)
 {
   GPtrArray *res;
   GHashTableIter iter;
   gpointer key, value;
   int i;
 
-  g_return_val_if_fail (XDG_APP_IS_DB (self), NULL);
+  g_return_val_if_fail (FLATPAK_IS_DB (self), NULL);
 
   res = g_ptr_array_new ();
 
@@ -384,14 +384,14 @@ app_update_empty (GHashTable *ht, const char *app)
 
 /* Transfer: full */
 char **
-xdg_app_db_list_apps (XdgAppDb *self)
+flatpak_db_list_apps (FlatpakDb *self)
 {
   gpointer key, _value;
   GHashTableIter iter;
   GPtrArray *res;
   int i;
 
-  g_return_val_if_fail (XDG_APP_IS_DB (self), NULL);
+  g_return_val_if_fail (FLATPAK_IS_DB (self), NULL);
 
   res = g_ptr_array_new ();
 
@@ -454,7 +454,7 @@ xdg_app_db_list_apps (XdgAppDb *self)
 
 /* Transfer: full */
 char **
-xdg_app_db_list_ids_by_app (XdgAppDb   *self,
+flatpak_db_list_ids_by_app (FlatpakDb  *self,
                             const char *app)
 {
   GPtrArray *res;
@@ -462,7 +462,7 @@ xdg_app_db_list_ids_by_app (XdgAppDb   *self,
   GPtrArray *removals;
   int i;
 
-  g_return_val_if_fail (XDG_APP_IS_DB (self), NULL);
+  g_return_val_if_fail (FLATPAK_IS_DB (self), NULL);
 
   res = g_ptr_array_new ();
 
@@ -497,14 +497,14 @@ xdg_app_db_list_ids_by_app (XdgAppDb   *self,
 }
 
 /* Transfer: full */
-XdgAppDbEntry *
-xdg_app_db_lookup (XdgAppDb   *self,
+FlatpakDbEntry *
+flatpak_db_lookup (FlatpakDb  *self,
                    const char *id)
 {
   GVariant *res = NULL;
   gpointer value;
 
-  g_return_val_if_fail (XDG_APP_IS_DB (self), NULL);
+  g_return_val_if_fail (FLATPAK_IS_DB (self), NULL);
   g_return_val_if_fail (id != NULL, NULL);
 
   if (g_hash_table_lookup_extended (self->main_updates, id, NULL, &value))
@@ -517,19 +517,19 @@ xdg_app_db_lookup (XdgAppDb   *self,
       res = gvdb_table_get_value (self->main_table, id);
     }
 
-  return (XdgAppDbEntry *) res;
+  return (FlatpakDbEntry *) res;
 }
 
 /* Transfer: full */
 char **
-xdg_app_db_list_ids_by_value (XdgAppDb *self,
-                              GVariant *data)
+flatpak_db_list_ids_by_value (FlatpakDb *self,
+                              GVariant  *data)
 {
-  g_autofree char **ids = xdg_app_db_list_ids (self);
+  g_autofree char **ids = flatpak_db_list_ids (self);
   int i;
   GPtrArray *res;
 
-  g_return_val_if_fail (XDG_APP_IS_DB (self), NULL);
+  g_return_val_if_fail (FLATPAK_IS_DB (self), NULL);
   g_return_val_if_fail (data != NULL, NULL);
 
   res = g_ptr_array_new ();
@@ -538,13 +538,13 @@ xdg_app_db_list_ids_by_value (XdgAppDb *self,
     {
       char *id = ids[i];
 
-      g_autoptr(XdgAppDbEntry) entry = NULL;
+      g_autoptr(FlatpakDbEntry) entry = NULL;
       g_autoptr(GVariant) entry_data = NULL;
 
-      entry = xdg_app_db_lookup (self, id);
+      entry = flatpak_db_lookup (self, id);
       if (entry)
         {
-          entry_data = xdg_app_db_entry_get_data (entry);
+          entry_data = flatpak_db_entry_get_data (entry);
           if (g_variant_equal (data, entry_data))
             {
               g_ptr_array_add (res, id);
@@ -559,7 +559,7 @@ xdg_app_db_list_ids_by_value (XdgAppDb *self,
 }
 
 static void
-add_app_id (XdgAppDb   *self,
+add_app_id (FlatpakDb  *self,
             const char *app,
             const char *id)
 {
@@ -592,7 +592,7 @@ add_app_id (XdgAppDb   *self,
 }
 
 static void
-remove_app_id (XdgAppDb   *self,
+remove_app_id (FlatpakDb  *self,
                const char *app,
                const char *id)
 {
@@ -625,50 +625,50 @@ remove_app_id (XdgAppDb   *self,
 }
 
 gboolean
-xdg_app_db_is_dirty (XdgAppDb *self)
+flatpak_db_is_dirty (FlatpakDb *self)
 {
-  g_return_val_if_fail (XDG_APP_IS_DB (self), FALSE);
+  g_return_val_if_fail (FLATPAK_IS_DB (self), FALSE);
 
   return self->dirty;
 }
 
 /* add, replace, or NULL entry to remove */
 void
-xdg_app_db_set_entry (XdgAppDb      *self,
-                      const char    *id,
-                      XdgAppDbEntry *entry)
+flatpak_db_set_entry (FlatpakDb      *self,
+                      const char     *id,
+                      FlatpakDbEntry *entry)
 {
-  g_autoptr(XdgAppDbEntry) old_entry = NULL;
+  g_autoptr(FlatpakDbEntry) old_entry = NULL;
   g_autofree const char **old = NULL;
   g_autofree const char **new = NULL;
   static const char *empty[] = { NULL };
   const char **a, **b;
   int ia, ib;
 
-  g_return_if_fail (XDG_APP_IS_DB (self));
+  g_return_if_fail (FLATPAK_IS_DB (self));
   g_return_if_fail (id != NULL);
 
   self->dirty = TRUE;
 
-  old_entry = xdg_app_db_lookup (self, id);
+  old_entry = flatpak_db_lookup (self, id);
 
   g_hash_table_insert (self->main_updates,
                        g_strdup (id),
-                       xdg_app_db_entry_ref (entry));
+                       flatpak_db_entry_ref (entry));
 
   a = empty;
   b = empty;
 
   if (old_entry)
     {
-      old = xdg_app_db_entry_list_apps (old_entry);
+      old = flatpak_db_entry_list_apps (old_entry);
       sort_strv (old);
       a = old;
     }
 
   if (entry)
     {
-      new = xdg_app_db_entry_list_apps (entry);
+      new = flatpak_db_entry_list_apps (entry);
       sort_strv (new);
       b = new;
     }
@@ -716,7 +716,7 @@ xdg_app_db_set_entry (XdgAppDb      *self,
 }
 
 void
-xdg_app_db_update (XdgAppDb *self)
+flatpak_db_update (FlatpakDb *self)
 {
   GHashTable *root, *main_h, *apps_h;
   GBytes *new_contents;
@@ -726,7 +726,7 @@ xdg_app_db_update (XdgAppDb *self)
   g_auto(GStrv) ids = NULL;
   g_auto(GStrv) apps = NULL;
 
-  g_return_if_fail (XDG_APP_IS_DB (self));
+  g_return_if_fail (FLATPAK_IS_DB (self));
 
   root = gvdb_hash_table_new (NULL, NULL);
   main_h = gvdb_hash_table_new (root, "main");
@@ -734,10 +734,10 @@ xdg_app_db_update (XdgAppDb *self)
   g_hash_table_unref (main_h);
   g_hash_table_unref (apps_h);
 
-  ids = xdg_app_db_list_ids (self);
+  ids = flatpak_db_list_ids (self);
   for (i = 0; ids[i] != 0; i++)
     {
-      g_autoptr(XdgAppDbEntry) entry = xdg_app_db_lookup (self, ids[i]);
+      g_autoptr(FlatpakDbEntry) entry = flatpak_db_lookup (self, ids[i]);
       if (entry != NULL)
         {
           GvdbItem *item;
@@ -747,10 +747,10 @@ xdg_app_db_update (XdgAppDb *self)
         }
     }
 
-  apps = xdg_app_db_list_apps (self);
+  apps = flatpak_db_list_apps (self);
   for (i = 0; apps[i] != 0; i++)
     {
-      g_auto(GStrv) app_ids = xdg_app_db_list_ids_by_app (self, apps[i]);
+      g_auto(GStrv) app_ids = flatpak_db_list_ids_by_app (self, apps[i]);
       GVariantBuilder builder;
       GvdbItem *item;
       int j;
@@ -783,17 +783,17 @@ xdg_app_db_update (XdgAppDb *self)
 }
 
 GBytes *
-xdg_app_db_get_content (XdgAppDb *self)
+flatpak_db_get_content (FlatpakDb *self)
 {
-  g_return_val_if_fail (XDG_APP_IS_DB (self), NULL);
+  g_return_val_if_fail (FLATPAK_IS_DB (self), NULL);
 
   return self->gvdb_contents;
 }
 
 /* Note: You must first call update to serialize, this only saves serialied data */
 gboolean
-xdg_app_db_save_content (XdgAppDb *self,
-                         GError  **error)
+flatpak_db_save_content (FlatpakDb *self,
+                         GError   **error)
 {
   GBytes *content = NULL;
 
@@ -835,7 +835,7 @@ save_content_callback (GObject      *source_object,
 }
 
 void
-xdg_app_db_save_content_async (XdgAppDb           *self,
+flatpak_db_save_content_async (FlatpakDb          *self,
                                GCancellable       *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer            user_data)
@@ -873,7 +873,7 @@ xdg_app_db_save_content_async (XdgAppDb           *self,
 }
 
 gboolean
-xdg_app_db_save_content_finish (XdgAppDb     *self,
+flatpak_db_save_content_finish (FlatpakDb    *self,
                                 GAsyncResult *res,
                                 GError      **error)
 {
@@ -882,41 +882,41 @@ xdg_app_db_save_content_finish (XdgAppDb     *self,
 
 
 GString *
-xdg_app_db_print_string (XdgAppDb *self,
-                         GString  *string)
+flatpak_db_print_string (FlatpakDb *self,
+                         GString   *string)
 {
   g_auto(GStrv) ids = NULL;
   g_auto(GStrv) apps = NULL;
   int i;
 
-  g_return_val_if_fail (XDG_APP_IS_DB (self), NULL);
+  g_return_val_if_fail (FLATPAK_IS_DB (self), NULL);
 
   if G_UNLIKELY (string == NULL)
     string = g_string_new (NULL);
 
   g_string_append_printf (string, "main {\n");
 
-  ids = xdg_app_db_list_ids (self);
+  ids = flatpak_db_list_ids (self);
   sort_strv ((const char **) ids);
   for (i = 0; ids[i] != 0; i++)
     {
-      g_autoptr(XdgAppDbEntry) entry = xdg_app_db_lookup (self, ids[i]);
+      g_autoptr(FlatpakDbEntry) entry = flatpak_db_lookup (self, ids[i]);
       g_string_append_printf (string, " %s: ", ids[i]);
       if (entry != NULL)
-        xdg_app_db_entry_print_string (entry, string);
+        flatpak_db_entry_print_string (entry, string);
       g_string_append_printf (string, "\n");
     }
 
   g_string_append_printf (string, "}\napps {\n");
 
-  apps = xdg_app_db_list_apps (self);
+  apps = flatpak_db_list_apps (self);
   sort_strv ((const char **) apps);
   for (i = 0; apps[i] != 0; i++)
     {
       int j;
       g_auto(GStrv) app_ids = NULL;
 
-      app_ids = xdg_app_db_list_ids_by_app (self, apps[i]);
+      app_ids = flatpak_db_list_ids_by_app (self, apps[i]);
       sort_strv ((const char **) app_ids);
 
       g_string_append_printf (string, " %s: ", apps[i]);
@@ -931,13 +931,13 @@ xdg_app_db_print_string (XdgAppDb *self,
 }
 
 char *
-xdg_app_db_print (XdgAppDb *self)
+flatpak_db_print (FlatpakDb *self)
 {
-  return g_string_free (xdg_app_db_print_string (self, NULL), FALSE);
+  return g_string_free (flatpak_db_print_string (self, NULL), FALSE);
 }
 
-XdgAppDbEntry  *
-xdg_app_db_entry_ref (XdgAppDbEntry *entry)
+FlatpakDbEntry  *
+flatpak_db_entry_ref (FlatpakDbEntry *entry)
 {
   if (entry != NULL)
     g_variant_ref ((GVariant *) entry);
@@ -945,14 +945,14 @@ xdg_app_db_entry_ref (XdgAppDbEntry *entry)
 }
 
 void
-xdg_app_db_entry_unref (XdgAppDbEntry *entry)
+flatpak_db_entry_unref (FlatpakDbEntry *entry)
 {
   g_variant_unref ((GVariant *) entry);
 }
 
 /* Transfer: full */
 GVariant *
-xdg_app_db_entry_get_data (XdgAppDbEntry *entry)
+flatpak_db_entry_get_data (FlatpakDbEntry *entry)
 {
   g_autoptr(GVariant) variant = g_variant_get_child_value ((GVariant *) entry, 0);
 
@@ -961,7 +961,7 @@ xdg_app_db_entry_get_data (XdgAppDbEntry *entry)
 
 /* Transfer: container */
 const char **
-xdg_app_db_entry_list_apps (XdgAppDbEntry *entry)
+flatpak_db_entry_list_apps (FlatpakDbEntry *entry)
 {
   GVariant *v = (GVariant *) entry;
 
@@ -994,8 +994,8 @@ xdg_app_db_entry_list_apps (XdgAppDbEntry *entry)
 }
 
 static GVariant *
-xdg_app_db_entry_get_permissions_variant (XdgAppDbEntry *entry,
-                                          const char    *app_id)
+flatpak_db_entry_get_permissions_variant (FlatpakDbEntry *entry,
+                                          const char     *app_id)
 {
   GVariant *v = (GVariant *) entry;
 
@@ -1041,12 +1041,12 @@ xdg_app_db_entry_get_permissions_variant (XdgAppDbEntry *entry,
 
 /* Transfer: container */
 const char **
-xdg_app_db_entry_list_permissions (XdgAppDbEntry *entry,
-                                   const char    *app)
+flatpak_db_entry_list_permissions (FlatpakDbEntry *entry,
+                                   const char     *app)
 {
   g_autoptr(GVariant) permissions = NULL;
 
-  permissions = xdg_app_db_entry_get_permissions_variant (entry, app);
+  permissions = flatpak_db_entry_get_permissions_variant (entry, app);
   if (permissions)
     return g_variant_get_strv (permissions, NULL);
   else
@@ -1054,26 +1054,26 @@ xdg_app_db_entry_list_permissions (XdgAppDbEntry *entry,
 }
 
 gboolean
-xdg_app_db_entry_has_permission (XdgAppDbEntry *entry,
-                                 const char    *app,
-                                 const char    *permission)
+flatpak_db_entry_has_permission (FlatpakDbEntry *entry,
+                                 const char     *app,
+                                 const char     *permission)
 {
   g_autofree const char **app_permissions = NULL;
 
-  app_permissions = xdg_app_db_entry_list_permissions (entry, app);
+  app_permissions = flatpak_db_entry_list_permissions (entry, app);
 
   return g_strv_contains (app_permissions, permission);
 }
 
 gboolean
-xdg_app_db_entry_has_permissions (XdgAppDbEntry *entry,
-                                  const char    *app,
-                                  const char   **permissions)
+flatpak_db_entry_has_permissions (FlatpakDbEntry *entry,
+                                  const char     *app,
+                                  const char    **permissions)
 {
   g_autofree const char **app_permissions = NULL;
   int i;
 
-  app_permissions = xdg_app_db_entry_list_permissions (entry, app);
+  app_permissions = flatpak_db_entry_list_permissions (entry, app);
 
   for (i = 0; permissions[i] != NULL; i++)
     {
@@ -1167,8 +1167,8 @@ add_permissions (GVariant *app_permissions,
   return g_variant_builder_end (&builder);
 }
 
-XdgAppDbEntry  *
-xdg_app_db_entry_new (GVariant *data)
+FlatpakDbEntry  *
+flatpak_db_entry_new (GVariant *data)
 {
   GVariant *res;
 
@@ -1178,12 +1178,12 @@ xdg_app_db_entry_new (GVariant *data)
   res = make_entry (data,
                     make_empty_app_permissions ());
 
-  return (XdgAppDbEntry  *) g_variant_ref_sink (res);
+  return (FlatpakDbEntry  *) g_variant_ref_sink (res);
 }
 
-XdgAppDbEntry  *
-xdg_app_db_entry_modify_data (XdgAppDbEntry *entry,
-                              GVariant      *data)
+FlatpakDbEntry  *
+flatpak_db_entry_modify_data (FlatpakDbEntry *entry,
+                              GVariant       *data)
 {
   GVariant *v = (GVariant *) entry;
   GVariant *res;
@@ -1193,14 +1193,14 @@ xdg_app_db_entry_modify_data (XdgAppDbEntry *entry,
 
   res = make_entry (data,
                     g_variant_get_child_value (v, 1));
-  return (XdgAppDbEntry  *) g_variant_ref_sink (res);
+  return (FlatpakDbEntry  *) g_variant_ref_sink (res);
 }
 
 /* NULL (or empty) permissions to remove permissions */
-XdgAppDbEntry  *
-xdg_app_db_entry_set_app_permissions (XdgAppDbEntry *entry,
-                                      const char    *app,
-                                      const char   **permissions)
+FlatpakDbEntry  *
+flatpak_db_entry_set_app_permissions (FlatpakDbEntry *entry,
+                                      const char     *app,
+                                      const char    **permissions)
 {
   GVariant *v = (GVariant *) entry;
   GVariant *res;
@@ -1213,12 +1213,12 @@ xdg_app_db_entry_set_app_permissions (XdgAppDbEntry *entry,
                     add_permissions (old_permissions,
                                      make_permissions (app,
                                                        permissions)));
-  return (XdgAppDbEntry  *) g_variant_ref_sink (res);
+  return (FlatpakDbEntry  *) g_variant_ref_sink (res);
 }
 
 GString *
-xdg_app_db_entry_print_string (XdgAppDbEntry *entry,
-                               GString       *string)
+flatpak_db_entry_print_string (FlatpakDbEntry *entry,
+                               GString        *string)
 {
   return g_variant_print_string ((GVariant *) entry, string, FALSE);
 }
diff --git a/common/xdg-app-db.h b/common/xdg-app-db.h
index ba49947..738cf9b 100644
--- a/common/xdg-app-db.h
+++ b/common/xdg-app-db.h
@@ -19,8 +19,8 @@
  *       Alexander Larsson <alexl@redhat.com>
  */
 
-#ifndef XDG_APP_DB_H
-#define XDG_APP_DB_H
+#ifndef FLATPAK_DB_H
+#define FLATPAK_DB_H
 
 #include <string.h>
 
@@ -29,75 +29,75 @@
 
 G_BEGIN_DECLS
 
-typedef struct XdgAppDb       XdgAppDb;
-typedef struct _XdgAppDbEntry XdgAppDbEntry;
+typedef struct FlatpakDb       FlatpakDb;
+typedef struct _FlatpakDbEntry FlatpakDbEntry;
 
-#define XDG_APP_TYPE_DB (xdg_app_db_get_type ())
-#define XDG_APP_DB(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XDG_APP_TYPE_DB, XdgAppDb))
-#define XDG_APP_IS_DB(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), XDG_APP_TYPE_DB))
+#define FLATPAK_TYPE_DB (flatpak_db_get_type ())
+#define FLATPAK_DB(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FLATPAK_TYPE_DB, FlatpakDb))
+#define FLATPAK_IS_DB(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FLATPAK_TYPE_DB))
 
-GType xdg_app_db_get_type (void);
+GType flatpak_db_get_type (void);
 
-XdgAppDb *     xdg_app_db_new (const char *path,
-                               gboolean    fail_if_not_found,
-                               GError    **error);
-char **        xdg_app_db_list_ids (XdgAppDb *self);
-char **        xdg_app_db_list_apps (XdgAppDb *self);
-char **        xdg_app_db_list_ids_by_app (XdgAppDb   *self,
+FlatpakDb *     flatpak_db_new (const char *path,
+                                gboolean    fail_if_not_found,
+                                GError    **error);
+char **        flatpak_db_list_ids (FlatpakDb *self);
+char **        flatpak_db_list_apps (FlatpakDb *self);
+char **        flatpak_db_list_ids_by_app (FlatpakDb  *self,
                                            const char *app);
-char **        xdg_app_db_list_ids_by_value (XdgAppDb *self,
-                                             GVariant *data);
-XdgAppDbEntry *xdg_app_db_lookup (XdgAppDb   *self,
-                                  const char *id);
-GString *      xdg_app_db_print_string (XdgAppDb *self,
-                                        GString  *string);
-char *         xdg_app_db_print (XdgAppDb *self);
+char **        flatpak_db_list_ids_by_value (FlatpakDb *self,
+                                             GVariant  *data);
+FlatpakDbEntry *flatpak_db_lookup (FlatpakDb  *self,
+                                   const char *id);
+GString *      flatpak_db_print_string (FlatpakDb *self,
+                                        GString   *string);
+char *         flatpak_db_print (FlatpakDb *self);
 
-gboolean       xdg_app_db_is_dirty (XdgAppDb *self);
-void           xdg_app_db_set_entry (XdgAppDb      *self,
-                                     const char    *id,
-                                     XdgAppDbEntry *entry);
-void           xdg_app_db_update (XdgAppDb *self);
-GBytes *       xdg_app_db_get_content (XdgAppDb *self);
-const char *   xdg_app_db_get_path (XdgAppDb *self);
-gboolean       xdg_app_db_save_content (XdgAppDb *self,
-                                        GError  **error);
-void           xdg_app_db_save_content_async (XdgAppDb           *self,
+gboolean       flatpak_db_is_dirty (FlatpakDb *self);
+void           flatpak_db_set_entry (FlatpakDb      *self,
+                                     const char     *id,
+                                     FlatpakDbEntry *entry);
+void           flatpak_db_update (FlatpakDb *self);
+GBytes *       flatpak_db_get_content (FlatpakDb *self);
+const char *   flatpak_db_get_path (FlatpakDb *self);
+gboolean       flatpak_db_save_content (FlatpakDb *self,
+                                        GError   **error);
+void           flatpak_db_save_content_async (FlatpakDb          *self,
                                               GCancellable       *cancellable,
                                               GAsyncReadyCallback callback,
                                               gpointer            user_data);
-gboolean       xdg_app_db_save_content_finish (XdgAppDb     *self,
+gboolean       flatpak_db_save_content_finish (FlatpakDb    *self,
                                                GAsyncResult *res,
                                                GError      **error);
-void           xdg_app_db_set_path (XdgAppDb   *self,
+void           flatpak_db_set_path (FlatpakDb  *self,
                                     const char *path);
 
 
-XdgAppDbEntry  *xdg_app_db_entry_ref (XdgAppDbEntry *entry);
-void            xdg_app_db_entry_unref (XdgAppDbEntry *entry);
-GVariant *      xdg_app_db_entry_get_data (XdgAppDbEntry *entry);
-const char **   xdg_app_db_entry_list_apps (XdgAppDbEntry *entry);
-const char **   xdg_app_db_entry_list_permissions (XdgAppDbEntry *entry,
-                                                   const char    *app);
-gboolean        xdg_app_db_entry_has_permission (XdgAppDbEntry *entry,
-                                                 const char    *app,
-                                                 const char    *permission);
-gboolean        xdg_app_db_entry_has_permissions (XdgAppDbEntry *entry,
-                                                  const char    *app,
-                                                  const char   **permissions);
-GString *       xdg_app_db_entry_print_string (XdgAppDbEntry *entry,
-                                               GString       *string);
+FlatpakDbEntry  *flatpak_db_entry_ref (FlatpakDbEntry *entry);
+void            flatpak_db_entry_unref (FlatpakDbEntry *entry);
+GVariant *      flatpak_db_entry_get_data (FlatpakDbEntry *entry);
+const char **   flatpak_db_entry_list_apps (FlatpakDbEntry *entry);
+const char **   flatpak_db_entry_list_permissions (FlatpakDbEntry *entry,
+                                                   const char     *app);
+gboolean        flatpak_db_entry_has_permission (FlatpakDbEntry *entry,
+                                                 const char     *app,
+                                                 const char     *permission);
+gboolean        flatpak_db_entry_has_permissions (FlatpakDbEntry *entry,
+                                                  const char     *app,
+                                                  const char    **permissions);
+GString *       flatpak_db_entry_print_string (FlatpakDbEntry *entry,
+                                               GString        *string);
 
-XdgAppDbEntry  *xdg_app_db_entry_new (GVariant *data);
-XdgAppDbEntry  *xdg_app_db_entry_modify_data (XdgAppDbEntry *entry,
-                                              GVariant      *data);
-XdgAppDbEntry  *xdg_app_db_entry_set_app_permissions (XdgAppDbEntry *entry,
-                                                      const char    *app,
-                                                      const char   **permissions);
+FlatpakDbEntry  *flatpak_db_entry_new (GVariant *data);
+FlatpakDbEntry  *flatpak_db_entry_modify_data (FlatpakDbEntry *entry,
+                                               GVariant       *data);
+FlatpakDbEntry  *flatpak_db_entry_set_app_permissions (FlatpakDbEntry *entry,
+                                                       const char     *app,
+                                                       const char    **permissions);
 
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (XdgAppDb, g_object_unref)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (XdgAppDbEntry, xdg_app_db_entry_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FlatpakDb, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FlatpakDbEntry, flatpak_db_entry_unref)
 
 G_END_DECLS
 
-#endif /* XDG_APP_DB_H */
+#endif /* FLATPAK_DB_H */
diff --git a/common/xdg-app-dir.c b/common/xdg-app-dir.c
index 563366b..0fa1afa 100644
--- a/common/xdg-app-dir.c
+++ b/common/xdg-app-dir.c
@@ -39,7 +39,7 @@
 
 #define NO_SYSTEM_HELPER ((XdgAppSystemHelper *) (gpointer) 1)
 
-struct XdgAppDir
+struct FlatpakDir
 {
   GObject             parent;
 
@@ -55,27 +55,27 @@ struct XdgAppDir
 typedef struct
 {
   GObjectClass parent_class;
-} XdgAppDirClass;
+} FlatpakDirClass;
 
-struct XdgAppDeploy
+struct FlatpakDeploy
 {
-  GObject        parent;
+  GObject         parent;
 
-  GFile         *dir;
-  GKeyFile      *metadata;
-  XdgAppContext *system_overrides;
-  XdgAppContext *user_overrides;
+  GFile          *dir;
+  GKeyFile       *metadata;
+  FlatpakContext *system_overrides;
+  FlatpakContext *user_overrides;
 };
 
 typedef struct
 {
   GObjectClass parent_class;
-} XdgAppDeployClass;
+} FlatpakDeployClass;
 
-G_DEFINE_TYPE (XdgAppDir, xdg_app_dir, G_TYPE_OBJECT)
-G_DEFINE_TYPE (XdgAppDeploy, xdg_app_deploy, G_TYPE_OBJECT)
+G_DEFINE_TYPE (FlatpakDir, flatpak_dir, G_TYPE_OBJECT)
+G_DEFINE_TYPE (FlatpakDeploy, flatpak_deploy, G_TYPE_OBJECT)
 
-G_DEFINE_QUARK (xdg - app - dir - error - quark, xdg_app_dir_error)
+G_DEFINE_QUARK (xdg - app - dir - error - quark, flatpak_dir_error)
 
 enum {
   PROP_0,
@@ -88,70 +88,70 @@ enum {
                                    "unix::device,unix::inode,unix::mode,unix::uid,unix::gid,unix::rdev")
 
 static void
-xdg_app_deploy_finalize (GObject *object)
+flatpak_deploy_finalize (GObject *object)
 {
-  XdgAppDeploy *self = XDG_APP_DEPLOY (object);
+  FlatpakDeploy *self = FLATPAK_DEPLOY (object);
 
   g_clear_object (&self->dir);
   g_clear_pointer (&self->metadata, g_key_file_unref);
   g_clear_pointer (&self->system_overrides, g_key_file_unref);
   g_clear_pointer (&self->user_overrides, g_key_file_unref);
 
-  G_OBJECT_CLASS (xdg_app_deploy_parent_class)->finalize (object);
+  G_OBJECT_CLASS (flatpak_deploy_parent_class)->finalize (object);
 }
 
 static void
-xdg_app_deploy_class_init (XdgAppDeployClass *klass)
+flatpak_deploy_class_init (FlatpakDeployClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  object_class->finalize = xdg_app_deploy_finalize;
+  object_class->finalize = flatpak_deploy_finalize;
 
 }
 
 static void
-xdg_app_deploy_init (XdgAppDeploy *self)
+flatpak_deploy_init (FlatpakDeploy *self)
 {
 }
 
 GFile *
-xdg_app_deploy_get_dir (XdgAppDeploy *deploy)
+flatpak_deploy_get_dir (FlatpakDeploy *deploy)
 {
   return g_object_ref (deploy->dir);
 }
 
 GFile *
-xdg_app_deploy_get_files (XdgAppDeploy *deploy)
+flatpak_deploy_get_files (FlatpakDeploy *deploy)
 {
   return g_file_get_child (deploy->dir, "files");
 }
 
-XdgAppContext *
-xdg_app_deploy_get_overrides (XdgAppDeploy *deploy)
+FlatpakContext *
+flatpak_deploy_get_overrides (FlatpakDeploy *deploy)
 {
-  XdgAppContext *overrides = xdg_app_context_new ();
+  FlatpakContext *overrides = flatpak_context_new ();
 
   if (deploy->system_overrides)
-    xdg_app_context_merge (overrides, deploy->system_overrides);
+    flatpak_context_merge (overrides, deploy->system_overrides);
 
   if (deploy->user_overrides)
-    xdg_app_context_merge (overrides, deploy->user_overrides);
+    flatpak_context_merge (overrides, deploy->user_overrides);
 
   return overrides;
 }
 
 GKeyFile *
-xdg_app_deploy_get_metadata (XdgAppDeploy *deploy)
+flatpak_deploy_get_metadata (FlatpakDeploy *deploy)
 {
   return g_key_file_ref (deploy->metadata);
 }
 
-static XdgAppDeploy *
-xdg_app_deploy_new (GFile *dir, GKeyFile *metadata)
+static FlatpakDeploy *
+flatpak_deploy_new (GFile *dir, GKeyFile *metadata)
 {
-  XdgAppDeploy *deploy;
+  FlatpakDeploy *deploy;
 
-  deploy = g_object_new (XDG_APP_TYPE_DEPLOY, NULL);
+  deploy = g_object_new (FLATPAK_TYPE_DEPLOY, NULL);
   deploy->dir = g_object_ref (dir);
   deploy->metadata = g_key_file_ref (metadata);
 
@@ -159,13 +159,13 @@ xdg_app_deploy_new (GFile *dir, GKeyFile *metadata)
 }
 
 GFile *
-xdg_app_get_system_base_dir_location (void)
+flatpak_get_system_base_dir_location (void)
 {
-  return g_file_new_for_path (XDG_APP_SYSTEMDIR);
+  return g_file_new_for_path (FLATPAK_SYSTEMDIR);
 }
 
 GFile *
-xdg_app_get_user_base_dir_location (void)
+flatpak_get_user_base_dir_location (void)
 {
   g_autofree char *base = g_build_filename (g_get_user_data_dir (), "xdg-app", NULL);
 
@@ -173,21 +173,21 @@ xdg_app_get_user_base_dir_location (void)
 }
 
 GFile *
-xdg_app_get_user_cache_dir_location (void)
+flatpak_get_user_cache_dir_location (void)
 {
   g_autoptr(GFile) base_dir = NULL;
 
-  base_dir = xdg_app_get_user_base_dir_location ();
+  base_dir = flatpak_get_user_base_dir_location ();
   return g_file_get_child (base_dir, "system-cache");
 }
 
 GFile *
-xdg_app_ensure_user_cache_dir_location (GError **error)
+flatpak_ensure_user_cache_dir_location (GError **error)
 {
   g_autoptr(GFile) cache_dir = NULL;
   g_autofree char *cache_path = NULL;
 
-  cache_dir = xdg_app_get_user_cache_dir_location ();
+  cache_dir = flatpak_get_user_cache_dir_location ();
   cache_path = g_file_get_path (cache_dir);
 
   if (g_mkdir_with_parents (cache_path, 0755) != 0)
@@ -200,7 +200,7 @@ xdg_app_ensure_user_cache_dir_location (GError **error)
 }
 
 static XdgAppSystemHelper *
-xdg_app_dir_get_system_helper (XdgAppDir *self)
+flatpak_dir_get_system_helper (FlatpakDir *self)
 {
   g_autoptr(GError) error = NULL;
 
@@ -211,12 +211,12 @@ xdg_app_dir_get_system_helper (XdgAppDir *self)
         xdg_app_system_helper_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
                                                       G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |
                                                       G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
-                                                      "org.freedesktop.XdgApp.SystemHelper",
-                                                      "/org/freedesktop/XdgApp/SystemHelper",
+                                                      "org.freedesktop.Flatpak.SystemHelper",
+                                                      "/org/freedesktop/Flatpak/SystemHelper",
                                                       NULL, &error);
       if (error != NULL)
         {
-          g_warning ("Can't find org.freedesktop.XdgApp.SystemHelper: %s\n", error->message);
+          g_warning ("Can't find org.freedesktop.Flatpak.SystemHelper: %s\n", error->message);
           system_helper = NO_SYSTEM_HELPER;
         }
 
@@ -229,14 +229,14 @@ xdg_app_dir_get_system_helper (XdgAppDir *self)
 }
 
 gboolean
-xdg_app_dir_use_child_repo (XdgAppDir *self)
+flatpak_dir_use_child_repo (FlatpakDir *self)
 {
   XdgAppSystemHelper *system_helper;
 
   if (self->user || getuid () == 0)
     return FALSE;
 
-  system_helper = xdg_app_dir_get_system_helper (self);
+  system_helper = flatpak_dir_get_system_helper (self);
 
   return system_helper != NULL;
 }
@@ -245,14 +245,14 @@ static OstreeRepo *
 system_ostree_repo_new (GFile *repodir)
 {
   return g_object_new (OSTREE_TYPE_REPO, "path", repodir,
-                       "remotes-config-dir", XDG_APP_CONFIGDIR "/remotes.d",
+                       "remotes-config-dir", FLATPAK_CONFIGDIR "/remotes.d",
                        NULL);
 }
 
 static void
-xdg_app_dir_finalize (GObject *object)
+flatpak_dir_finalize (GObject *object)
 {
-  XdgAppDir *self = XDG_APP_DIR (object);
+  FlatpakDir *self = FLATPAK_DIR (object);
 
   g_clear_object (&self->repo);
   g_clear_object (&self->basedir);
@@ -261,16 +261,16 @@ xdg_app_dir_finalize (GObject *object)
 
   g_clear_object (&self->soup_session);
 
-  G_OBJECT_CLASS (xdg_app_dir_parent_class)->finalize (object);
+  G_OBJECT_CLASS (flatpak_dir_parent_class)->finalize (object);
 }
 
 static void
-xdg_app_dir_set_property (GObject      *object,
+flatpak_dir_set_property (GObject      *object,
                           guint         prop_id,
                           const GValue *value,
                           GParamSpec   *pspec)
 {
-  XdgAppDir *self = XDG_APP_DIR (object);
+  FlatpakDir *self = FLATPAK_DIR (object);
 
   switch (prop_id)
     {
@@ -290,12 +290,12 @@ xdg_app_dir_set_property (GObject      *object,
 }
 
 static void
-xdg_app_dir_get_property (GObject    *object,
+flatpak_dir_get_property (GObject    *object,
                           guint       prop_id,
                           GValue     *value,
                           GParamSpec *pspec)
 {
-  XdgAppDir *self = XDG_APP_DIR (object);
+  FlatpakDir *self = FLATPAK_DIR (object);
 
   switch (prop_id)
     {
@@ -314,13 +314,13 @@ xdg_app_dir_get_property (GObject    *object,
 }
 
 static void
-xdg_app_dir_class_init (XdgAppDirClass *klass)
+flatpak_dir_class_init (FlatpakDirClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  object_class->get_property = xdg_app_dir_get_property;
-  object_class->set_property = xdg_app_dir_set_property;
-  object_class->finalize = xdg_app_dir_finalize;
+  object_class->get_property = flatpak_dir_get_property;
+  object_class->set_property = flatpak_dir_set_property;
+  object_class->finalize = flatpak_dir_finalize;
 
   g_object_class_install_property (object_class,
                                    PROP_USER,
@@ -339,30 +339,30 @@ xdg_app_dir_class_init (XdgAppDirClass *klass)
 }
 
 static void
-xdg_app_dir_init (XdgAppDir *self)
+flatpak_dir_init (FlatpakDir *self)
 {
 }
 
 gboolean
-xdg_app_dir_is_user (XdgAppDir *self)
+flatpak_dir_is_user (FlatpakDir *self)
 {
   return self->user;
 }
 
 GFile *
-xdg_app_dir_get_path (XdgAppDir *self)
+flatpak_dir_get_path (FlatpakDir *self)
 {
   return self->basedir;
 }
 
 GFile *
-xdg_app_dir_get_changed_path (XdgAppDir *self)
+flatpak_dir_get_changed_path (FlatpakDir *self)
 {
   return g_file_get_child (self->basedir, ".changed");
 }
 
 char *
-xdg_app_dir_load_override (XdgAppDir  *self,
+flatpak_dir_load_override (FlatpakDir *self,
                            const char *app_id,
                            gsize      *length,
                            GError    **error)
@@ -386,17 +386,17 @@ xdg_app_dir_load_override (XdgAppDir  *self,
 }
 
 GKeyFile *
-xdg_app_load_override_keyfile (const char *app_id, gboolean user, GError **error)
+flatpak_load_override_keyfile (const char *app_id, gboolean user, GError **error)
 {
   g_autofree char *metadata_contents = NULL;
   gsize metadata_size;
 
   g_autoptr(GKeyFile) metakey = g_key_file_new ();
-  g_autoptr(XdgAppDir) dir = NULL;
+  g_autoptr(FlatpakDir) dir = NULL;
 
-  dir = xdg_app_dir_get (user);
+  dir = flatpak_dir_get (user);
 
-  metadata_contents = xdg_app_dir_load_override (dir, app_id, &metadata_size, error);
+  metadata_contents = flatpak_dir_load_override (dir, app_id, &metadata_size, error);
   if (metadata_contents == NULL)
     return NULL;
 
@@ -409,15 +409,15 @@ xdg_app_load_override_keyfile (const char *app_id, gboolean user, GError **error
   return g_steal_pointer (&metakey);
 }
 
-XdgAppContext *
-xdg_app_load_override_file (const char *app_id, gboolean user, GError **error)
+FlatpakContext *
+flatpak_load_override_file (const char *app_id, gboolean user, GError **error)
 {
-  XdgAppContext *overrides = xdg_app_context_new ();
+  FlatpakContext *overrides = flatpak_context_new ();
 
   g_autoptr(GKeyFile) metakey = NULL;
   g_autoptr(GError) my_error = NULL;
 
-  metakey = xdg_app_load_override_keyfile (app_id, user, &my_error);
+  metakey = flatpak_load_override_keyfile (app_id, user, &my_error);
   if (metakey == NULL)
     {
       if (!g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
@@ -428,7 +428,7 @@ xdg_app_load_override_file (const char *app_id, gboolean user, GError **error)
     }
   else
     {
-      if (!xdg_app_context_load_metadata (overrides, metakey, error))
+      if (!flatpak_context_load_metadata (overrides, metakey, error))
         return NULL;
     }
 
@@ -436,7 +436,7 @@ xdg_app_load_override_file (const char *app_id, gboolean user, GError **error)
 }
 
 gboolean
-xdg_app_save_override_keyfile (GKeyFile   *metakey,
+flatpak_save_override_keyfile (GKeyFile   *metakey,
                                const char *app_id,
                                gboolean    user,
                                GError    **error)
@@ -448,9 +448,9 @@ xdg_app_save_override_keyfile (GKeyFile   *metakey,
   g_autofree char *parent = NULL;
 
   if (user)
-    base_dir = xdg_app_get_user_base_dir_location ();
+    base_dir = flatpak_get_user_base_dir_location ();
   else
-    base_dir = xdg_app_get_system_base_dir_location ();
+    base_dir = flatpak_get_system_base_dir_location ();
 
   override_dir = g_file_get_child (base_dir, "overrides");
   file = g_file_get_child (override_dir, app_id);
@@ -466,8 +466,8 @@ xdg_app_save_override_keyfile (GKeyFile   *metakey,
   return g_key_file_save_to_file (metakey, filename, error);
 }
 
-XdgAppDeploy *
-xdg_app_dir_load_deployed (XdgAppDir    *self,
+FlatpakDeploy *
+flatpak_dir_load_deployed (FlatpakDir   *self,
                            const char   *ref,
                            const char   *checksum,
                            GCancellable *cancellable,
@@ -478,13 +478,13 @@ xdg_app_dir_load_deployed (XdgAppDir    *self,
   g_autoptr(GFile) metadata = NULL;
   g_auto(GStrv) ref_parts = NULL;
   g_autofree char *metadata_contents = NULL;
-  XdgAppDeploy *deploy;
+  FlatpakDeploy *deploy;
   gsize metadata_size;
 
-  deploy_dir = xdg_app_dir_get_if_deployed (self, ref, checksum, cancellable);
+  deploy_dir = flatpak_dir_get_if_deployed (self, ref, checksum, cancellable);
   if (deploy_dir == NULL)
     {
-      g_set_error (error, XDG_APP_DIR_ERROR, XDG_APP_DIR_ERROR_NOT_DEPLOYED, "%s not installed", ref);
+      g_set_error (error, FLATPAK_DIR_ERROR, FLATPAK_DIR_ERROR_NOT_DEPLOYED, "%s not installed", ref);
       return NULL;
     }
 
@@ -496,7 +496,7 @@ xdg_app_dir_load_deployed (XdgAppDir    *self,
   if (!g_key_file_load_from_data (metakey, metadata_contents, metadata_size, 0, error))
     return NULL;
 
-  deploy = xdg_app_deploy_new (deploy_dir, metakey);
+  deploy = flatpak_deploy_new (deploy_dir, metakey);
 
   ref_parts = g_strsplit (ref, "/", -1);
   g_assert (g_strv_length (ref_parts) == 4);
@@ -507,13 +507,13 @@ xdg_app_dir_load_deployed (XdgAppDir    *self,
       /* Only load system overrides for system installed apps */
       if (!self->user)
         {
-          deploy->system_overrides = xdg_app_load_override_file (ref_parts[1], FALSE, error);
+          deploy->system_overrides = flatpak_load_override_file (ref_parts[1], FALSE, error);
           if (deploy->system_overrides == NULL)
             return NULL;
         }
 
       /* Always load user overrides */
-      deploy->user_overrides = xdg_app_load_override_file (ref_parts[1], TRUE, error);
+      deploy->user_overrides = flatpak_load_override_file (ref_parts[1], TRUE, error);
       if (deploy->user_overrides == NULL)
         return NULL;
     }
@@ -522,26 +522,26 @@ xdg_app_dir_load_deployed (XdgAppDir    *self,
 }
 
 GFile *
-xdg_app_dir_get_deploy_dir (XdgAppDir  *self,
+flatpak_dir_get_deploy_dir (FlatpakDir *self,
                             const char *ref)
 {
   return g_file_resolve_relative_path (self->basedir, ref);
 }
 
 GFile *
-xdg_app_dir_get_exports_dir (XdgAppDir *self)
+flatpak_dir_get_exports_dir (FlatpakDir *self)
 {
   return g_file_get_child (self->basedir, "exports");
 }
 
 GFile *
-xdg_app_dir_get_removed_dir (XdgAppDir *self)
+flatpak_dir_get_removed_dir (FlatpakDir *self)
 {
   return g_file_get_child (self->basedir, ".removed");
 }
 
 OstreeRepo *
-xdg_app_dir_get_repo (XdgAppDir *self)
+flatpak_dir_get_repo (FlatpakDir *self)
 {
   return self->repo;
 }
@@ -555,19 +555,19 @@ xdg_app_dir_get_repo (XdgAppDir *self)
  * to do the right thing.
  */
 gboolean
-xdg_app_dir_lock (XdgAppDir    *self,
+flatpak_dir_lock (FlatpakDir   *self,
                   GLnxLockFile *lockfile,
                   GCancellable *cancellable,
                   GError      **error)
 {
-  g_autoptr(GFile) lock_file = g_file_get_child (xdg_app_dir_get_path (self), "lock");
+  g_autoptr(GFile) lock_file = g_file_get_child (flatpak_dir_get_path (self), "lock");
   g_autofree char *lock_path = g_file_get_path (lock_file);
 
   return glnx_make_lock_file (AT_FDCWD, lock_path, LOCK_EX, lockfile, error);
 }
 
 const char *
-xdg_app_deploy_data_get_origin (GVariant *deploy_data)
+flatpak_deploy_data_get_origin (GVariant *deploy_data)
 {
   const char *origin;
 
@@ -576,7 +576,7 @@ xdg_app_deploy_data_get_origin (GVariant *deploy_data)
 }
 
 const char *
-xdg_app_deploy_data_get_commit (GVariant *deploy_data)
+flatpak_deploy_data_get_commit (GVariant *deploy_data)
 {
   const char *commit;
 
@@ -585,12 +585,12 @@ xdg_app_deploy_data_get_commit (GVariant *deploy_data)
 }
 
 /**
- * xdg_app_deploy_data_get_subpaths:
+ * flatpak_deploy_data_get_subpaths:
  *
  * Returns: (array length=length zero-terminated=1) (transfer container): an array of constant strings
  **/
 const char **
-xdg_app_deploy_data_get_subpaths (GVariant *deploy_data)
+flatpak_deploy_data_get_subpaths (GVariant *deploy_data)
 {
   const char **subpaths;
 
@@ -599,7 +599,7 @@ xdg_app_deploy_data_get_subpaths (GVariant *deploy_data)
 }
 
 guint64
-xdg_app_deploy_data_get_installed_size (GVariant *deploy_data)
+flatpak_deploy_data_get_installed_size (GVariant *deploy_data)
 {
   guint64 size;
 
@@ -608,7 +608,7 @@ xdg_app_deploy_data_get_installed_size (GVariant *deploy_data)
 }
 
 static GVariant *
-xdg_app_dir_new_deploy_data (const char *origin,
+flatpak_dir_new_deploy_data (const char *origin,
                              const char *commit,
                              char      **subpaths,
                              guint64     installed_size,
@@ -672,7 +672,7 @@ get_old_subpaths (GFile        *deploy_base,
 }
 
 static GVariant *
-xdg_app_create_deploy_data_from_old (XdgAppDir    *self,
+flatpak_create_deploy_data_from_old (FlatpakDir   *self,
                                      GFile        *deploy_dir,
                                      GCancellable *cancellable,
                                      GError      **error)
@@ -699,12 +699,12 @@ xdg_app_create_deploy_data_from_old (XdgAppDir    *self,
   /* For backwards compat we return a 0 installed size, its to slow to regenerate */
   installed_size = 0;
 
-  return xdg_app_dir_new_deploy_data (old_origin, commit, old_subpaths,
+  return flatpak_dir_new_deploy_data (old_origin, commit, old_subpaths,
                                       installed_size, NULL);
 }
 
 GVariant *
-xdg_app_dir_get_deploy_data (XdgAppDir    *self,
+flatpak_dir_get_deploy_data (FlatpakDir   *self,
                              const char   *ref,
                              GCancellable *cancellable,
                              GError      **error)
@@ -716,10 +716,10 @@ xdg_app_dir_get_deploy_data (XdgAppDir    *self,
   gsize data_size;
   g_autofree char *active = NULL;
 
-  deploy_dir = xdg_app_dir_get_if_deployed (self, ref, NULL, cancellable);
+  deploy_dir = flatpak_dir_get_if_deployed (self, ref, NULL, cancellable);
   if (deploy_dir == NULL)
     {
-      xdg_app_fail (error, "%s is not installed", ref);
+      flatpak_fail (error, "%s is not installed", ref);
       return NULL;
     }
 
@@ -732,37 +732,37 @@ xdg_app_dir_get_deploy_data (XdgAppDir    *self,
           return NULL;
         }
 
-      return xdg_app_create_deploy_data_from_old (self, deploy_dir,
+      return flatpak_create_deploy_data_from_old (self, deploy_dir,
                                                   cancellable, error);
     }
 
-  return g_variant_ref_sink (g_variant_new_from_data (XDG_APP_DEPLOY_DATA_GVARIANT_FORMAT,
+  return g_variant_ref_sink (g_variant_new_from_data (FLATPAK_DEPLOY_DATA_GVARIANT_FORMAT,
                                                       data, data_size,
                                                       FALSE, g_free, data));
 }
 
 
 char *
-xdg_app_dir_get_origin (XdgAppDir    *self,
+flatpak_dir_get_origin (FlatpakDir   *self,
                         const char   *ref,
                         GCancellable *cancellable,
                         GError      **error)
 {
   g_autoptr(GVariant) deploy_data = NULL;
 
-  deploy_data = xdg_app_dir_get_deploy_data (self, ref,
+  deploy_data = flatpak_dir_get_deploy_data (self, ref,
                                              cancellable, error);
   if (deploy_data == NULL)
     {
-      xdg_app_fail (error, "%s is not installed", ref);
+      flatpak_fail (error, "%s is not installed", ref);
       return NULL;
     }
 
-  return g_strdup (xdg_app_deploy_data_get_origin (deploy_data));
+  return g_strdup (flatpak_deploy_data_get_origin (deploy_data));
 }
 
 char **
-xdg_app_dir_get_subpaths (XdgAppDir    *self,
+flatpak_dir_get_subpaths (FlatpakDir   *self,
                           const char   *ref,
                           GCancellable *cancellable,
                           GError      **error)
@@ -771,15 +771,15 @@ xdg_app_dir_get_subpaths (XdgAppDir    *self,
   char **subpaths;
   int i;
 
-  deploy_data = xdg_app_dir_get_deploy_data (self, ref,
+  deploy_data = flatpak_dir_get_deploy_data (self, ref,
                                              cancellable, error);
   if (deploy_data == NULL)
     {
-      xdg_app_fail (error, "%s is not installed", ref);
+      flatpak_fail (error, "%s is not installed", ref);
       return NULL;
     }
 
-  subpaths = (char **) xdg_app_deploy_data_get_subpaths (deploy_data);
+  subpaths = (char **) flatpak_deploy_data_get_subpaths (deploy_data);
   for (i = 0; subpaths[i] != NULL; i++)
     subpaths[i] = g_strdup (subpaths[i]);
 
@@ -787,7 +787,7 @@ xdg_app_dir_get_subpaths (XdgAppDir    *self,
 }
 
 gboolean
-xdg_app_dir_ensure_path (XdgAppDir    *self,
+flatpak_dir_ensure_path (FlatpakDir   *self,
                          GCancellable *cancellable,
                          GError      **error)
 {
@@ -795,7 +795,7 @@ xdg_app_dir_ensure_path (XdgAppDir    *self,
 }
 
 gboolean
-xdg_app_dir_ensure_repo (XdgAppDir    *self,
+flatpak_dir_ensure_repo (FlatpakDir   *self,
                          GCancellable *cancellable,
                          GError      **error)
 {
@@ -806,7 +806,7 @@ xdg_app_dir_ensure_repo (XdgAppDir    *self,
 
   if (self->repo == NULL)
     {
-      if (!xdg_app_dir_ensure_path (self, cancellable, error))
+      if (!flatpak_dir_ensure_path (self, cancellable, error))
         goto out;
 
       repodir = g_file_get_child (self->basedir, "repo");
@@ -821,7 +821,7 @@ xdg_app_dir_ensure_repo (XdgAppDir    *self,
 
           repo = system_ostree_repo_new (repodir);
 
-          cache_dir = xdg_app_ensure_user_cache_dir_location (error);
+          cache_dir = flatpak_ensure_user_cache_dir_location (error);
           if (cache_dir == NULL)
             goto out;
 
@@ -843,7 +843,7 @@ xdg_app_dir_ensure_repo (XdgAppDir    *self,
             }
 
           /* Create .changes file early to avoid polling non-existing file in monitor */
-          xdg_app_dir_mark_changed (self, NULL);
+          flatpak_dir_mark_changed (self, NULL);
         }
       else
         {
@@ -866,12 +866,12 @@ out:
 }
 
 gboolean
-xdg_app_dir_mark_changed (XdgAppDir *self,
-                          GError   **error)
+flatpak_dir_mark_changed (FlatpakDir *self,
+                          GError    **error)
 {
   g_autoptr(GFile) changed_file = NULL;
 
-  changed_file = xdg_app_dir_get_changed_path (self);
+  changed_file = flatpak_dir_get_changed_path (self);
   if (!g_file_replace_contents (changed_file, "", 0, NULL, FALSE,
                                 G_FILE_CREATE_REPLACE_DESTINATION, NULL, NULL, error))
     return FALSE;
@@ -880,7 +880,7 @@ xdg_app_dir_mark_changed (XdgAppDir *self,
 }
 
 gboolean
-xdg_app_dir_remove_appstream (XdgAppDir    *self,
+flatpak_dir_remove_appstream (FlatpakDir   *self,
                               const char   *remote,
                               GCancellable *cancellable,
                               GError      **error)
@@ -888,10 +888,10 @@ xdg_app_dir_remove_appstream (XdgAppDir    *self,
   g_autoptr(GFile) appstream_dir = NULL;
   g_autoptr(GFile) remote_dir = NULL;
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     return FALSE;
 
-  appstream_dir = g_file_get_child (xdg_app_dir_get_path (self), "appstream");
+  appstream_dir = g_file_get_child (flatpak_dir_get_path (self), "appstream");
   remote_dir = g_file_get_child (appstream_dir, remote);
 
   if (g_file_query_exists (remote_dir, cancellable) &&
@@ -902,7 +902,7 @@ xdg_app_dir_remove_appstream (XdgAppDir    *self,
 }
 
 gboolean
-xdg_app_dir_remove_all_refs (XdgAppDir    *self,
+flatpak_dir_remove_all_refs (FlatpakDir   *self,
                              const char   *remote,
                              GCancellable *cancellable,
                              GError      **error)
@@ -913,7 +913,7 @@ xdg_app_dir_remove_all_refs (XdgAppDir    *self,
   GHashTableIter hash_iter;
   gpointer key;
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     return FALSE;
 
   prefix = g_strdup_printf ("%s:", remote);
@@ -930,7 +930,7 @@ xdg_app_dir_remove_all_refs (XdgAppDir    *self,
       const char *refspec = key;
 
       if (g_str_has_prefix (refspec, prefix) &&
-          !xdg_app_dir_remove_ref (self, remote, refspec + strlen (prefix), cancellable, error))
+          !flatpak_dir_remove_ref (self, remote, refspec + strlen (prefix), cancellable, error))
         return FALSE;
     }
 
@@ -938,7 +938,7 @@ xdg_app_dir_remove_all_refs (XdgAppDir    *self,
 }
 
 gboolean
-xdg_app_dir_update_appstream (XdgAppDir           *self,
+flatpak_dir_update_appstream (FlatpakDir          *self,
                               const char          *remote,
                               const char          *arch,
                               gboolean            *out_changed,
@@ -966,11 +966,11 @@ xdg_app_dir_update_appstream (XdgAppDir           *self,
   g_autoptr(GError) tmp_error = NULL;
   gboolean checkout_exists;
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     return FALSE;
 
   if (arch == NULL)
-    arch = xdg_app_get_arch ();
+    arch = flatpak_get_arch ();
 
   branch = g_strdup_printf ("appstream/%s", arch);
   remote_and_branch = g_strdup_printf ("%s:%s", remote, branch);
@@ -978,7 +978,7 @@ xdg_app_dir_update_appstream (XdgAppDir           *self,
   if (!ostree_repo_resolve_rev (self->repo, remote_and_branch, TRUE, &old_checksum, error))
     return FALSE;
 
-  if (!xdg_app_dir_pull (self, remote, branch, NULL, NULL, OSTREE_REPO_PULL_FLAGS_NONE, progress,
+  if (!flatpak_dir_pull (self, remote, branch, NULL, NULL, OSTREE_REPO_PULL_FLAGS_NONE, progress,
                          cancellable, error))
     return FALSE;
 
@@ -991,7 +991,7 @@ xdg_app_dir_update_appstream (XdgAppDir           *self,
       return TRUE;
     }
 
-  appstream_dir = g_file_get_child (xdg_app_dir_get_path (self), "appstream");
+  appstream_dir = g_file_get_child (flatpak_dir_get_path (self), "appstream");
   remote_dir = g_file_get_child (appstream_dir, remote);
   arch_dir = g_file_get_child (remote_dir, arch);
   checkout_dir = g_file_get_child (arch_dir, new_checksum);
@@ -1109,7 +1109,7 @@ repo_pull_one_dir (OstreeRepo          *self,
 
 
 gboolean
-xdg_app_dir_pull (XdgAppDir           *self,
+flatpak_dir_pull (FlatpakDir          *self,
                   const char          *repository,
                   const char          *ref,
                   char               **subpaths,
@@ -1126,7 +1126,7 @@ xdg_app_dir_pull (XdgAppDir           *self,
   const char *refs[2];
   g_autofree char *url = NULL;
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     goto out;
 
   if (!ostree_repo_remote_get_url (self->repo,
@@ -1257,7 +1257,7 @@ repo_pull_one_untrusted (OstreeRepo          *self,
 }
 
 gboolean
-xdg_app_dir_pull_untrusted_local (XdgAppDir           *self,
+flatpak_dir_pull_untrusted_local (FlatpakDir          *self,
                                   const char          *src_path,
                                   const char          *remote_name,
                                   const char          *ref,
@@ -1286,7 +1286,7 @@ xdg_app_dir_pull_untrusted_local (XdgAppDir           *self,
   g_autoptr(GVariant) summary = NULL;
   g_autoptr(GVariant) old_commit = NULL;
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     return FALSE;
 
   if (!ostree_repo_remote_get_gpg_verify_summary (self->repo, remote_name,
@@ -1298,7 +1298,7 @@ xdg_app_dir_pull_untrusted_local (XdgAppDir           *self,
     return FALSE;
 
   if (!gpg_verify_summary || !gpg_verify)
-    return xdg_app_fail (error, "Can't pull from untrusted non-gpg verified remote");
+    return flatpak_fail (error, "Can't pull from untrusted non-gpg verified remote");
 
   /* We verify the summary manually before anything else to make sure
      we've got something right before looking too hard at the repo and
@@ -1307,13 +1307,13 @@ xdg_app_dir_pull_untrusted_local (XdgAppDir           *self,
 
   if (!g_file_load_contents (summary_sig_file, cancellable,
                              &summary_sig_data, &summary_sig_data_size, NULL, NULL))
-    return xdg_app_fail (error, "GPG verification enabled, but no summary signatures found");
+    return flatpak_fail (error, "GPG verification enabled, but no summary signatures found");
 
   summary_sig_bytes = g_bytes_new_take (summary_sig_data, summary_sig_data_size);
 
   if (!g_file_load_contents (summary_file, cancellable,
                              &summary_data, &summary_data_size, NULL, NULL))
-    return xdg_app_fail (error, "No summary found");
+    return flatpak_fail (error, "No summary found");
   summary_bytes = g_bytes_new_take (summary_data, summary_data_size);
 
   gpg_result = ostree_repo_verify_summary (self->repo,
@@ -1325,10 +1325,10 @@ xdg_app_dir_pull_untrusted_local (XdgAppDir           *self,
     return FALSE;
 
   if (ostree_gpg_verify_result_count_valid (gpg_result) == 0)
-    return xdg_app_fail (error, "GPG signatures found, but none are in trusted keyring");
+    return flatpak_fail (error, "GPG signatures found, but none are in trusted keyring");
 
   summary = g_variant_ref_sink (g_variant_new_from_bytes (OSTREE_SUMMARY_GVARIANT_FORMAT, summary_bytes, FALSE));
-  if (!xdg_app_summary_lookup_ref (summary,
+  if (!flatpak_summary_lookup_ref (summary,
                                    ref,
                                    &checksum))
     {
@@ -1356,7 +1356,7 @@ xdg_app_dir_pull_untrusted_local (XdgAppDir           *self,
       new_timestamp = ostree_commit_get_timestamp (new_commit);
 
       if (new_timestamp < old_timestamp)
-        return xdg_app_fail (error, "Not allowed to downgrade %s", ref);
+        return flatpak_fail (error, "Not allowed to downgrade %s", ref);
     }
 
 
@@ -1422,7 +1422,7 @@ out:
 
 
 char *
-xdg_app_dir_current_ref (XdgAppDir    *self,
+flatpak_dir_current_ref (FlatpakDir   *self,
                          const char   *name,
                          GCancellable *cancellable)
 {
@@ -1431,7 +1431,7 @@ xdg_app_dir_current_ref (XdgAppDir    *self,
   g_autoptr(GFile) current_link = NULL;
   g_autoptr(GFileInfo) file_info = NULL;
 
-  base = g_file_get_child (xdg_app_dir_get_path (self), "app");
+  base = g_file_get_child (flatpak_dir_get_path (self), "app");
   dir = g_file_get_child (base, name);
 
   current_link = g_file_get_child (dir, "current");
@@ -1446,7 +1446,7 @@ xdg_app_dir_current_ref (XdgAppDir    *self,
 }
 
 gboolean
-xdg_app_dir_drop_current_ref (XdgAppDir    *self,
+flatpak_dir_drop_current_ref (FlatpakDir   *self,
                               const char   *name,
                               GCancellable *cancellable,
                               GError      **error)
@@ -1455,7 +1455,7 @@ xdg_app_dir_drop_current_ref (XdgAppDir    *self,
   g_autoptr(GFile) dir = NULL;
   g_autoptr(GFile) current_link = NULL;
 
-  base = g_file_get_child (xdg_app_dir_get_path (self), "app");
+  base = g_file_get_child (flatpak_dir_get_path (self), "app");
   dir = g_file_get_child (base, name);
 
   current_link = g_file_get_child (dir, "current");
@@ -1464,7 +1464,7 @@ xdg_app_dir_drop_current_ref (XdgAppDir    *self,
 }
 
 gboolean
-xdg_app_dir_make_current_ref (XdgAppDir    *self,
+flatpak_dir_make_current_ref (FlatpakDir   *self,
                               const char   *ref,
                               GCancellable *cancellable,
                               GError      **error)
@@ -1481,7 +1481,7 @@ xdg_app_dir_make_current_ref (XdgAppDir    *self,
   g_assert (g_strv_length (ref_parts) == 4);
   g_assert (strcmp (ref_parts[0], "app") == 0);
 
-  base = g_file_get_child (xdg_app_dir_get_path (self), ref_parts[0]);
+  base = g_file_get_child (flatpak_dir_get_path (self), ref_parts[0]);
   dir = g_file_get_child (base, ref_parts[1]);
 
   current_link = g_file_get_child (dir, "current");
@@ -1502,7 +1502,7 @@ out:
 }
 
 gboolean
-xdg_app_dir_list_refs_for_name (XdgAppDir    *self,
+flatpak_dir_list_refs_for_name (FlatpakDir   *self,
                                 const char   *kind,
                                 const char   *name,
                                 char       ***refs_out,
@@ -1518,7 +1518,7 @@ xdg_app_dir_list_refs_for_name (XdgAppDir    *self,
   GError *temp_error = NULL;
   g_autoptr(GPtrArray) refs = NULL;
 
-  base = g_file_get_child (xdg_app_dir_get_path (self), kind);
+  base = g_file_get_child (flatpak_dir_get_path (self), kind);
   dir = g_file_get_child (base, name);
 
   refs = g_ptr_array_new ();
@@ -1583,7 +1583,7 @@ xdg_app_dir_list_refs_for_name (XdgAppDir    *self,
   if (temp_error != NULL)
     goto out;
 
-  g_ptr_array_sort (refs, xdg_app_strcmp0_ptr);
+  g_ptr_array_sort (refs, flatpak_strcmp0_ptr);
 
   ret = TRUE;
 
@@ -1602,7 +1602,7 @@ out:
 }
 
 gboolean
-xdg_app_dir_list_refs (XdgAppDir    *self,
+flatpak_dir_list_refs (FlatpakDir   *self,
                        const char   *kind,
                        char       ***refs_out,
                        GCancellable *cancellable,
@@ -1618,7 +1618,7 @@ xdg_app_dir_list_refs (XdgAppDir    *self,
 
   refs = g_ptr_array_new ();
 
-  base = g_file_get_child (xdg_app_dir_get_path (self), kind);
+  base = g_file_get_child (flatpak_dir_get_path (self), kind);
 
   if (!g_file_query_exists (base, cancellable))
     {
@@ -1646,7 +1646,7 @@ xdg_app_dir_list_refs (XdgAppDir    *self,
 
       name = g_file_info_get_name (child_info);
 
-      if (!xdg_app_dir_list_refs_for_name (self, kind, name, &sub_refs, cancellable, error))
+      if (!flatpak_dir_list_refs_for_name (self, kind, name, &sub_refs, cancellable, error))
         goto out;
 
       for (i = 0; sub_refs[i] != NULL; i++)
@@ -1661,7 +1661,7 @@ xdg_app_dir_list_refs (XdgAppDir    *self,
 
   ret = TRUE;
 
-  g_ptr_array_sort (refs, xdg_app_strcmp0_ptr);
+  g_ptr_array_sort (refs, flatpak_strcmp0_ptr);
 
 out:
   if (ret)
@@ -1678,7 +1678,7 @@ out:
 }
 
 char *
-xdg_app_dir_read_latest (XdgAppDir    *self,
+flatpak_dir_read_latest (FlatpakDir   *self,
                          const char   *remote,
                          const char   *ref,
                          GCancellable *cancellable,
@@ -1704,7 +1704,7 @@ xdg_app_dir_read_latest (XdgAppDir    *self,
 
 
 char *
-xdg_app_dir_read_active (XdgAppDir    *self,
+flatpak_dir_read_active (FlatpakDir   *self,
                          const char   *ref,
                          GCancellable *cancellable)
 {
@@ -1712,7 +1712,7 @@ xdg_app_dir_read_active (XdgAppDir    *self,
   g_autoptr(GFile) active_link = NULL;
   g_autoptr(GFileInfo) file_info = NULL;
 
-  deploy_base = xdg_app_dir_get_deploy_dir (self, ref);
+  deploy_base = flatpak_dir_get_deploy_dir (self, ref);
   active_link = g_file_get_child (deploy_base, "active");
 
   file_info = g_file_query_info (active_link, OSTREE_GIO_FAST_QUERYINFO,
@@ -1725,7 +1725,7 @@ xdg_app_dir_read_active (XdgAppDir    *self,
 }
 
 gboolean
-xdg_app_dir_set_active (XdgAppDir    *self,
+flatpak_dir_set_active (FlatpakDir   *self,
                         const char   *ref,
                         const char   *checksum,
                         GCancellable *cancellable,
@@ -1739,7 +1739,7 @@ xdg_app_dir_set_active (XdgAppDir    *self,
   g_autoptr(GFile) active_link = NULL;
   g_autoptr(GError) my_error = NULL;
 
-  deploy_base = xdg_app_dir_get_deploy_dir (self, ref);
+  deploy_base = flatpak_dir_get_deploy_dir (self, ref);
   active_link = g_file_get_child (deploy_base, "active");
 
   if (checksum != NULL)
@@ -1772,7 +1772,7 @@ out:
 
 
 gboolean
-xdg_app_dir_run_triggers (XdgAppDir    *self,
+flatpak_dir_run_triggers (FlatpakDir   *self,
                           GCancellable *cancellable,
                           GError      **error)
 {
@@ -1784,9 +1784,9 @@ xdg_app_dir_run_triggers (XdgAppDir    *self,
   GError *temp_error = NULL;
   const char *triggerspath;
 
-  triggerspath = g_getenv ("XDG_APP_TRIGGERSDIR");
+  triggerspath = g_getenv ("FLATPAK_TRIGGERSDIR");
   if (triggerspath == NULL)
-    triggerspath = XDG_APP_TRIGGERDIR;
+    triggerspath = FLATPAK_TRIGGERDIR;
 
   g_debug ("running triggers from %s", triggerspath);
 
@@ -1819,7 +1819,7 @@ xdg_app_dir_run_triggers (XdgAppDir    *self,
           g_ptr_array_add (argv_array, g_file_get_path (child));
           g_ptr_array_add (argv_array, g_file_get_path (self->basedir));
 #else
-          g_ptr_array_add (argv_array, g_strdup (xdg_app_get_bwrap ()));
+          g_ptr_array_add (argv_array, g_strdup (flatpak_get_bwrap ()));
           g_ptr_array_add (argv_array, g_strdup ("--unshare-ipc"));
           g_ptr_array_add (argv_array, g_strdup ("--unshare-net"));
           g_ptr_array_add (argv_array, g_strdup ("--unshare-pid"));
@@ -2009,7 +2009,7 @@ export_desktop_file (const char   *app,
 
       if (dbus_name == NULL || strcmp (dbus_name, expected_dbus_name) != 0)
         {
-          xdg_app_fail (error, "dbus service file %s has wrong name", name);
+          flatpak_fail (error, "dbus service file %s has wrong name", name);
           return FALSE;
         }
     }
@@ -2026,7 +2026,7 @@ export_desktop_file (const char   *app,
         {
           g_key_file_set_string_list (keyfile,
                                       "Desktop Entry",
-                                      "X-XdgApp-Tags",
+                                      "X-Flatpak-Tags",
                                       (const char * const *) tags, length);
         }
     }
@@ -2041,7 +2041,7 @@ export_desktop_file (const char   *app,
       g_key_file_remove_key (keyfile, groups[i], "X-GNOME-Bugzilla-ExtraInfoScript", NULL);
 
       new_exec = g_string_new ("");
-      g_string_append_printf (new_exec, XDG_APP_BINDIR "/xdg-app run --branch=%s --arch=%s", escaped_branch, escaped_arch);
+      g_string_append_printf (new_exec, FLATPAK_BINDIR "/xdg-app run --branch=%s --arch=%s", escaped_branch, escaped_arch);
 
       old_exec = g_key_file_get_string (keyfile, groups[i], "Exec", NULL);
       if (old_exec && g_shell_parse_argv (old_exec, &old_argc, &old_argv, NULL) && old_argc >= 1)
@@ -2154,7 +2154,7 @@ rewrite_export_dir (const char   *app,
         }
       else if (S_ISREG (stbuf.st_mode))
         {
-          if (!xdg_app_has_name_prefix (dent->d_name, app))
+          if (!flatpak_has_name_prefix (dent->d_name, app))
             {
               g_warning ("Non-prefixed filename %s in app %s, removing.\n", dent->d_name, app);
               if (unlinkat (source_iter.fd, dent->d_name, 0) != 0 && errno != ENOENT)
@@ -2200,7 +2200,7 @@ out:
 }
 
 gboolean
-xdg_app_rewrite_export_dir (const char   *app,
+flatpak_rewrite_export_dir (const char   *app,
                             const char   *branch,
                             const char   *arch,
                             GKeyFile     *metadata,
@@ -2319,7 +2319,7 @@ out:
 }
 
 gboolean
-xdg_app_export_dir (GFile        *source,
+flatpak_export_dir (GFile        *source,
                     GFile        *destination,
                     const char   *symlink_prefix,
                     GCancellable *cancellable,
@@ -2343,7 +2343,7 @@ out:
 }
 
 gboolean
-xdg_app_dir_update_exports (XdgAppDir    *self,
+flatpak_dir_update_exports (FlatpakDir   *self,
                             const char   *changed_app,
                             GCancellable *cancellable,
                             GError      **error)
@@ -2355,27 +2355,27 @@ xdg_app_dir_update_exports (XdgAppDir    *self,
   g_autofree char *active_id = NULL;
   g_autofree char *symlink_prefix = NULL;
 
-  exports = xdg_app_dir_get_exports_dir (self);
+  exports = flatpak_dir_get_exports_dir (self);
 
   if (!gs_file_ensure_directory (exports, TRUE, cancellable, error))
     goto out;
 
   if (changed_app &&
-      (current_ref = xdg_app_dir_current_ref (self, changed_app, cancellable)) &&
-      (active_id = xdg_app_dir_read_active (self, current_ref, cancellable)))
+      (current_ref = flatpak_dir_current_ref (self, changed_app, cancellable)) &&
+      (active_id = flatpak_dir_read_active (self, current_ref, cancellable)))
     {
       g_autoptr(GFile) deploy_base = NULL;
       g_autoptr(GFile) active = NULL;
       g_autoptr(GFile) export = NULL;
 
-      deploy_base = xdg_app_dir_get_deploy_dir (self, current_ref);
+      deploy_base = flatpak_dir_get_deploy_dir (self, current_ref);
       active = g_file_get_child (deploy_base, active_id);
       export = g_file_get_child (active, "export");
 
       if (g_file_query_exists (export, cancellable))
         {
           symlink_prefix = g_build_filename ("..", "app", changed_app, "current", "active", "export", NULL);
-          if (!xdg_app_export_dir (export, exports,
+          if (!flatpak_export_dir (export, exports,
                                    symlink_prefix,
                                    cancellable,
                                    error))
@@ -2383,10 +2383,10 @@ xdg_app_dir_update_exports (XdgAppDir    *self,
         }
     }
 
-  if (!xdg_app_remove_dangling_symlinks (exports, cancellable, error))
+  if (!flatpak_remove_dangling_symlinks (exports, cancellable, error))
     goto out;
 
-  if (!xdg_app_dir_run_triggers (self, cancellable, error))
+  if (!flatpak_dir_run_triggers (self, cancellable, error))
     goto out;
 
   ret = TRUE;
@@ -2396,7 +2396,7 @@ out:
 }
 
 gboolean
-xdg_app_dir_deploy (XdgAppDir           *self,
+flatpak_dir_deploy (FlatpakDir          *self,
                     const char          *origin,
                     const char          *ref,
                     const char          *checksum_or_latest,
@@ -2424,16 +2424,16 @@ xdg_app_dir_deploy (XdgAppDir           *self,
   g_autoptr(GFile) tmp_dir_template = NULL;
   g_autofree char *tmp_dir_path = NULL;
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     return FALSE;
 
-  deploy_base = xdg_app_dir_get_deploy_dir (self, ref);
+  deploy_base = flatpak_dir_get_deploy_dir (self, ref);
 
   if (checksum_or_latest == NULL)
     {
       g_debug ("No checksum specified, getting tip of %s", ref);
 
-      resolved_ref = xdg_app_dir_read_latest (self, origin, ref, cancellable, error);
+      resolved_ref = flatpak_dir_read_latest (self, origin, ref, cancellable, error);
       if (resolved_ref == NULL)
         {
           g_prefix_error (error, "While trying to resolve ref %s: ", ref);
@@ -2451,14 +2451,14 @@ xdg_app_dir_deploy (XdgAppDir           *self,
       checksum = checksum_or_latest;
       g_debug ("Looking for checksum %s in local repo", checksum);
       if (!ostree_repo_read_commit (self->repo, checksum, &root, &commit, cancellable, NULL))
-        return xdg_app_fail (error, "%s is not available", ref);
+        return flatpak_fail (error, "%s is not available", ref);
     }
 
   real_checkoutdir = g_file_get_child (deploy_base, checksum);
   if (g_file_query_exists (real_checkoutdir, cancellable))
     {
-      g_set_error (error, XDG_APP_DIR_ERROR,
-                   XDG_APP_DIR_ERROR_ALREADY_DEPLOYED,
+      g_set_error (error, FLATPAK_DIR_ERROR,
+                   FLATPAK_DIR_ERROR_ALREADY_DEPLOYED,
                    "%s branch %s already deployed", ref, checksum);
       return FALSE;
     }
@@ -2481,7 +2481,7 @@ xdg_app_dir_deploy (XdgAppDir           *self,
       return FALSE;
     }
 
-  if (!xdg_app_repo_collect_sizes (self->repo, root, &installed_size, NULL, cancellable, error))
+  if (!flatpak_repo_collect_sizes (self->repo, root, &installed_size, NULL, cancellable, error))
     return FALSE;
 
   file_info = g_file_query_info (root, OSTREE_GIO_FAST_QUERYINFO,
@@ -2618,35 +2618,35 @@ xdg_app_dir_deploy (XdgAppDir           *self,
 
       ref_parts = g_strsplit (ref, "/", -1);
 
-      if (!xdg_app_rewrite_export_dir (ref_parts[1], ref_parts[3], ref_parts[2],
+      if (!flatpak_rewrite_export_dir (ref_parts[1], ref_parts[3], ref_parts[2],
                                        keyfile, export,
                                        cancellable,
                                        error))
         return FALSE;
     }
 
-  deploy_data = xdg_app_dir_new_deploy_data (origin,
+  deploy_data = flatpak_dir_new_deploy_data (origin,
                                              checksum,
                                              (char **) subpaths,
                                              installed_size,
                                              NULL);
 
   deploy_data_file = g_file_get_child (checkoutdir, "deploy");
-  if (!xdg_app_variant_save (deploy_data_file, deploy_data, cancellable, error))
+  if (!flatpak_variant_save (deploy_data_file, deploy_data, cancellable, error))
     return FALSE;
 
   if (!g_file_move (checkoutdir, real_checkoutdir, G_FILE_COPY_NO_FALLBACK_FOR_MOVE,
                     cancellable, NULL, NULL, error))
     return FALSE;
 
-  if (!xdg_app_dir_set_active (self, ref, checksum, cancellable, error))
+  if (!flatpak_dir_set_active (self, ref, checksum, cancellable, error))
     return FALSE;
 
   return TRUE;
 }
 
 gboolean
-xdg_app_dir_deploy_install (XdgAppDir    *self,
+flatpak_dir_deploy_install (FlatpakDir   *self,
                             const char   *ref,
                             const char   *origin,
                             char        **subpaths,
@@ -2660,11 +2660,11 @@ xdg_app_dir_deploy_install (XdgAppDir    *self,
   g_autoptr(GError) local_error = NULL;
   g_auto(GStrv) ref_parts = g_strsplit (ref, "/", -1);
 
-  if (!xdg_app_dir_lock (self, &lock,
+  if (!flatpak_dir_lock (self, &lock,
                          cancellable, error))
     goto out;
 
-  deploy_base = xdg_app_dir_get_deploy_dir (self, ref);
+  deploy_base = flatpak_dir_get_deploy_dir (self, ref);
   if (!g_file_make_directory_with_parents (deploy_base, cancellable, &local_error))
     {
       if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_EXISTS))
@@ -2685,25 +2685,25 @@ xdg_app_dir_deploy_install (XdgAppDir    *self,
   /* After we create the deploy base we must goto out on errors */
   created_deploy_base = TRUE;
 
-  if (!xdg_app_dir_deploy (self, origin, ref, NULL, (const char * const *) subpaths, NULL, cancellable, error))
+  if (!flatpak_dir_deploy (self, origin, ref, NULL, (const char * const *) subpaths, NULL, cancellable, error))
     goto out;
 
   if (g_str_has_prefix (ref, "app/"))
     {
 
-      if (!xdg_app_dir_make_current_ref (self, ref, cancellable, error))
+      if (!flatpak_dir_make_current_ref (self, ref, cancellable, error))
         goto out;
 
-      if (!xdg_app_dir_update_exports (self, ref_parts[1], cancellable, error))
+      if (!flatpak_dir_update_exports (self, ref_parts[1], cancellable, error))
         goto out;
     }
 
   /* Release lock before doing possibly slow prune */
   glnx_release_lock_file (&lock);
 
-  xdg_app_dir_cleanup_removed (self, cancellable, NULL);
+  flatpak_dir_cleanup_removed (self, cancellable, NULL);
 
-  if (!xdg_app_dir_mark_changed (self, error))
+  if (!flatpak_dir_mark_changed (self, error))
     goto out;
 
   ret = TRUE;
@@ -2717,7 +2717,7 @@ out:
 
 
 gboolean
-xdg_app_dir_deploy_update (XdgAppDir    *self,
+flatpak_dir_deploy_update (FlatpakDir   *self,
                            const char   *ref,
                            const char   *checksum_or_latest,
                            GCancellable *cancellable,
@@ -2732,19 +2732,19 @@ xdg_app_dir_deploy_update (XdgAppDir    *self,
   const char *old_active;
   const char *old_origin;
 
-  if (!xdg_app_dir_lock (self, &lock,
+  if (!flatpak_dir_lock (self, &lock,
                          cancellable, error))
     return FALSE;
 
-  old_deploy_data = xdg_app_dir_get_deploy_data (self, ref,
+  old_deploy_data = flatpak_dir_get_deploy_data (self, ref,
                                                  cancellable, error);
   if (old_deploy_data == NULL)
     return FALSE;
 
-  old_origin = xdg_app_deploy_data_get_origin (old_deploy_data);
-  old_active = xdg_app_deploy_data_get_commit (old_deploy_data);
-  old_subpaths = xdg_app_deploy_data_get_subpaths (old_deploy_data);
-  if (!xdg_app_dir_deploy (self,
+  old_origin = flatpak_deploy_data_get_origin (old_deploy_data);
+  old_active = flatpak_deploy_data_get_commit (old_deploy_data);
+  old_subpaths = flatpak_deploy_data_get_subpaths (old_deploy_data);
+  if (!flatpak_dir_deploy (self,
                            old_origin,
                            ref,
                            checksum_or_latest,
@@ -2752,15 +2752,15 @@ xdg_app_dir_deploy_update (XdgAppDir    *self,
                            old_deploy_data,
                            cancellable, &my_error))
     {
-      if (g_error_matches (my_error, XDG_APP_DIR_ERROR,
-                           XDG_APP_DIR_ERROR_ALREADY_DEPLOYED))
+      if (g_error_matches (my_error, FLATPAK_DIR_ERROR,
+                           FLATPAK_DIR_ERROR_ALREADY_DEPLOYED))
         return TRUE;
 
       g_propagate_error (error, my_error);
       return FALSE;
     }
 
-  if (!xdg_app_dir_undeploy (self, ref, old_active,
+  if (!flatpak_dir_undeploy (self, ref, old_active,
                              FALSE,
                              cancellable, error))
     return FALSE;
@@ -2769,26 +2769,26 @@ xdg_app_dir_deploy_update (XdgAppDir    *self,
     {
       g_auto(GStrv) ref_parts = g_strsplit (ref, "/", -1);
 
-      if (!xdg_app_dir_update_exports (self, ref_parts[1], cancellable, error))
+      if (!flatpak_dir_update_exports (self, ref_parts[1], cancellable, error))
         return FALSE;
     }
 
   /* Release lock before doing possibly slow prune */
   glnx_release_lock_file (&lock);
 
-  if (!xdg_app_dir_prune (self, cancellable, error))
+  if (!flatpak_dir_prune (self, cancellable, error))
     return FALSE;
 
-  if (!xdg_app_dir_mark_changed (self, error))
+  if (!flatpak_dir_mark_changed (self, error))
     return FALSE;
 
-  xdg_app_dir_cleanup_removed (self, cancellable, NULL);
+  flatpak_dir_cleanup_removed (self, cancellable, NULL);
 
   return TRUE;
 }
 
 static OstreeRepo *
-xdg_app_dir_create_system_child_repo (XdgAppDir    *self,
+flatpak_dir_create_system_child_repo (FlatpakDir   *self,
                                       GLnxLockFile *file_lock,
                                       GError      **error)
 {
@@ -2802,14 +2802,14 @@ xdg_app_dir_create_system_child_repo (XdgAppDir    *self,
 
   g_assert (!self->user);
 
-  if (!xdg_app_dir_ensure_repo (self, NULL, error))
+  if (!flatpak_dir_ensure_repo (self, NULL, error))
     return NULL;
 
-  cache_dir = xdg_app_ensure_user_cache_dir_location (error);
+  cache_dir = flatpak_ensure_user_cache_dir_location (error);
   if (cache_dir == NULL)
     return NULL;
 
-  if (!xdg_app_allocate_tmpdir (AT_FDCWD,
+  if (!flatpak_allocate_tmpdir (AT_FDCWD,
                                 gs_file_get_path_cached (cache_dir),
                                 "repo-", &tmpdir_name,
                                 NULL,
@@ -2853,7 +2853,7 @@ xdg_app_dir_create_system_child_repo (XdgAppDir    *self,
 }
 
 gboolean
-xdg_app_dir_install (XdgAppDir           *self,
+flatpak_dir_install (FlatpakDir          *self,
                      gboolean             no_pull,
                      gboolean             no_deploy,
                      const char          *ref,
@@ -2863,7 +2863,7 @@ xdg_app_dir_install (XdgAppDir           *self,
                      GCancellable        *cancellable,
                      GError             **error)
 {
-  if (xdg_app_dir_use_child_repo (self))
+  if (flatpak_dir_use_child_repo (self))
     {
       g_autoptr(OstreeRepo) child_repo = NULL;
       g_auto(GLnxLockFile) child_repo_lock = GLNX_LOCK_FILE_INIT;
@@ -2871,27 +2871,27 @@ xdg_app_dir_install (XdgAppDir           *self,
       XdgAppSystemHelper *system_helper;
 
       if (no_pull)
-        return xdg_app_fail (error, "No-pull install not supported without root permissions");
+        return flatpak_fail (error, "No-pull install not supported without root permissions");
 
       if (no_deploy)
-        return xdg_app_fail (error, "No-deploy install not supported without root permissions");
+        return flatpak_fail (error, "No-deploy install not supported without root permissions");
 
-      child_repo = xdg_app_dir_create_system_child_repo (self, &child_repo_lock, error);
+      child_repo = flatpak_dir_create_system_child_repo (self, &child_repo_lock, error);
       if (child_repo == NULL)
         return FALSE;
 
-      system_helper = xdg_app_dir_get_system_helper (self);
+      system_helper = flatpak_dir_get_system_helper (self);
 
       g_assert (system_helper != NULL);
 
-      if (!xdg_app_dir_pull (self, remote_name, ref, subpaths,
+      if (!flatpak_dir_pull (self, remote_name, ref, subpaths,
                              child_repo, OSTREE_REPO_PULL_FLAGS_MIRROR,
                              progress, cancellable, error))
         return FALSE;
 
       if (!xdg_app_system_helper_call_deploy_sync (system_helper,
                                                    gs_file_get_path_cached (ostree_repo_get_path (child_repo)),
-                                                   XDG_APP_HELPER_DEPLOY_FLAGS_NONE,
+                                                   FLATPAK_HELPER_DEPLOY_FLAGS_NONE,
                                                    ref,
                                                    remote_name,
                                                    (const char * const *) (subpaths ? subpaths : empty_subpaths),
@@ -2909,14 +2909,14 @@ xdg_app_dir_install (XdgAppDir           *self,
 
   if (!no_pull)
     {
-      if (!xdg_app_dir_pull (self, remote_name, ref, subpaths, NULL, OSTREE_REPO_PULL_FLAGS_NONE, progress,
+      if (!flatpak_dir_pull (self, remote_name, ref, subpaths, NULL, OSTREE_REPO_PULL_FLAGS_NONE, progress,
                              cancellable, error))
         return FALSE;
     }
 
   if (!no_deploy)
     {
-      if (!xdg_app_dir_deploy_install (self, ref, remote_name, subpaths,
+      if (!flatpak_dir_deploy_install (self, ref, remote_name, subpaths,
                                        cancellable, error))
         return FALSE;
     }
@@ -2925,7 +2925,7 @@ xdg_app_dir_install (XdgAppDir           *self,
 }
 
 gboolean
-xdg_app_dir_update (XdgAppDir           *self,
+flatpak_dir_update (FlatpakDir          *self,
                     gboolean             no_pull,
                     gboolean             no_deploy,
                     const char          *ref,
@@ -2936,7 +2936,7 @@ xdg_app_dir_update (XdgAppDir           *self,
                     GCancellable        *cancellable,
                     GError             **error)
 {
-  if (xdg_app_dir_use_child_repo (self))
+  if (flatpak_dir_use_child_repo (self))
     {
       g_autoptr(OstreeRepo) child_repo = NULL;
       g_auto(GLnxLockFile) child_repo_lock = GLNX_LOCK_FILE_INIT;
@@ -2946,23 +2946,23 @@ xdg_app_dir_update (XdgAppDir           *self,
       XdgAppSystemHelper *system_helper;
 
       if (no_pull)
-        return xdg_app_fail (error, "No-pull update not supported without root permissions");
+        return flatpak_fail (error, "No-pull update not supported without root permissions");
 
       if (no_deploy)
-        return xdg_app_fail (error, "No-deploy update not supported without root permissions");
+        return flatpak_fail (error, "No-deploy update not supported without root permissions");
 
       if (checksum_or_latest != NULL)
-        return xdg_app_fail (error, "Can't update to a specific commit without root permissions");
+        return flatpak_fail (error, "Can't update to a specific commit without root permissions");
 
-      child_repo = xdg_app_dir_create_system_child_repo (self, &child_repo_lock, error);
+      child_repo = flatpak_dir_create_system_child_repo (self, &child_repo_lock, error);
       if (child_repo == NULL)
         return FALSE;
 
-      system_helper = xdg_app_dir_get_system_helper (self);
+      system_helper = flatpak_dir_get_system_helper (self);
 
       g_assert (system_helper != NULL);
 
-      if (!xdg_app_dir_pull (self, remote_name, ref, subpaths,
+      if (!flatpak_dir_pull (self, remote_name, ref, subpaths,
                              child_repo, OSTREE_REPO_PULL_FLAGS_MIRROR,
                              progress, cancellable, error))
         return FALSE;
@@ -2970,13 +2970,13 @@ xdg_app_dir_update (XdgAppDir           *self,
       if (!ostree_repo_resolve_rev (child_repo, ref, FALSE, &pulled_checksum, error))
         return FALSE;
 
-      active_checksum = xdg_app_dir_read_active (self, ref, NULL);
+      active_checksum = flatpak_dir_read_active (self, ref, NULL);
       if (g_strcmp0 (active_checksum, pulled_checksum) != 0)
         {
 
           if (!xdg_app_system_helper_call_deploy_sync (system_helper,
                                                        gs_file_get_path_cached (ostree_repo_get_path (child_repo)),
-                                                       XDG_APP_HELPER_DEPLOY_FLAGS_UPDATE,
+                                                       FLATPAK_HELPER_DEPLOY_FLAGS_UPDATE,
                                                        ref,
                                                        remote_name,
                                                        (const char * const *) empty_subpaths,
@@ -2995,7 +2995,7 @@ xdg_app_dir_update (XdgAppDir           *self,
 
   if (!no_pull)
     {
-      if (!xdg_app_dir_pull (self, remote_name, ref, subpaths,
+      if (!flatpak_dir_pull (self, remote_name, ref, subpaths,
                              NULL, OSTREE_REPO_PULL_FLAGS_NONE, progress,
                              cancellable, error))
         return FALSE;
@@ -3003,7 +3003,7 @@ xdg_app_dir_update (XdgAppDir           *self,
 
   if (!no_deploy)
     {
-      if (!xdg_app_dir_deploy_update (self, ref, checksum_or_latest,
+      if (!flatpak_dir_deploy_update (self, ref, checksum_or_latest,
                                       cancellable, error))
         return FALSE;
     }
@@ -3014,7 +3014,7 @@ xdg_app_dir_update (XdgAppDir           *self,
 
 
 gboolean
-xdg_app_dir_collect_deployed_refs (XdgAppDir    *self,
+flatpak_dir_collect_deployed_refs (FlatpakDir   *self,
                                    const char   *type,
                                    const char   *name_prefix,
                                    const char   *branch,
@@ -3072,7 +3072,7 @@ out:
 }
 
 gboolean
-xdg_app_dir_list_deployed (XdgAppDir    *self,
+flatpak_dir_list_deployed (FlatpakDir   *self,
                            const char   *ref,
                            char       ***deployed_checksums,
                            GCancellable *cancellable,
@@ -3088,7 +3088,7 @@ xdg_app_dir_list_deployed (XdgAppDir    *self,
   g_autoptr(GFileInfo) child_info = NULL;
   g_autoptr(GError) my_error = NULL;
 
-  deploy_base = xdg_app_dir_get_deploy_dir (self, ref);
+  deploy_base = flatpak_dir_get_deploy_dir (self, ref);
 
   checksums = g_ptr_array_new_with_free_func (g_free);
 
@@ -3167,7 +3167,7 @@ dir_is_locked (GFile *dir)
 }
 
 gboolean
-xdg_app_dir_undeploy (XdgAppDir    *self,
+flatpak_dir_undeploy (FlatpakDir   *self,
                       const char   *ref,
                       const char   *checksum,
                       gboolean      force_remove,
@@ -3187,21 +3187,21 @@ xdg_app_dir_undeploy (XdgAppDir    *self,
   g_assert (ref != NULL);
   g_assert (checksum != NULL);
 
-  deploy_base = xdg_app_dir_get_deploy_dir (self, ref);
+  deploy_base = flatpak_dir_get_deploy_dir (self, ref);
 
   checkoutdir = g_file_get_child (deploy_base, checksum);
   if (!g_file_query_exists (checkoutdir, cancellable))
     {
-      g_set_error (error, XDG_APP_DIR_ERROR,
-                   XDG_APP_DIR_ERROR_ALREADY_UNDEPLOYED,
+      g_set_error (error, FLATPAK_DIR_ERROR,
+                   FLATPAK_DIR_ERROR_ALREADY_UNDEPLOYED,
                    "%s branch %s already undeployed", ref, checksum);
       goto out;
     }
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     goto out;
 
-  active = xdg_app_dir_read_active (self, ref, cancellable);
+  active = flatpak_dir_read_active (self, ref, cancellable);
   if (active != NULL && strcmp (active, checksum) == 0)
     {
       g_auto(GStrv) deployed_checksums = NULL;
@@ -3210,7 +3210,7 @@ xdg_app_dir_undeploy (XdgAppDir    *self,
       /* We're removing the active deployment, start by repointing that
          to another deployment if one exists */
 
-      if (!xdg_app_dir_list_deployed (self, ref,
+      if (!flatpak_dir_list_deployed (self, ref,
                                       &deployed_checksums,
                                       cancellable, error))
         goto out;
@@ -3225,11 +3225,11 @@ xdg_app_dir_undeploy (XdgAppDir    *self,
           break;
         }
 
-      if (!xdg_app_dir_set_active (self, ref, some_deployment, cancellable, error))
+      if (!flatpak_dir_set_active (self, ref, some_deployment, cancellable, error))
         goto out;
     }
 
-  removed_dir = xdg_app_dir_get_removed_dir (self);
+  removed_dir = flatpak_dir_get_removed_dir (self);
   if (!gs_file_ensure_directory (removed_dir, TRUE, cancellable, error))
     goto out;
 
@@ -3258,7 +3258,7 @@ out:
 }
 
 gboolean
-xdg_app_dir_undeploy_all (XdgAppDir    *self,
+flatpak_dir_undeploy_all (FlatpakDir   *self,
                           const char   *ref,
                           gboolean      force_remove,
                           gboolean     *was_deployed_out,
@@ -3273,17 +3273,17 @@ xdg_app_dir_undeploy_all (XdgAppDir    *self,
   int i;
   gboolean was_deployed;
 
-  if (!xdg_app_dir_list_deployed (self, ref, &deployed, cancellable, error))
+  if (!flatpak_dir_list_deployed (self, ref, &deployed, cancellable, error))
     return FALSE;
 
   for (i = 0; deployed[i] != NULL; i++)
     {
       g_debug ("undeploying %s", deployed[i]);
-      if (!xdg_app_dir_undeploy (self, ref, deployed[i], force_remove, cancellable, error))
+      if (!flatpak_dir_undeploy (self, ref, deployed[i], force_remove, cancellable, error))
         return FALSE;
     }
 
-  deploy_base = xdg_app_dir_get_deploy_dir (self, ref);
+  deploy_base = flatpak_dir_get_deploy_dir (self, ref);
   was_deployed = g_file_query_exists (deploy_base, cancellable);
   if (was_deployed)
     {
@@ -3324,7 +3324,7 @@ xdg_app_dir_undeploy_all (XdgAppDir    *self,
 }
 
 gboolean
-xdg_app_dir_remove_ref (XdgAppDir    *self,
+flatpak_dir_remove_ref (FlatpakDir   *self,
                         const char   *remote_name,
                         const char   *ref,
                         GCancellable *cancellable,
@@ -3337,7 +3337,7 @@ xdg_app_dir_remove_ref (XdgAppDir    *self,
 }
 
 gboolean
-xdg_app_dir_cleanup_removed (XdgAppDir    *self,
+flatpak_dir_cleanup_removed (FlatpakDir   *self,
                              GCancellable *cancellable,
                              GError      **error)
 {
@@ -3348,7 +3348,7 @@ xdg_app_dir_cleanup_removed (XdgAppDir    *self,
   g_autoptr(GFileInfo) child_info = NULL;
   GError *temp_error = NULL;
 
-  removed_dir = xdg_app_dir_get_removed_dir (self);
+  removed_dir = flatpak_dir_get_removed_dir (self);
   if (!g_file_query_exists (removed_dir, cancellable))
     return TRUE;
 
@@ -3391,7 +3391,7 @@ out:
 
 
 gboolean
-xdg_app_dir_prune (XdgAppDir    *self,
+flatpak_dir_prune (FlatpakDir   *self,
                    GCancellable *cancellable,
                    GError      **error)
 {
@@ -3400,7 +3400,7 @@ xdg_app_dir_prune (XdgAppDir    *self,
   guint64 pruned_object_size_total;
   g_autofree char *formatted_freed_size = NULL;
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     goto out;
 
   if (!ostree_repo_prune (self->repo,
@@ -3422,7 +3422,7 @@ out:
 }
 
 GFile *
-xdg_app_dir_get_if_deployed (XdgAppDir    *self,
+flatpak_dir_get_if_deployed (FlatpakDir   *self,
                              const char   *ref,
                              const char   *checksum,
                              GCancellable *cancellable)
@@ -3430,7 +3430,7 @@ xdg_app_dir_get_if_deployed (XdgAppDir    *self,
   g_autoptr(GFile) deploy_base = NULL;
   g_autoptr(GFile) deploy_dir = NULL;
 
-  deploy_base = xdg_app_dir_get_deploy_dir (self, ref);
+  deploy_base = flatpak_dir_get_deploy_dir (self, ref);
 
   if (checksum != NULL)
     {
@@ -3463,7 +3463,7 @@ xdg_app_dir_get_if_deployed (XdgAppDir    *self,
 }
 
 static gboolean
-xdg_app_dir_remote_fetch_summary (XdgAppDir    *self,
+flatpak_dir_remote_fetch_summary (FlatpakDir   *self,
                                   const char   *name,
                                   GBytes      **out_summary,
                                   GCancellable *cancellable,
@@ -3480,7 +3480,7 @@ xdg_app_dir_remote_fetch_summary (XdgAppDir    *self,
 }
 
 char *
-xdg_app_dir_find_remote_ref (XdgAppDir    *self,
+flatpak_dir_find_remote_ref (FlatpakDir   *self,
                              const char   *remote,
                              const char   *name,
                              const char   *opt_branch,
@@ -3500,12 +3500,12 @@ xdg_app_dir_find_remote_ref (XdgAppDir    *self,
   g_autoptr(GVariant) refs = NULL;
   g_autoptr(GBytes) summary_bytes = NULL;
 
-  if (!xdg_app_dir_ensure_repo (self, NULL, error))
+  if (!flatpak_dir_ensure_repo (self, NULL, error))
     return NULL;
 
   if (app)
     {
-      app_ref = xdg_app_compose_ref (TRUE, name, opt_branch, opt_arch, error);
+      app_ref = flatpak_compose_ref (TRUE, name, opt_branch, opt_arch, error);
       if (app_ref == NULL)
         return NULL;
       app_ref_with_remote = g_strconcat (remote, ":", app_ref, NULL);
@@ -3513,7 +3513,7 @@ xdg_app_dir_find_remote_ref (XdgAppDir    *self,
 
   if (runtime)
     {
-      runtime_ref = xdg_app_compose_ref (FALSE, name, opt_branch, opt_arch, error);
+      runtime_ref = flatpak_compose_ref (FALSE, name, opt_branch, opt_arch, error);
       if (runtime_ref == NULL)
         return NULL;
       runtime_ref_with_remote = g_strconcat (remote, ":", app_ref, NULL);
@@ -3539,7 +3539,7 @@ xdg_app_dir_find_remote_ref (XdgAppDir    *self,
       return g_steal_pointer (&runtime_ref);
     }
 
-  if (!xdg_app_dir_remote_fetch_summary (self, remote,
+  if (!flatpak_dir_remote_fetch_summary (self, remote,
                                          &summary_bytes,
                                          cancellable, error))
     return NULL;
@@ -3554,14 +3554,14 @@ xdg_app_dir_find_remote_ref (XdgAppDir    *self,
   summary = g_variant_ref_sink (g_variant_new_from_bytes (OSTREE_SUMMARY_GVARIANT_FORMAT, summary_bytes, FALSE));
   refs = g_variant_get_child_value (summary, 0);
 
-  if (app_ref && xdg_app_summary_lookup_ref (summary, app_ref, NULL))
+  if (app_ref && flatpak_summary_lookup_ref (summary, app_ref, NULL))
     {
       if (is_app)
         *is_app = TRUE;
       return g_steal_pointer (&app_ref);
     }
 
-  if (runtime_ref && xdg_app_summary_lookup_ref (summary, runtime_ref, NULL))
+  if (runtime_ref && flatpak_summary_lookup_ref (summary, runtime_ref, NULL))
     {
       if (is_app)
         *is_app = FALSE;
@@ -3575,7 +3575,7 @@ xdg_app_dir_find_remote_ref (XdgAppDir    *self,
 }
 
 char *
-xdg_app_dir_find_installed_ref (XdgAppDir  *self,
+flatpak_dir_find_installed_ref (FlatpakDir *self,
                                 const char *name,
                                 const char *opt_branch,
                                 const char *opt_arch,
@@ -3589,12 +3589,12 @@ xdg_app_dir_find_installed_ref (XdgAppDir  *self,
       g_autofree char *app_ref = NULL;
       g_autoptr(GFile) deploy_base = NULL;
 
-      app_ref = xdg_app_compose_ref (TRUE, name, opt_branch, opt_arch, error);
+      app_ref = flatpak_compose_ref (TRUE, name, opt_branch, opt_arch, error);
       if (app_ref == NULL)
         return NULL;
 
 
-      deploy_base = xdg_app_dir_get_deploy_dir (self, app_ref);
+      deploy_base = flatpak_dir_get_deploy_dir (self, app_ref);
       if (g_file_query_exists (deploy_base, NULL))
         {
           if (is_app)
@@ -3608,11 +3608,11 @@ xdg_app_dir_find_installed_ref (XdgAppDir  *self,
       g_autofree char *runtime_ref = NULL;
       g_autoptr(GFile) deploy_base = NULL;
 
-      runtime_ref = xdg_app_compose_ref (FALSE, name, opt_branch, opt_arch, error);
+      runtime_ref = flatpak_compose_ref (FALSE, name, opt_branch, opt_arch, error);
       if (runtime_ref == NULL)
         return NULL;
 
-      deploy_base = xdg_app_dir_get_deploy_dir (self, runtime_ref);
+      deploy_base = flatpak_dir_get_deploy_dir (self, runtime_ref);
       if (g_file_query_exists (deploy_base, NULL))
         {
           if (is_app)
@@ -3626,39 +3626,39 @@ xdg_app_dir_find_installed_ref (XdgAppDir  *self,
   return NULL;
 }
 
-XdgAppDir *
-xdg_app_dir_new (GFile *path, gboolean user)
+FlatpakDir *
+flatpak_dir_new (GFile *path, gboolean user)
 {
-  return g_object_new (XDG_APP_TYPE_DIR, "path", path, "user", user, NULL);
+  return g_object_new (FLATPAK_TYPE_DIR, "path", path, "user", user, NULL);
 }
 
-XdgAppDir *
-xdg_app_dir_clone (XdgAppDir *self)
+FlatpakDir *
+flatpak_dir_clone (FlatpakDir *self)
 {
-  return xdg_app_dir_new (self->basedir, self->user);
+  return flatpak_dir_new (self->basedir, self->user);
 }
 
-XdgAppDir *
-xdg_app_dir_get_system (void)
+FlatpakDir *
+flatpak_dir_get_system (void)
 {
-  g_autoptr(GFile) path = xdg_app_get_system_base_dir_location ();
-  return xdg_app_dir_new (path, FALSE);
+  g_autoptr(GFile) path = flatpak_get_system_base_dir_location ();
+  return flatpak_dir_new (path, FALSE);
 }
 
-XdgAppDir *
-xdg_app_dir_get_user (void)
+FlatpakDir *
+flatpak_dir_get_user (void)
 {
-  g_autoptr(GFile) path = xdg_app_get_user_base_dir_location ();
-  return xdg_app_dir_new (path, TRUE);
+  g_autoptr(GFile) path = flatpak_get_user_base_dir_location ();
+  return flatpak_dir_new (path, TRUE);
 }
 
-XdgAppDir *
-xdg_app_dir_get (gboolean user)
+FlatpakDir *
+flatpak_dir_get (gboolean user)
 {
   if (user)
-    return xdg_app_dir_get_user ();
+    return flatpak_dir_get_user ();
   else
-    return xdg_app_dir_get_system ();
+    return flatpak_dir_get_system ();
 }
 
 static char *
@@ -3668,7 +3668,7 @@ get_group (const char *remote_name)
 }
 
 char *
-xdg_app_dir_get_remote_title (XdgAppDir  *self,
+flatpak_dir_get_remote_title (FlatpakDir *self,
                               const char *remote_name)
 {
   GKeyFile *config = ostree_repo_get_config (self->repo);
@@ -3681,7 +3681,7 @@ xdg_app_dir_get_remote_title (XdgAppDir  *self,
 }
 
 int
-xdg_app_dir_get_remote_prio (XdgAppDir  *self,
+flatpak_dir_get_remote_prio (FlatpakDir *self,
                              const char *remote_name)
 {
   GKeyFile *config = ostree_repo_get_config (self->repo);
@@ -3694,7 +3694,7 @@ xdg_app_dir_get_remote_prio (XdgAppDir  *self,
 }
 
 gboolean
-xdg_app_dir_get_remote_noenumerate (XdgAppDir  *self,
+flatpak_dir_get_remote_noenumerate (FlatpakDir *self,
                                     const char *remote_name)
 {
   GKeyFile *config = ostree_repo_get_config (self->repo);
@@ -3707,7 +3707,7 @@ xdg_app_dir_get_remote_noenumerate (XdgAppDir  *self,
 }
 
 gboolean
-xdg_app_dir_get_remote_disabled (XdgAppDir  *self,
+flatpak_dir_get_remote_disabled (FlatpakDir *self,
                                  const char *remote_name)
 {
   GKeyFile *config = ostree_repo_get_config (self->repo);
@@ -3724,19 +3724,19 @@ cmp_remote (gconstpointer a,
             gconstpointer b,
             gpointer      user_data)
 {
-  XdgAppDir *self = user_data;
+  FlatpakDir *self = user_data;
   const char *a_name = *(const char **) a;
   const char *b_name = *(const char **) b;
   int prio_a, prio_b;
 
-  prio_a = xdg_app_dir_get_remote_prio (self, a_name);
-  prio_b = xdg_app_dir_get_remote_prio (self, b_name);
+  prio_a = flatpak_dir_get_remote_prio (self, a_name);
+  prio_b = flatpak_dir_get_remote_prio (self, b_name);
 
   return prio_b - prio_a;
 }
 
 char *
-xdg_app_dir_create_origin_remote (XdgAppDir    *self,
+flatpak_dir_create_origin_remote (FlatpakDir   *self,
                                   const char   *url,
                                   const char   *id,
                                   const char   *title,
@@ -3750,7 +3750,7 @@ xdg_app_dir_create_origin_remote (XdgAppDir    *self,
   int version = 0;
   g_autoptr(GVariantBuilder) optbuilder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     return FALSE;
 
   remotes = ostree_repo_remote_list (self->repo, NULL);
@@ -3804,13 +3804,13 @@ xdg_app_dir_create_origin_remote (XdgAppDir    *self,
 
 
 char **
-xdg_app_dir_list_remotes (XdgAppDir    *self,
+flatpak_dir_list_remotes (FlatpakDir   *self,
                           GCancellable *cancellable,
                           GError      **error)
 {
   char **res;
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     return NULL;
 
   res = ostree_repo_remote_list (self->repo, NULL);
@@ -3834,7 +3834,7 @@ remove_unless_in_hash (gpointer key,
 }
 
 gboolean
-xdg_app_dir_list_remote_refs (XdgAppDir    *self,
+flatpak_dir_list_remote_refs (FlatpakDir   *self,
                               const char   *remote,
                               GHashTable  **refs,
                               GCancellable *cancellable,
@@ -3845,14 +3845,14 @@ xdg_app_dir_list_remote_refs (XdgAppDir    *self,
   if (error == NULL)
     error = &my_error;
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     return FALSE;
 
   if (!ostree_repo_remote_list_refs (self->repo, remote,
                                      refs, cancellable, error))
     return FALSE;
 
-  if (xdg_app_dir_get_remote_noenumerate (self, remote))
+  if (flatpak_dir_get_remote_noenumerate (self, remote))
     {
       g_autoptr(GHashTable) unprefixed_local_refs = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
       g_autoptr(GHashTable) local_refs = NULL;
@@ -3888,7 +3888,7 @@ xdg_app_dir_list_remote_refs (XdgAppDir    *self,
 }
 
 char *
-xdg_app_dir_fetch_remote_title (XdgAppDir    *self,
+flatpak_dir_fetch_remote_title (FlatpakDir   *self,
                                 const char   *remote,
                                 GCancellable *cancellable,
                                 GError      **error)
@@ -3903,10 +3903,10 @@ xdg_app_dir_fetch_remote_title (XdgAppDir    *self,
   if (error == NULL)
     error = &my_error;
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     return NULL;
 
-  if (!xdg_app_dir_remote_fetch_summary (self, remote,
+  if (!flatpak_dir_remote_fetch_summary (self, remote,
                                          &summary_bytes,
                                          cancellable, error))
     return FALSE;
@@ -3937,7 +3937,7 @@ xdg_app_dir_fetch_remote_title (XdgAppDir    *self,
 }
 
 static void
-ensure_soup_session (XdgAppDir *self)
+ensure_soup_session (FlatpakDir *self)
 {
   const char *http_proxy;
 
@@ -3971,7 +3971,7 @@ ensure_soup_session (XdgAppDir *self)
 }
 
 static GBytes *
-xdg_app_dir_load_uri (XdgAppDir    *self,
+flatpak_dir_load_uri (FlatpakDir   *self,
                       const char   *uri,
                       GCancellable *cancellable,
                       GError      **error)
@@ -4043,7 +4043,7 @@ xdg_app_dir_load_uri (XdgAppDir    *self,
 }
 
 GBytes *
-xdg_app_dir_fetch_remote_object (XdgAppDir    *self,
+flatpak_dir_fetch_remote_object (FlatpakDir   *self,
                                  const char   *remote_name,
                                  const char   *checksum,
                                  const char   *type,
@@ -4065,7 +4065,7 @@ xdg_app_dir_fetch_remote_object (XdgAppDir    *self,
 
   object_url = g_build_filename (base_url, "objects", part1, part2, NULL);
 
-  bytes = xdg_app_dir_load_uri (self, object_url, cancellable, error);
+  bytes = flatpak_dir_load_uri (self, object_url, cancellable, error);
   if (bytes == NULL)
     return NULL;
 
@@ -4073,7 +4073,7 @@ xdg_app_dir_fetch_remote_object (XdgAppDir    *self,
 }
 
 gboolean
-xdg_app_dir_fetch_ref_cache (XdgAppDir    *self,
+flatpak_dir_fetch_ref_cache (FlatpakDir   *self,
                              const char   *remote_name,
                              const char   *ref,
                              guint64      *download_size,
@@ -4089,10 +4089,10 @@ xdg_app_dir_fetch_ref_cache (XdgAppDir    *self,
   g_autoptr(GVariant) cache = NULL;
   g_autoptr(GVariant) res = NULL;
 
-  if (!xdg_app_dir_ensure_repo (self, cancellable, error))
+  if (!flatpak_dir_ensure_repo (self, cancellable, error))
     return FALSE;
 
-  if (!xdg_app_dir_remote_fetch_summary (self, remote_name,
+  if (!flatpak_dir_remote_fetch_summary (self, remote_name,
                                          &summary_bytes,
                                          cancellable, error))
     return FALSE;
@@ -4146,7 +4146,7 @@ xdg_app_dir_fetch_ref_cache (XdgAppDir    *self,
 }
 
 GBytes *
-xdg_app_dir_fetch_metadata (XdgAppDir    *self,
+flatpak_dir_fetch_metadata (FlatpakDir   *self,
                             const char   *remote_name,
                             const char   *commit,
                             GCancellable *cancellable,
@@ -4170,7 +4170,7 @@ xdg_app_dir_fetch_metadata (XdgAppDir    *self,
   guint32 archive_header_size;
   int i, n;
 
-  commit_bytes = xdg_app_dir_fetch_remote_object (self, remote_name,
+  commit_bytes = flatpak_dir_fetch_remote_object (self, remote_name,
                                                   commit, "commit",
                                                   cancellable, error);
   if (commit_bytes == NULL)
@@ -4185,7 +4185,7 @@ xdg_app_dir_fetch_metadata (XdgAppDir    *self,
   g_variant_get_child (commit_variant, 6, "@ay", &root_csum);
   root_checksum = ostree_checksum_from_bytes_v (root_csum);
 
-  root_bytes = xdg_app_dir_fetch_remote_object (self, remote_name,
+  root_bytes = flatpak_dir_fetch_remote_object (self, remote_name,
                                                 root_checksum, "dirtree",
                                                 cancellable, error);
   if (root_bytes == NULL)
@@ -4221,7 +4221,7 @@ xdg_app_dir_fetch_metadata (XdgAppDir    *self,
       return NULL;
     }
 
-  filez_bytes = xdg_app_dir_fetch_remote_object (self, remote_name,
+  filez_bytes = flatpak_dir_fetch_remote_object (self, remote_name,
                                                  file_checksum, "filez",
                                                  cancellable, error);
   if (filez_bytes == NULL)
diff --git a/common/xdg-app-dir.h b/common/xdg-app-dir.h
index bb7c1b4..cfedccd 100644
--- a/common/xdg-app-dir.h
+++ b/common/xdg-app-dir.h
@@ -18,47 +18,47 @@
  *       Alexander Larsson <alexl@redhat.com>
  */
 
-#ifndef __XDG_APP_DIR_H__
-#define __XDG_APP_DIR_H__
+#ifndef __FLATPAK_DIR_H__
+#define __FLATPAK_DIR_H__
 
 #include <ostree.h>
 
 #include "libglnx/libglnx.h"
 #include <xdg-app-common-types.h>
 
-#define XDG_APP_TYPE_DIR xdg_app_dir_get_type ()
-#define XDG_APP_DIR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XDG_APP_TYPE_DIR, XdgAppDir))
-#define XDG_APP_IS_DIR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), XDG_APP_TYPE_DIR))
+#define FLATPAK_TYPE_DIR flatpak_dir_get_type ()
+#define FLATPAK_DIR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FLATPAK_TYPE_DIR, FlatpakDir))
+#define FLATPAK_IS_DIR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FLATPAK_TYPE_DIR))
 
-#define XDG_APP_TYPE_DEPLOY xdg_app_deploy_get_type ()
-#define XDG_APP_DEPLOY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XDG_APP_TYPE_DEPLOY, XdgAppDeploy))
-#define XDG_APP_IS_DEPLOY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), XDG_APP_TYPE_DEPLOY))
+#define FLATPAK_TYPE_DEPLOY flatpak_deploy_get_type ()
+#define FLATPAK_DEPLOY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FLATPAK_TYPE_DEPLOY, FlatpakDeploy))
+#define FLATPAK_IS_DEPLOY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FLATPAK_TYPE_DEPLOY))
 
-GType xdg_app_dir_get_type (void);
-GType xdg_app_deploy_get_type (void);
+GType flatpak_dir_get_type (void);
+GType flatpak_deploy_get_type (void);
 
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (XdgAppDir, g_object_unref)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (XdgAppDeploy, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FlatpakDir, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FlatpakDeploy, g_object_unref)
 
-#define XDG_APP_DIR_ERROR xdg_app_dir_error_quark ()
+#define FLATPAK_DIR_ERROR flatpak_dir_error_quark ()
 
 typedef enum {
-  XDG_APP_DIR_ERROR_ALREADY_DEPLOYED,
-  XDG_APP_DIR_ERROR_ALREADY_UNDEPLOYED,
-  XDG_APP_DIR_ERROR_NOT_DEPLOYED,
-} XdgAppDirErrorEnum;
+  FLATPAK_DIR_ERROR_ALREADY_DEPLOYED,
+  FLATPAK_DIR_ERROR_ALREADY_UNDEPLOYED,
+  FLATPAK_DIR_ERROR_NOT_DEPLOYED,
+} FlatpakDirErrorEnum;
 
 typedef enum {
-  XDG_APP_HELPER_DEPLOY_FLAGS_NONE = 0,
-  XDG_APP_HELPER_DEPLOY_FLAGS_UPDATE = 1 << 0,
-} XdgAppHelperDeployFlags;
+  FLATPAK_HELPER_DEPLOY_FLAGS_NONE = 0,
+  FLATPAK_HELPER_DEPLOY_FLAGS_UPDATE = 1 << 0,
+} FlatpakHelperDeployFlags;
 
-#define XDG_APP_HELPER_DEPLOY_FLAGS_ALL (XDG_APP_HELPER_DEPLOY_FLAGS_UPDATE)
+#define FLATPAK_HELPER_DEPLOY_FLAGS_ALL (FLATPAK_HELPER_DEPLOY_FLAGS_UPDATE)
 
-GQuark       xdg_app_dir_error_quark (void);
+GQuark       flatpak_dir_error_quark (void);
 
 /**
- * XDG_APP_DEPLOY_DATA_GVARIANT_FORMAT:
+ * FLATPAK_DEPLOY_DATA_GVARIANT_FORMAT:
  *
  * s - origin
  * s - commit
@@ -66,63 +66,63 @@ GQuark       xdg_app_dir_error_quark (void);
  * t - installed size
  * a{sv} - Metadata
  */
-#define XDG_APP_DEPLOY_DATA_GVARIANT_STRING "(ssasta{sv})"
-#define XDG_APP_DEPLOY_DATA_GVARIANT_FORMAT G_VARIANT_TYPE (XDG_APP_DEPLOY_DATA_GVARIANT_STRING)
+#define FLATPAK_DEPLOY_DATA_GVARIANT_STRING "(ssasta{sv})"
+#define FLATPAK_DEPLOY_DATA_GVARIANT_FORMAT G_VARIANT_TYPE (FLATPAK_DEPLOY_DATA_GVARIANT_STRING)
 
-GFile *  xdg_app_get_system_base_dir_location (void);
-GFile *  xdg_app_get_user_base_dir_location (void);
+GFile *  flatpak_get_system_base_dir_location (void);
+GFile *  flatpak_get_user_base_dir_location (void);
 
-GKeyFile *     xdg_app_load_override_keyfile (const char *app_id,
+GKeyFile *     flatpak_load_override_keyfile (const char *app_id,
                                               gboolean    user,
                                               GError    **error);
-XdgAppContext *xdg_app_load_override_file (const char *app_id,
-                                           gboolean    user,
-                                           GError    **error);
-gboolean       xdg_app_save_override_keyfile (GKeyFile   *metakey,
+FlatpakContext *flatpak_load_override_file (const char *app_id,
+                                            gboolean    user,
+                                            GError    **error);
+gboolean       flatpak_save_override_keyfile (GKeyFile   *metakey,
                                               const char *app_id,
                                               gboolean    user,
                                               GError    **error);
 
-const char *        xdg_app_deploy_data_get_origin (GVariant *deploy_data);
-const char *        xdg_app_deploy_data_get_commit (GVariant *deploy_data);
-const char **       xdg_app_deploy_data_get_subpaths (GVariant *deploy_data);
-guint64             xdg_app_deploy_data_get_installed_size (GVariant *deploy_data);
+const char *        flatpak_deploy_data_get_origin (GVariant *deploy_data);
+const char *        flatpak_deploy_data_get_commit (GVariant *deploy_data);
+const char **       flatpak_deploy_data_get_subpaths (GVariant *deploy_data);
+guint64             flatpak_deploy_data_get_installed_size (GVariant *deploy_data);
 
-GFile *        xdg_app_deploy_get_dir (XdgAppDeploy *deploy);
-GFile *        xdg_app_deploy_get_files (XdgAppDeploy *deploy);
-XdgAppContext *xdg_app_deploy_get_overrides (XdgAppDeploy *deploy);
-GKeyFile *     xdg_app_deploy_get_metadata (XdgAppDeploy *deploy);
+GFile *        flatpak_deploy_get_dir (FlatpakDeploy *deploy);
+GFile *        flatpak_deploy_get_files (FlatpakDeploy *deploy);
+FlatpakContext *flatpak_deploy_get_overrides (FlatpakDeploy *deploy);
+GKeyFile *     flatpak_deploy_get_metadata (FlatpakDeploy *deploy);
 
-XdgAppDir *  xdg_app_dir_new (GFile   *basedir,
-                              gboolean user);
-XdgAppDir *  xdg_app_dir_clone (XdgAppDir *self);
-XdgAppDir  *xdg_app_dir_get (gboolean user);
-XdgAppDir  *xdg_app_dir_get_system (void);
-XdgAppDir  *xdg_app_dir_get_user (void);
-gboolean    xdg_app_dir_is_user (XdgAppDir *self);
-GFile *     xdg_app_dir_get_path (XdgAppDir *self);
-GFile *     xdg_app_dir_get_changed_path (XdgAppDir *self);
-GFile *     xdg_app_dir_get_deploy_dir (XdgAppDir  *self,
+FlatpakDir *  flatpak_dir_new (GFile   *basedir,
+                               gboolean user);
+FlatpakDir *  flatpak_dir_clone (FlatpakDir *self);
+FlatpakDir  *flatpak_dir_get (gboolean user);
+FlatpakDir  *flatpak_dir_get_system (void);
+FlatpakDir  *flatpak_dir_get_user (void);
+gboolean    flatpak_dir_is_user (FlatpakDir *self);
+GFile *     flatpak_dir_get_path (FlatpakDir *self);
+GFile *     flatpak_dir_get_changed_path (FlatpakDir *self);
+GFile *     flatpak_dir_get_deploy_dir (FlatpakDir *self,
                                         const char *ref);
-GVariant *  xdg_app_dir_get_deploy_data (XdgAppDir    *dir,
+GVariant *  flatpak_dir_get_deploy_data (FlatpakDir   *dir,
                                          const char   *ref,
                                          GCancellable *cancellable,
                                          GError      **error);
-char *      xdg_app_dir_get_origin (XdgAppDir    *self,
+char *      flatpak_dir_get_origin (FlatpakDir   *self,
                                     const char   *ref,
                                     GCancellable *cancellable,
                                     GError      **error);
-char **     xdg_app_dir_get_subpaths (XdgAppDir    *self,
+char **     flatpak_dir_get_subpaths (FlatpakDir   *self,
                                       const char   *ref,
                                       GCancellable *cancellable,
                                       GError      **error);
-GFile *     xdg_app_dir_get_exports_dir (XdgAppDir *self);
-GFile *     xdg_app_dir_get_removed_dir (XdgAppDir *self);
-GFile *     xdg_app_dir_get_if_deployed (XdgAppDir    *self,
+GFile *     flatpak_dir_get_exports_dir (FlatpakDir *self);
+GFile *     flatpak_dir_get_removed_dir (FlatpakDir *self);
+GFile *     flatpak_dir_get_if_deployed (FlatpakDir   *self,
                                          const char   *ref,
                                          const char   *checksum,
                                          GCancellable *cancellable);
-char *      xdg_app_dir_find_remote_ref (XdgAppDir    *self,
+char *      flatpak_dir_find_remote_ref (FlatpakDir   *self,
                                          const char   *remote,
                                          const char   *name,
                                          const char   *opt_branch,
@@ -132,7 +132,7 @@ char *      xdg_app_dir_find_remote_ref (XdgAppDir    *self,
                                          gboolean     *is_app,
                                          GCancellable *cancellable,
                                          GError      **error);
-char *      xdg_app_dir_find_installed_ref (XdgAppDir  *self,
+char *      flatpak_dir_find_installed_ref (FlatpakDir *self,
                                             const char *name,
                                             const char *opt_branch,
                                             const char *opt_arch,
@@ -140,39 +140,39 @@ char *      xdg_app_dir_find_installed_ref (XdgAppDir  *self,
                                             gboolean    runtime,
                                             gboolean   *is_app,
                                             GError    **error);
-XdgAppDeploy *xdg_app_dir_load_deployed (XdgAppDir    *self,
-                                         const char   *ref,
-                                         const char   *checksum,
-                                         GCancellable *cancellable,
-                                         GError      **error);
-char *    xdg_app_dir_load_override (XdgAppDir  *dir,
+FlatpakDeploy *flatpak_dir_load_deployed (FlatpakDir   *self,
+                                          const char   *ref,
+                                          const char   *checksum,
+                                          GCancellable *cancellable,
+                                          GError      **error);
+char *    flatpak_dir_load_override (FlatpakDir *dir,
                                      const char *app_id,
                                      gsize      *length,
                                      GError    **error);
-OstreeRepo *xdg_app_dir_get_repo (XdgAppDir *self);
-gboolean    xdg_app_dir_ensure_path (XdgAppDir    *self,
+OstreeRepo *flatpak_dir_get_repo (FlatpakDir *self);
+gboolean    flatpak_dir_ensure_path (FlatpakDir   *self,
                                      GCancellable *cancellable,
                                      GError      **error);
-gboolean    xdg_app_dir_use_child_repo (XdgAppDir *self);
-gboolean    xdg_app_dir_ensure_system_child_repo (XdgAppDir *self,
-                                                  GError   **error);
-gboolean    xdg_app_dir_ensure_repo (XdgAppDir    *self,
+gboolean    flatpak_dir_use_child_repo (FlatpakDir *self);
+gboolean    flatpak_dir_ensure_system_child_repo (FlatpakDir *self,
+                                                  GError    **error);
+gboolean    flatpak_dir_ensure_repo (FlatpakDir   *self,
                                      GCancellable *cancellable,
                                      GError      **error);
-gboolean    xdg_app_dir_mark_changed (XdgAppDir *self,
-                                      GError   **error);
-gboolean    xdg_app_dir_remove_appstream (XdgAppDir    *self,
+gboolean    flatpak_dir_mark_changed (FlatpakDir *self,
+                                      GError    **error);
+gboolean    flatpak_dir_remove_appstream (FlatpakDir   *self,
                                           const char   *remote,
                                           GCancellable *cancellable,
                                           GError      **error);
-gboolean    xdg_app_dir_update_appstream (XdgAppDir           *self,
+gboolean    flatpak_dir_update_appstream (FlatpakDir          *self,
                                           const char          *remote,
                                           const char          *arch,
                                           gboolean            *out_changed,
                                           OstreeAsyncProgress *progress,
                                           GCancellable        *cancellable,
                                           GError             **error);
-gboolean    xdg_app_dir_pull (XdgAppDir           *self,
+gboolean    flatpak_dir_pull (FlatpakDir          *self,
                               const char          *repository,
                               const char          *ref,
                               char               **subpaths,
@@ -181,7 +181,7 @@ gboolean    xdg_app_dir_pull (XdgAppDir           *self,
                               OstreeAsyncProgress *progress,
                               GCancellable        *cancellable,
                               GError             **error);
-gboolean    xdg_app_dir_pull_untrusted_local (XdgAppDir           *self,
+gboolean    flatpak_dir_pull_untrusted_local (FlatpakDir          *self,
                                               const char          *src_path,
                                               const char          *remote_name,
                                               const char          *ref,
@@ -189,51 +189,51 @@ gboolean    xdg_app_dir_pull_untrusted_local (XdgAppDir           *self,
                                               OstreeAsyncProgress *progress,
                                               GCancellable        *cancellable,
                                               GError             **error);
-gboolean    xdg_app_dir_list_refs_for_name (XdgAppDir    *self,
+gboolean    flatpak_dir_list_refs_for_name (FlatpakDir   *self,
                                             const char   *kind,
                                             const char   *name,
                                             char       ***refs,
                                             GCancellable *cancellable,
                                             GError      **error);
-gboolean    xdg_app_dir_list_refs (XdgAppDir    *self,
+gboolean    flatpak_dir_list_refs (FlatpakDir   *self,
                                    const char   *kind,
                                    char       ***refs,
                                    GCancellable *cancellable,
                                    GError      **error);
-char *      xdg_app_dir_read_latest (XdgAppDir    *self,
+char *      flatpak_dir_read_latest (FlatpakDir   *self,
                                      const char   *remote,
                                      const char   *ref,
                                      GCancellable *cancellable,
                                      GError      **error);
-char *      xdg_app_dir_read_active (XdgAppDir    *self,
+char *      flatpak_dir_read_active (FlatpakDir   *self,
                                      const char   *ref,
                                      GCancellable *cancellable);
-gboolean    xdg_app_dir_set_active (XdgAppDir    *self,
+gboolean    flatpak_dir_set_active (FlatpakDir   *self,
                                     const char   *ref,
                                     const char   *checksum,
                                     GCancellable *cancellable,
                                     GError      **error);
-char *      xdg_app_dir_current_ref (XdgAppDir    *self,
+char *      flatpak_dir_current_ref (FlatpakDir   *self,
                                      const char   *name,
                                      GCancellable *cancellable);
-gboolean    xdg_app_dir_drop_current_ref (XdgAppDir    *self,
+gboolean    flatpak_dir_drop_current_ref (FlatpakDir   *self,
                                           const char   *name,
                                           GCancellable *cancellable,
                                           GError      **error);
-gboolean    xdg_app_dir_make_current_ref (XdgAppDir    *self,
+gboolean    flatpak_dir_make_current_ref (FlatpakDir   *self,
                                           const char   *ref,
                                           GCancellable *cancellable,
                                           GError      **error);
-gboolean    xdg_app_dir_list_deployed (XdgAppDir    *self,
+gboolean    flatpak_dir_list_deployed (FlatpakDir   *self,
                                        const char   *ref,
                                        char       ***deployed_checksums,
                                        GCancellable *cancellable,
                                        GError      **error);
-gboolean    xdg_app_dir_lock (XdgAppDir    *self,
+gboolean    flatpak_dir_lock (FlatpakDir   *self,
                               GLnxLockFile *lockfile,
                               GCancellable *cancellable,
                               GError      **error);
-gboolean    xdg_app_dir_deploy (XdgAppDir           *self,
+gboolean    flatpak_dir_deploy (FlatpakDir          *self,
                                 const char          *origin,
                                 const char          *ref,
                                 const char          *checksum_or_latest,
@@ -241,18 +241,18 @@ gboolean    xdg_app_dir_deploy (XdgAppDir           *self,
                                 GVariant            *old_deploy_data,
                                 GCancellable        *cancellable,
                                 GError             **error);
-gboolean    xdg_app_dir_deploy_update (XdgAppDir    *self,
+gboolean    flatpak_dir_deploy_update (FlatpakDir   *self,
                                        const char   *ref,
                                        const char   *checksum,
                                        GCancellable *cancellable,
                                        GError      **error);
-gboolean   xdg_app_dir_deploy_install (XdgAppDir    *self,
+gboolean   flatpak_dir_deploy_install (FlatpakDir   *self,
                                        const char   *ref,
                                        const char   *origin,
                                        char        **subpaths,
                                        GCancellable *cancellable,
                                        GError      **error);
-gboolean   xdg_app_dir_install (XdgAppDir           *self,
+gboolean   flatpak_dir_install (FlatpakDir          *self,
                                 gboolean             no_pull,
                                 gboolean             no_deploy,
                                 const char          *ref,
@@ -261,7 +261,7 @@ gboolean   xdg_app_dir_install (XdgAppDir           *self,
                                 OstreeAsyncProgress *progress,
                                 GCancellable        *cancellable,
                                 GError             **error);
-gboolean   xdg_app_dir_update (XdgAppDir           *self,
+gboolean   flatpak_dir_update (FlatpakDir          *self,
                                gboolean             no_pull,
                                gboolean             no_deploy,
                                const char          *ref,
@@ -271,38 +271,38 @@ gboolean   xdg_app_dir_update (XdgAppDir           *self,
                                OstreeAsyncProgress *progress,
                                GCancellable        *cancellable,
                                GError             **error);
-gboolean    xdg_app_dir_undeploy (XdgAppDir    *self,
+gboolean    flatpak_dir_undeploy (FlatpakDir   *self,
                                   const char   *ref,
                                   const char   *checksum,
                                   gboolean      force_remove,
                                   GCancellable *cancellable,
                                   GError      **error);
-gboolean    xdg_app_dir_undeploy_all (XdgAppDir    *self,
+gboolean    flatpak_dir_undeploy_all (FlatpakDir   *self,
                                       const char   *ref,
                                       gboolean      force_remove,
                                       gboolean     *was_deployed_out,
                                       GCancellable *cancellable,
                                       GError      **error);
-gboolean    xdg_app_dir_remove_all_refs (XdgAppDir    *self,
+gboolean    flatpak_dir_remove_all_refs (FlatpakDir   *self,
                                          const char   *remote,
                                          GCancellable *cancellable,
                                          GError      **error);
-gboolean    xdg_app_dir_remove_ref (XdgAppDir    *self,
+gboolean    flatpak_dir_remove_ref (FlatpakDir   *self,
                                     const char   *remote_name,
                                     const char   *ref,
                                     GCancellable *cancellable,
                                     GError      **error);
-gboolean    xdg_app_dir_update_exports (XdgAppDir    *self,
+gboolean    flatpak_dir_update_exports (FlatpakDir   *self,
                                         const char   *app,
                                         GCancellable *cancellable,
                                         GError      **error);
-gboolean    xdg_app_dir_prune (XdgAppDir    *self,
+gboolean    flatpak_dir_prune (FlatpakDir   *self,
                                GCancellable *cancellable,
                                GError      **error);
-gboolean    xdg_app_dir_cleanup_removed (XdgAppDir    *self,
+gboolean    flatpak_dir_cleanup_removed (FlatpakDir   *self,
                                          GCancellable *cancellable,
                                          GError      **error);
-gboolean    xdg_app_dir_collect_deployed_refs (XdgAppDir    *self,
+gboolean    flatpak_dir_collect_deployed_refs (FlatpakDir   *self,
                                                const char   *type,
                                                const char   *name_prefix,
                                                const char   *branch,
@@ -310,45 +310,45 @@ gboolean    xdg_app_dir_collect_deployed_refs (XdgAppDir    *self,
                                                GHashTable   *hash,
                                                GCancellable *cancellable,
                                                GError      **error);
-char      *xdg_app_dir_create_origin_remote (XdgAppDir    *self,
+char      *flatpak_dir_create_origin_remote (FlatpakDir   *self,
                                              const char   *url,
                                              const char   *id,
                                              const char   *title,
                                              GBytes       *gpg_data,
                                              GCancellable *cancellable,
                                              GError      **error);
-char     **xdg_app_dir_list_remotes (XdgAppDir    *self,
+char     **flatpak_dir_list_remotes (FlatpakDir   *self,
                                      GCancellable *cancellable,
                                      GError      **error);
-char      *xdg_app_dir_get_remote_title (XdgAppDir  *self,
+char      *flatpak_dir_get_remote_title (FlatpakDir *self,
                                          const char *remote_name);
-int        xdg_app_dir_get_remote_prio (XdgAppDir  *self,
+int        flatpak_dir_get_remote_prio (FlatpakDir *self,
                                         const char *remote_name);
-gboolean   xdg_app_dir_get_remote_noenumerate (XdgAppDir  *self,
+gboolean   flatpak_dir_get_remote_noenumerate (FlatpakDir *self,
                                                const char *remote_name);
-gboolean   xdg_app_dir_get_remote_disabled (XdgAppDir  *self,
+gboolean   flatpak_dir_get_remote_disabled (FlatpakDir *self,
                                             const char *remote_name);
-gboolean   xdg_app_dir_list_remote_refs (XdgAppDir    *self,
+gboolean   flatpak_dir_list_remote_refs (FlatpakDir   *self,
                                          const char   *remote,
                                          GHashTable  **refs,
                                          GCancellable *cancellable,
                                          GError      **error);
-char *   xdg_app_dir_fetch_remote_title (XdgAppDir    *self,
+char *   flatpak_dir_fetch_remote_title (FlatpakDir   *self,
                                          const char   *remote,
                                          GCancellable *cancellable,
                                          GError      **error);
-GBytes * xdg_app_dir_fetch_remote_object (XdgAppDir    *self,
+GBytes * flatpak_dir_fetch_remote_object (FlatpakDir   *self,
                                           const char   *remote,
                                           const char   *checksum,
                                           const char   *type,
                                           GCancellable *cancellable,
                                           GError      **error);
-GBytes * xdg_app_dir_fetch_metadata (XdgAppDir    *self,
+GBytes * flatpak_dir_fetch_metadata (FlatpakDir   *self,
                                      const char   *remote_name,
                                      const char   *commit,
                                      GCancellable *cancellable,
                                      GError      **error);
-gboolean xdg_app_dir_fetch_ref_cache (XdgAppDir    *self,
+gboolean flatpak_dir_fetch_ref_cache (FlatpakDir   *self,
                                       const char   *remote_name,
                                       const char   *ref,
                                       guint64      *download_size,
@@ -357,4 +357,4 @@ gboolean xdg_app_dir_fetch_ref_cache (XdgAppDir    *self,
                                       GCancellable *cancellable,
                                       GError      **error);
 
-#endif /* __XDG_APP_DIR_H__ */
+#endif /* __FLATPAK_DIR_H__ */
diff --git a/common/xdg-app-portal-error.c b/common/xdg-app-portal-error.c
index a9fc70f..036aca7 100644
--- a/common/xdg-app-portal-error.c
+++ b/common/xdg-app-portal-error.c
@@ -25,24 +25,24 @@
 
 #include <gio/gio.h>
 
-static const GDBusErrorEntry xdg_app_error_entries[] = {
-  {XDG_APP_PORTAL_ERROR_FAILED,                           "org.freedesktop.XdgApp.Failed"},
-  {XDG_APP_PORTAL_ERROR_INVALID_ARGUMENT,                 "org.freedesktop.XdgApp.InvalidArgument"},
-  {XDG_APP_PORTAL_ERROR_NOT_FOUND,                        "org.freedesktop.XdgApp.NotFound"},
-  {XDG_APP_PORTAL_ERROR_EXISTS,                           "org.freedesktop.XdgApp.Exists"},
-  {XDG_APP_PORTAL_ERROR_NOT_ALLOWED,                      "org.freedesktop.XdgApp.NotAllowed"},
-  {XDG_APP_PORTAL_ERROR_CANCELLED,                        "org.freedesktop.XdgApp.Cancelled"},
-  {XDG_APP_PORTAL_ERROR_WINDOW_DESTROYED,                 "org.freedesktop.XdgApp.WindowDestroyed"},
+static const GDBusErrorEntry flatpak_error_entries[] = {
+  {FLATPAK_PORTAL_ERROR_FAILED,                           "org.freedesktop.Flatpak.Failed"},
+  {FLATPAK_PORTAL_ERROR_INVALID_ARGUMENT,                 "org.freedesktop.Flatpak.InvalidArgument"},
+  {FLATPAK_PORTAL_ERROR_NOT_FOUND,                        "org.freedesktop.Flatpak.NotFound"},
+  {FLATPAK_PORTAL_ERROR_EXISTS,                           "org.freedesktop.Flatpak.Exists"},
+  {FLATPAK_PORTAL_ERROR_NOT_ALLOWED,                      "org.freedesktop.Flatpak.NotAllowed"},
+  {FLATPAK_PORTAL_ERROR_CANCELLED,                        "org.freedesktop.Flatpak.Cancelled"},
+  {FLATPAK_PORTAL_ERROR_WINDOW_DESTROYED,                 "org.freedesktop.Flatpak.WindowDestroyed"},
 };
 
 GQuark
-xdg_app_portal_error_quark (void)
+flatpak_portal_error_quark (void)
 {
   static volatile gsize quark_volatile = 0;
 
   g_dbus_error_register_error_domain ("xdg-app-portal-error-quark",
                                       &quark_volatile,
-                                      xdg_app_error_entries,
-                                      G_N_ELEMENTS (xdg_app_error_entries));
+                                      flatpak_error_entries,
+                                      G_N_ELEMENTS (flatpak_error_entries));
   return (GQuark) quark_volatile;
 }
diff --git a/common/xdg-app-portal-error.h b/common/xdg-app-portal-error.h
index 00e6b89..2ff02e8 100644
--- a/common/xdg-app-portal-error.h
+++ b/common/xdg-app-portal-error.h
@@ -19,8 +19,8 @@
  *       Alexander Larsson <alexl@redhat.com>
  */
 
-#ifndef XDG_APP_PORTAL_ERROR_H
-#define XDG_APP_PORTAL_ERROR_H
+#ifndef FLATPAK_PORTAL_ERROR_H
+#define FLATPAK_PORTAL_ERROR_H
 
 #include <glib.h>
 
@@ -30,20 +30,20 @@ G_BEGIN_DECLS
  * XdpErrorEnum:
  */
 typedef enum {
-  XDG_APP_PORTAL_ERROR_FAILED     = 0,
-  XDG_APP_PORTAL_ERROR_INVALID_ARGUMENT,
-  XDG_APP_PORTAL_ERROR_NOT_FOUND,
-  XDG_APP_PORTAL_ERROR_EXISTS,
-  XDG_APP_PORTAL_ERROR_NOT_ALLOWED,
-  XDG_APP_PORTAL_ERROR_CANCELLED,
-  XDG_APP_PORTAL_ERROR_WINDOW_DESTROYED,
-} XdgAppErrorEnum;
+  FLATPAK_PORTAL_ERROR_FAILED     = 0,
+  FLATPAK_PORTAL_ERROR_INVALID_ARGUMENT,
+  FLATPAK_PORTAL_ERROR_NOT_FOUND,
+  FLATPAK_PORTAL_ERROR_EXISTS,
+  FLATPAK_PORTAL_ERROR_NOT_ALLOWED,
+  FLATPAK_PORTAL_ERROR_CANCELLED,
+  FLATPAK_PORTAL_ERROR_WINDOW_DESTROYED,
+} FlatpakErrorEnum;
 
 
-#define XDG_APP_PORTAL_ERROR xdg_app_portal_error_quark ()
+#define FLATPAK_PORTAL_ERROR flatpak_portal_error_quark ()
 
-XDG_APP_EXTERN GQuark  xdg_app_portal_error_quark (void);
+FLATPAK_EXTERN GQuark  flatpak_portal_error_quark (void);
 
 G_END_DECLS
 
-#endif /* XDG_APP_PORTAL_ERROR_H */
+#endif /* FLATPAK_PORTAL_ERROR_H */
diff --git a/common/xdg-app-run.c b/common/xdg-app-run.c
index 44d5a14..2062657 100644
--- a/common/xdg-app-run.c
+++ b/common/xdg-app-run.c
@@ -48,34 +48,34 @@
 #define DEFAULT_SHELL "/bin/sh"
 
 typedef enum {
-  XDG_APP_CONTEXT_SHARED_NETWORK   = 1 << 0,
-  XDG_APP_CONTEXT_SHARED_IPC       = 1 << 1,
-} XdgAppContextShares;
+  FLATPAK_CONTEXT_SHARED_NETWORK   = 1 << 0,
+  FLATPAK_CONTEXT_SHARED_IPC       = 1 << 1,
+} FlatpakContextShares;
 
 /* In numerical order of more privs */
 typedef enum {
-  XDG_APP_FILESYSTEM_MODE_READ_ONLY    = 1,
-  XDG_APP_FILESYSTEM_MODE_READ_WRITE   = 2,
-} XdgAppFilesystemMode;
+  FLATPAK_FILESYSTEM_MODE_READ_ONLY    = 1,
+  FLATPAK_FILESYSTEM_MODE_READ_WRITE   = 2,
+} FlatpakFilesystemMode;
 
 
 /* Same order as enum */
-static const char *xdg_app_context_shares[] = {
+static const char *flatpak_context_shares[] = {
   "network",
   "ipc",
   NULL
 };
 
 typedef enum {
-  XDG_APP_CONTEXT_SOCKET_X11         = 1 << 0,
-  XDG_APP_CONTEXT_SOCKET_WAYLAND     = 1 << 1,
-  XDG_APP_CONTEXT_SOCKET_PULSEAUDIO  = 1 << 2,
-  XDG_APP_CONTEXT_SOCKET_SESSION_BUS = 1 << 3,
-  XDG_APP_CONTEXT_SOCKET_SYSTEM_BUS  = 1 << 4,
-} XdgAppContextSockets;
+  FLATPAK_CONTEXT_SOCKET_X11         = 1 << 0,
+  FLATPAK_CONTEXT_SOCKET_WAYLAND     = 1 << 1,
+  FLATPAK_CONTEXT_SOCKET_PULSEAUDIO  = 1 << 2,
+  FLATPAK_CONTEXT_SOCKET_SESSION_BUS = 1 << 3,
+  FLATPAK_CONTEXT_SOCKET_SYSTEM_BUS  = 1 << 4,
+} FlatpakContextSockets;
 
 /* Same order as enum */
-static const char *xdg_app_context_sockets[] = {
+static const char *flatpak_context_sockets[] = {
   "x11",
   "wayland",
   "pulseaudio",
@@ -90,35 +90,35 @@ const char *dont_mount_in_root[] = {
 };
 
 typedef enum {
-  XDG_APP_CONTEXT_DEVICE_DRI         = 1 << 0,
-} XdgAppContextDevices;
+  FLATPAK_CONTEXT_DEVICE_DRI         = 1 << 0,
+} FlatpakContextDevices;
 
-static const char *xdg_app_context_devices[] = {
+static const char *flatpak_context_devices[] = {
   "dri",
   NULL
 };
 
-struct XdgAppContext
-{
-  XdgAppContextShares  shares;
-  XdgAppContextShares  shares_valid;
-  XdgAppContextSockets sockets;
-  XdgAppContextSockets sockets_valid;
-  XdgAppContextDevices devices;
-  XdgAppContextDevices devices_valid;
-  GHashTable          *env_vars;
-  GHashTable          *persistent;
-  GHashTable          *filesystems;
-  GHashTable          *session_bus_policy;
-  GHashTable          *system_bus_policy;
+struct FlatpakContext
+{
+  FlatpakContextShares  shares;
+  FlatpakContextShares  shares_valid;
+  FlatpakContextSockets sockets;
+  FlatpakContextSockets sockets_valid;
+  FlatpakContextDevices devices;
+  FlatpakContextDevices devices_valid;
+  GHashTable           *env_vars;
+  GHashTable           *persistent;
+  GHashTable           *filesystems;
+  GHashTable           *session_bus_policy;
+  GHashTable           *system_bus_policy;
 };
 
-XdgAppContext *
-xdg_app_context_new (void)
+FlatpakContext *
+flatpak_context_new (void)
 {
-  XdgAppContext *context;
+  FlatpakContext *context;
 
-  context = g_slice_new0 (XdgAppContext);
+  context = g_slice_new0 (FlatpakContext);
   context->env_vars = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
   context->persistent = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
   context->filesystems = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
@@ -129,18 +129,18 @@ xdg_app_context_new (void)
 }
 
 void
-xdg_app_context_free (XdgAppContext *context)
+flatpak_context_free (FlatpakContext *context)
 {
   g_hash_table_destroy (context->env_vars);
   g_hash_table_destroy (context->persistent);
   g_hash_table_destroy (context->filesystems);
   g_hash_table_destroy (context->session_bus_policy);
   g_hash_table_destroy (context->system_bus_policy);
-  g_slice_free (XdgAppContext, context);
+  g_slice_free (FlatpakContext, context);
 }
 
 static guint32
-xdg_app_context_bitmask_from_string (const char *name, const char **names)
+flatpak_context_bitmask_from_string (const char *name, const char **names)
 {
   guint32 i;
 
@@ -155,7 +155,7 @@ xdg_app_context_bitmask_from_string (const char *name, const char **names)
 
 
 static char **
-xdg_app_context_bitmask_to_string (guint32 enabled, guint32 valid, const char **names)
+flatpak_context_bitmask_to_string (guint32 enabled, guint32 valid, const char **names)
 {
   guint32 i;
   GPtrArray *array;
@@ -178,10 +178,10 @@ xdg_app_context_bitmask_to_string (guint32 enabled, guint32 valid, const char **
   return (char **) g_ptr_array_free (array, FALSE);
 }
 
-static XdgAppContextShares
-xdg_app_context_share_from_string (const char *string, GError **error)
+static FlatpakContextShares
+flatpak_context_share_from_string (const char *string, GError **error)
 {
-  XdgAppContextShares shares = xdg_app_context_bitmask_from_string (string, xdg_app_context_shares);
+  FlatpakContextShares shares = flatpak_context_bitmask_from_string (string, flatpak_context_shares);
 
   if (shares == 0)
     g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED,
@@ -190,22 +190,22 @@ xdg_app_context_share_from_string (const char *string, GError **error)
 }
 
 static char **
-xdg_app_context_shared_to_string (XdgAppContextShares shares, XdgAppContextShares valid)
+flatpak_context_shared_to_string (FlatpakContextShares shares, FlatpakContextShares valid)
 {
-  return xdg_app_context_bitmask_to_string (shares, valid, xdg_app_context_shares);
+  return flatpak_context_bitmask_to_string (shares, valid, flatpak_context_shares);
 }
 
-static XdgAppPolicy
-xdg_app_policy_from_string (const char *string, GError **error)
+static FlatpakPolicy
+flatpak_policy_from_string (const char *string, GError **error)
 {
   if (strcmp (string, "none") == 0)
-    return XDG_APP_POLICY_NONE;
+    return FLATPAK_POLICY_NONE;
   if (strcmp (string, "see") == 0)
-    return XDG_APP_POLICY_SEE;
+    return FLATPAK_POLICY_SEE;
   if (strcmp (string, "talk") == 0)
-    return XDG_APP_POLICY_TALK;
+    return FLATPAK_POLICY_TALK;
   if (strcmp (string, "own") == 0)
-    return XDG_APP_POLICY_OWN;
+    return FLATPAK_POLICY_OWN;
 
   g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED,
                "Unknown socket type %s, valid types are: x11,wayland,pulseaudio,session-bus,system-bus\n", string);
@@ -213,20 +213,20 @@ xdg_app_policy_from_string (const char *string, GError **error)
 }
 
 static const char *
-xdg_app_policy_to_string (XdgAppPolicy policy)
+flatpak_policy_to_string (FlatpakPolicy policy)
 {
-  if (policy == XDG_APP_POLICY_SEE)
+  if (policy == FLATPAK_POLICY_SEE)
     return "see";
-  if (policy == XDG_APP_POLICY_TALK)
+  if (policy == FLATPAK_POLICY_TALK)
     return "talk";
-  if (policy == XDG_APP_POLICY_OWN)
+  if (policy == FLATPAK_POLICY_OWN)
     return "own";
 
   return "none";
 }
 
 static gboolean
-xdg_app_verify_dbus_name (const char *name, GError **error)
+flatpak_verify_dbus_name (const char *name, GError **error)
 {
   const char *name_part;
   g_autofree char *tmp = NULL;
@@ -248,10 +248,10 @@ xdg_app_verify_dbus_name (const char *name, GError **error)
   return FALSE;
 }
 
-static XdgAppContextSockets
-xdg_app_context_socket_from_string (const char *string, GError **error)
+static FlatpakContextSockets
+flatpak_context_socket_from_string (const char *string, GError **error)
 {
-  XdgAppContextSockets sockets = xdg_app_context_bitmask_from_string (string, xdg_app_context_sockets);
+  FlatpakContextSockets sockets = flatpak_context_bitmask_from_string (string, flatpak_context_sockets);
 
   if (sockets == 0)
     g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED,
@@ -260,15 +260,15 @@ xdg_app_context_socket_from_string (const char *string, GError **error)
 }
 
 static char **
-xdg_app_context_sockets_to_string (XdgAppContextSockets sockets, XdgAppContextSockets valid)
+flatpak_context_sockets_to_string (FlatpakContextSockets sockets, FlatpakContextSockets valid)
 {
-  return xdg_app_context_bitmask_to_string (sockets, valid, xdg_app_context_sockets);
+  return flatpak_context_bitmask_to_string (sockets, valid, flatpak_context_sockets);
 }
 
-static XdgAppContextDevices
-xdg_app_context_device_from_string (const char *string, GError **error)
+static FlatpakContextDevices
+flatpak_context_device_from_string (const char *string, GError **error)
 {
-  XdgAppContextDevices devices = xdg_app_context_bitmask_from_string (string, xdg_app_context_devices);
+  FlatpakContextDevices devices = flatpak_context_bitmask_from_string (string, flatpak_context_devices);
 
   if (devices == 0)
     g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_FAILED,
@@ -277,86 +277,86 @@ xdg_app_context_device_from_string (const char *string, GError **error)
 }
 
 static char **
-xdg_app_context_devices_to_string (XdgAppContextDevices devices, XdgAppContextDevices valid)
+flatpak_context_devices_to_string (FlatpakContextDevices devices, FlatpakContextDevices valid)
 {
-  return xdg_app_context_bitmask_to_string (devices, valid, xdg_app_context_devices);
+  return flatpak_context_bitmask_to_string (devices, valid, flatpak_context_devices);
 }
 
 static void
-xdg_app_context_add_shares (XdgAppContext      *context,
-                            XdgAppContextShares shares)
+flatpak_context_add_shares (FlatpakContext      *context,
+                            FlatpakContextShares shares)
 {
   context->shares_valid |= shares;
   context->shares |= shares;
 }
 
 static void
-xdg_app_context_remove_shares (XdgAppContext      *context,
-                               XdgAppContextShares shares)
+flatpak_context_remove_shares (FlatpakContext      *context,
+                               FlatpakContextShares shares)
 {
   context->shares_valid |= shares;
   context->shares &= ~shares;
 }
 
 static void
-xdg_app_context_add_sockets (XdgAppContext       *context,
-                             XdgAppContextSockets sockets)
+flatpak_context_add_sockets (FlatpakContext       *context,
+                             FlatpakContextSockets sockets)
 {
   context->sockets_valid |= sockets;
   context->sockets |= sockets;
 }
 
 static void
-xdg_app_context_remove_sockets (XdgAppContext       *context,
-                                XdgAppContextSockets sockets)
+flatpak_context_remove_sockets (FlatpakContext       *context,
+                                FlatpakContextSockets sockets)
 {
   context->sockets_valid |= sockets;
   context->sockets &= ~sockets;
 }
 
 static void
-xdg_app_context_add_devices (XdgAppContext       *context,
-                             XdgAppContextDevices devices)
+flatpak_context_add_devices (FlatpakContext       *context,
+                             FlatpakContextDevices devices)
 {
   context->devices_valid |= devices;
   context->devices |= devices;
 }
 
 static void
-xdg_app_context_remove_devices (XdgAppContext       *context,
-                                XdgAppContextDevices devices)
+flatpak_context_remove_devices (FlatpakContext       *context,
+                                FlatpakContextDevices devices)
 {
   context->devices_valid |= devices;
   context->devices &= ~devices;
 }
 
 static void
-xdg_app_context_set_env_var (XdgAppContext *context,
-                             const char    *name,
-                             const char    *value)
+flatpak_context_set_env_var (FlatpakContext *context,
+                             const char     *name,
+                             const char     *value)
 {
   g_hash_table_insert (context->env_vars, g_strdup (name), g_strdup (value));
 }
 
 void
-xdg_app_context_set_session_bus_policy (XdgAppContext *context,
-                                        const char    *name,
-                                        XdgAppPolicy   policy)
+flatpak_context_set_session_bus_policy (FlatpakContext *context,
+                                        const char     *name,
+                                        FlatpakPolicy   policy)
 {
   g_hash_table_insert (context->session_bus_policy, g_strdup (name), GINT_TO_POINTER (policy));
 }
 
 void
-xdg_app_context_set_system_bus_policy (XdgAppContext *context,
-                                       const char    *name,
-                                       XdgAppPolicy   policy)
+flatpak_context_set_system_bus_policy (FlatpakContext *context,
+                                       const char     *name,
+                                       FlatpakPolicy   policy)
 {
   g_hash_table_insert (context->system_bus_policy, g_strdup (name), GINT_TO_POINTER (policy));
 }
 
 static void
-xdg_app_context_set_persistent (XdgAppContext *context,
-                                const char    *path)
+flatpak_context_set_persistent (FlatpakContext *context,
+                                const char     *path)
 {
   g_hash_table_insert (context->persistent, g_strdup (path), GINT_TO_POINTER (1));
 }
@@ -467,31 +467,31 @@ get_user_dir_from_string (const char  *filesystem,
 }
 
 static char *
-parse_filesystem_flags (const char *filesystem, XdgAppFilesystemMode *mode)
+parse_filesystem_flags (const char *filesystem, FlatpakFilesystemMode *mode)
 {
   gsize len = strlen (filesystem);
 
   if (mode)
-    *mode = XDG_APP_FILESYSTEM_MODE_READ_WRITE;
+    *mode = FLATPAK_FILESYSTEM_MODE_READ_WRITE;
 
   if (g_str_has_suffix (filesystem, ":ro"))
     {
       len -= 3;
       if (mode)
-        *mode = XDG_APP_FILESYSTEM_MODE_READ_ONLY;
+        *mode = FLATPAK_FILESYSTEM_MODE_READ_ONLY;
     }
   else if (g_str_has_suffix (filesystem, ":rw"))
     {
       len -= 3;
       if (mode)
-        *mode = XDG_APP_FILESYSTEM_MODE_READ_WRITE;
+        *mode = FLATPAK_FILESYSTEM_MODE_READ_WRITE;
     }
 
   return g_strndup (filesystem, len);
 }
 
 static gboolean
-xdg_app_context_verify_filesystem (const char *filesystem_and_mode,
+flatpak_context_verify_filesystem (const char *filesystem_and_mode,
                                    GError    **error)
 {
   g_autofree char *filesystem = parse_filesystem_flags (filesystem_and_mode, NULL);
@@ -513,18 +513,18 @@ xdg_app_context_verify_filesystem (const char *filesystem_and_mode,
 }
 
 static void
-xdg_app_context_add_filesystem (XdgAppContext *context,
-                                const char    *what)
+flatpak_context_add_filesystem (FlatpakContext *context,
+                                const char     *what)
 {
-  XdgAppFilesystemMode mode;
+  FlatpakFilesystemMode mode;
   char *fs = parse_filesystem_flags (what, &mode);
 
   g_hash_table_insert (context->filesystems, fs, GINT_TO_POINTER (mode));
 }
 
 static void
-xdg_app_context_remove_filesystem (XdgAppContext *context,
-                                   const char    *what)
+flatpak_context_remove_filesystem (FlatpakContext *context,
+                                   const char     *what)
 {
   g_hash_table_insert (context->filesystems,
                        parse_filesystem_flags (what, NULL),
@@ -532,8 +532,8 @@ xdg_app_context_remove_filesystem (XdgAppContext *context,
 }
 
 void
-xdg_app_context_merge (XdgAppContext *context,
-                       XdgAppContext *other)
+flatpak_context_merge (FlatpakContext *context,
+                       FlatpakContext *other)
 {
   GHashTableIter iter;
   gpointer key, value;
@@ -575,14 +575,14 @@ option_share_cb (const gchar *option_name,
                  gpointer     data,
                  GError     **error)
 {
-  XdgAppContext *context = data;
-  XdgAppContextShares share;
+  FlatpakContext *context = data;
+  FlatpakContextShares share;
 
-  share = xdg_app_context_share_from_string (value, error);
+  share = flatpak_context_share_from_string (value, error);
   if (share == 0)
     return FALSE;
 
-  xdg_app_context_add_shares (context, share);
+  flatpak_context_add_shares (context, share);
 
   return TRUE;
 }
@@ -593,14 +593,14 @@ option_unshare_cb (const gchar *option_name,
                    gpointer     data,
                    GError     **error)
 {
-  XdgAppContext *context = data;
-  XdgAppContextShares share;
+  FlatpakContext *context = data;
+  FlatpakContextShares share;
 
-  share = xdg_app_context_share_from_string (value, error);
+  share = flatpak_context_share_from_string (value, error);
   if (share == 0)
     return FALSE;
 
-  xdg_app_context_remove_shares (context, share);
+  flatpak_context_remove_shares (context, share);
 
   return TRUE;
 }
@@ -611,14 +611,14 @@ option_socket_cb (const gchar *option_name,
                   gpointer     data,
                   GError     **error)
 {
-  XdgAppContext *context = data;
-  XdgAppContextSockets socket;
+  FlatpakContext *context = data;
+  FlatpakContextSockets socket;
 
-  socket = xdg_app_context_socket_from_string (value, error);
+  socket = flatpak_context_socket_from_string (value, error);
   if (socket == 0)
     return FALSE;
 
-  xdg_app_context_add_sockets (context, socket);
+  flatpak_context_add_sockets (context, socket);
 
   return TRUE;
 }
@@ -629,14 +629,14 @@ option_nosocket_cb (const gchar *option_name,
                     gpointer     data,
                     GError     **error)
 {
-  XdgAppContext *context = data;
-  XdgAppContextSockets socket;
+  FlatpakContext *context = data;
+  FlatpakContextSockets socket;
 
-  socket = xdg_app_context_socket_from_string (value, error);
+  socket = flatpak_context_socket_from_string (value, error);
   if (socket == 0)
     return FALSE;
 
-  xdg_app_context_remove_sockets (context, socket);
+  flatpak_context_remove_sockets (context, socket);
 
   return TRUE;
 }
@@ -647,14 +647,14 @@ option_device_cb (const gchar *option_name,
                   gpointer     data,
                   GError     **error)
 {
-  XdgAppContext *context = data;
-  XdgAppContextDevices device;
+  FlatpakContext *context = data;
+  FlatpakContextDevices device;
 
-  device = xdg_app_context_device_from_string (value, error);
+  device = flatpak_context_device_from_string (value, error);
   if (device == 0)
     return FALSE;
 
-  xdg_app_context_add_devices (context, device);
+  flatpak_context_add_devices (context, device);
 
   return TRUE;
 }
@@ -665,14 +665,14 @@ option_nodevice_cb (const gchar *option_name,
                     gpointer     data,
                     GError     **error)
 {
-  XdgAppContext *context = data;
-  XdgAppContextDevices device;
+  FlatpakContext *context = data;
+  FlatpakContextDevices device;
 
-  device = xdg_app_context_device_from_string (value, error);
+  device = flatpak_context_device_from_string (value, error);
   if (device == 0)
     return FALSE;
 
-  xdg_app_context_remove_devices (context, device);
+  flatpak_context_remove_devices (context, device);
 
   return TRUE;
 }
@@ -683,12 +683,12 @@ option_filesystem_cb (const gchar *option_name,
                       gpointer     data,
                       GError     **error)
 {
-  XdgAppContext *context = data;
+  FlatpakContext *context = data;
 
-  if (!xdg_app_context_verify_filesystem (value, error))
+  if (!flatpak_context_verify_filesystem (value, error))
     return FALSE;
 
-  xdg_app_context_add_filesystem (context, value);
+  flatpak_context_add_filesystem (context, value);
   return TRUE;
 }
 
@@ -698,12 +698,12 @@ option_nofilesystem_cb (const gchar *option_name,
                         gpointer     data,
                         GError     **error)
 {
-  XdgAppContext *context = data;
+  FlatpakContext *context = data;
 
-  if (!xdg_app_context_verify_filesystem (value, error))
+  if (!flatpak_context_verify_filesystem (value, error))
     return FALSE;
 
-  xdg_app_context_remove_filesystem (context, value);
+  flatpak_context_remove_filesystem (context, value);
   return TRUE;
 }
 
@@ -713,7 +713,7 @@ option_env_cb (const gchar *option_name,
                gpointer     data,
                GError     **error)
 {
-  XdgAppContext *context = data;
+  FlatpakContext *context = data;
 
   g_auto(GStrv) split = g_strsplit (value, "=", 2);
 
@@ -723,7 +723,7 @@ option_env_cb (const gchar *option_name,
       return FALSE;
     }
 
-  xdg_app_context_set_env_var (context, split[0], split[1]);
+  flatpak_context_set_env_var (context, split[0], split[1]);
   return TRUE;
 }
 
@@ -733,12 +733,12 @@ option_own_name_cb (const gchar *option_name,
                     gpointer     data,
                     GError     **error)
 {
-  XdgAppContext *context = data;
+  FlatpakContext *context = data;
 
-  if (!xdg_app_verify_dbus_name (value, error))
+  if (!flatpak_verify_dbus_name (value, error))
     return FALSE;
 
-  xdg_app_context_set_session_bus_policy (context, value, XDG_APP_POLICY_OWN);
+  flatpak_context_set_session_bus_policy (context, value, FLATPAK_POLICY_OWN);
   return TRUE;
 }
 
@@ -748,12 +748,12 @@ option_talk_name_cb (const gchar *option_name,
                      gpointer     data,
                      GError     **error)
 {
-  XdgAppContext *context = data;
+  FlatpakContext *context = data;
 
-  if (!xdg_app_verify_dbus_name (value, error))
+  if (!flatpak_verify_dbus_name (value, error))
     return FALSE;
 
-  xdg_app_context_set_session_bus_policy (context, value, XDG_APP_POLICY_TALK);
+  flatpak_context_set_session_bus_policy (context, value, FLATPAK_POLICY_TALK);
   return TRUE;
 }
 
@@ -763,12 +763,12 @@ option_system_own_name_cb (const gchar *option_name,
                            gpointer     data,
                            GError     **error)
 {
-  XdgAppContext *context = data;
+  FlatpakContext *context = data;
 
-  if (!xdg_app_verify_dbus_name (value, error))
+  if (!flatpak_verify_dbus_name (value, error))
     return FALSE;
 
-  xdg_app_context_set_system_bus_policy (context, value, XDG_APP_POLICY_OWN);
+  flatpak_context_set_system_bus_policy (context, value, FLATPAK_POLICY_OWN);
   return TRUE;
 }
 
@@ -778,12 +778,12 @@ option_system_talk_name_cb (const gchar *option_name,
                             gpointer     data,
                             GError     **error)
 {
-  XdgAppContext *context = data;
+  FlatpakContext *context = data;
 
-  if (!xdg_app_verify_dbus_name (value, error))
+  if (!flatpak_verify_dbus_name (value, error))
     return FALSE;
 
-  xdg_app_context_set_system_bus_policy (context, value, XDG_APP_POLICY_TALK);
+  flatpak_context_set_system_bus_policy (context, value, FLATPAK_POLICY_TALK);
   return TRUE;
 }
 
@@ -793,9 +793,9 @@ option_persist_cb (const gchar *option_name,
                    gpointer     data,
                    GError     **error)
 {
-  XdgAppContext *context = data;
+  FlatpakContext *context = data;
 
-  xdg_app_context_set_persistent (context, value);
+  flatpak_context_set_persistent (context, value);
   return TRUE;
 }
 
@@ -818,7 +818,7 @@ static GOptionEntry context_options[] = {
 };
 
 GOptionGroup  *
-xdg_app_context_get_options (XdgAppContext *context)
+flatpak_context_get_options (FlatpakContext *context)
 {
   GOptionGroup *group;
 
@@ -850,161 +850,161 @@ parse_negated (const char *option, gboolean *negated)
 
 /* This is a merge, not a replace */
 gboolean
-xdg_app_context_load_metadata (XdgAppContext *context,
-                               GKeyFile      *metakey,
-                               GError       **error)
+flatpak_context_load_metadata (FlatpakContext *context,
+                               GKeyFile       *metakey,
+                               GError        **error)
 {
   gboolean remove;
   int i;
 
-  if (g_key_file_has_key (metakey, XDG_APP_METADATA_GROUP_CONTEXT, XDG_APP_METADATA_KEY_SHARED, NULL))
+  if (g_key_file_has_key (metakey, FLATPAK_METADATA_GROUP_CONTEXT, FLATPAK_METADATA_KEY_SHARED, NULL))
     {
-      g_auto(GStrv) shares = g_key_file_get_string_list (metakey, XDG_APP_METADATA_GROUP_CONTEXT,
-                                                         XDG_APP_METADATA_KEY_SHARED, NULL, error);
+      g_auto(GStrv) shares = g_key_file_get_string_list (metakey, FLATPAK_METADATA_GROUP_CONTEXT,
+                                                         FLATPAK_METADATA_KEY_SHARED, NULL, error);
       if (shares == NULL)
         return FALSE;
 
       for (i = 0; shares[i] != NULL; i++)
         {
-          XdgAppContextShares share;
+          FlatpakContextShares share;
 
-          share = xdg_app_context_share_from_string (parse_negated (shares[i], &remove), error);
+          share = flatpak_context_share_from_string (parse_negated (shares[i], &remove), error);
           if (share == 0)
             return FALSE;
           if (remove)
-            xdg_app_context_remove_shares (context, share);
+            flatpak_context_remove_shares (context, share);
           else
-            xdg_app_context_add_shares (context, share);
+            flatpak_context_add_shares (context, share);
         }
     }
 
-  if (g_key_file_has_key (metakey, XDG_APP_METADATA_GROUP_CONTEXT, XDG_APP_METADATA_KEY_SOCKETS, NULL))
+  if (g_key_file_has_key (metakey, FLATPAK_METADATA_GROUP_CONTEXT, FLATPAK_METADATA_KEY_SOCKETS, NULL))
     {
-      g_auto(GStrv) sockets = g_key_file_get_string_list (metakey, XDG_APP_METADATA_GROUP_CONTEXT,
-                                                          XDG_APP_METADATA_KEY_SOCKETS, NULL, error);
+      g_auto(GStrv) sockets = g_key_file_get_string_list (metakey, FLATPAK_METADATA_GROUP_CONTEXT,
+                                                          FLATPAK_METADATA_KEY_SOCKETS, NULL, error);
       if (sockets == NULL)
         return FALSE;
 
       for (i = 0; sockets[i] != NULL; i++)
         {
-          XdgAppContextSockets socket = xdg_app_context_socket_from_string (parse_negated (sockets[i], &remove), error);
+          FlatpakContextSockets socket = flatpak_context_socket_from_string (parse_negated (sockets[i], &remove), error);
           if (socket == 0)
             return FALSE;
           if (remove)
-            xdg_app_context_remove_sockets (context, socket);
+            flatpak_context_remove_sockets (context, socket);
           else
-            xdg_app_context_add_sockets (context, socket);
+            flatpak_context_add_sockets (context, socket);
         }
     }
 
-  if (g_key_file_has_key (metakey, XDG_APP_METADATA_GROUP_CONTEXT, XDG_APP_METADATA_KEY_DEVICES, NULL))
+  if (g_key_file_has_key (metakey, FLATPAK_METADATA_GROUP_CONTEXT, FLATPAK_METADATA_KEY_DEVICES, NULL))
     {
-      g_auto(GStrv) devices = g_key_file_get_string_list (metakey, XDG_APP_METADATA_GROUP_CONTEXT,
-                                                          XDG_APP_METADATA_KEY_DEVICES, NULL, error);
+      g_auto(GStrv) devices = g_key_file_get_string_list (metakey, FLATPAK_METADATA_GROUP_CONTEXT,
+                                                          FLATPAK_METADATA_KEY_DEVICES, NULL, error);
       if (devices == NULL)
         return FALSE;
 
 
       for (i = 0; devices[i] != NULL; i++)
         {
-          XdgAppContextDevices device = xdg_app_context_device_from_string (parse_negated (devices[i], &remove), error);
+          FlatpakContextDevices device = flatpak_context_device_from_string (parse_negated (devices[i], &remove), error);
           if (device == 0)
             return FALSE;
           if (remove)
-            xdg_app_context_remove_devices (context, device);
+            flatpak_context_remove_devices (context, device);
           else
-            xdg_app_context_add_devices (context, device);
+            flatpak_context_add_devices (context, device);
         }
     }
 
-  if (g_key_file_has_key (metakey, XDG_APP_METADATA_GROUP_CONTEXT, XDG_APP_METADATA_KEY_FILESYSTEMS, NULL))
+  if (g_key_file_has_key (metakey, FLATPAK_METADATA_GROUP_CONTEXT, FLATPAK_METADATA_KEY_FILESYSTEMS, NULL))
     {
-      g_auto(GStrv) filesystems = g_key_file_get_string_list (metakey, XDG_APP_METADATA_GROUP_CONTEXT,
-                                                              XDG_APP_METADATA_KEY_FILESYSTEMS, NULL, error);
+      g_auto(GStrv) filesystems = g_key_file_get_string_list (metakey, FLATPAK_METADATA_GROUP_CONTEXT,
+                                                              FLATPAK_METADATA_KEY_FILESYSTEMS, NULL, error);
       if (filesystems == NULL)
         return FALSE;
 
       for (i = 0; filesystems[i] != NULL; i++)
         {
           const char *fs = parse_negated (filesystems[i], &remove);
-          if (!xdg_app_context_verify_filesystem (fs, error))
+          if (!flatpak_context_verify_filesystem (fs, error))
             return FALSE;
           if (remove)
-            xdg_app_context_remove_filesystem (context, fs);
+            flatpak_context_remove_filesystem (context, fs);
           else
-            xdg_app_context_add_filesystem (context, fs);
+            flatpak_context_add_filesystem (context, fs);
         }
     }
 
-  if (g_key_file_has_key (metakey, XDG_APP_METADATA_GROUP_CONTEXT, XDG_APP_METADATA_KEY_PERSISTENT, NULL))
+  if (g_key_file_has_key (metakey, FLATPAK_METADATA_GROUP_CONTEXT, FLATPAK_METADATA_KEY_PERSISTENT, NULL))
     {
-      g_auto(GStrv) persistent = g_key_file_get_string_list (metakey, XDG_APP_METADATA_GROUP_CONTEXT,
-                                                             XDG_APP_METADATA_KEY_PERSISTENT, NULL, error);
+      g_auto(GStrv) persistent = g_key_file_get_string_list (metakey, FLATPAK_METADATA_GROUP_CONTEXT,
+                                                             FLATPAK_METADATA_KEY_PERSISTENT, NULL, error);
       if (persistent == NULL)
         return FALSE;
 
       for (i = 0; persistent[i] != NULL; i++)
-        xdg_app_context_set_persistent (context, persistent[i]);
+        flatpak_context_set_persistent (context, persistent[i]);
     }
 
-  if (g_key_file_has_group (metakey, XDG_APP_METADATA_GROUP_SESSION_BUS_POLICY))
+  if (g_key_file_has_group (metakey, FLATPAK_METADATA_GROUP_SESSION_BUS_POLICY))
     {
       g_auto(GStrv) keys = NULL;
       gsize i, keys_count;
 
-      keys = g_key_file_get_keys (metakey, XDG_APP_METADATA_GROUP_SESSION_BUS_POLICY, &keys_count, NULL);
+      keys = g_key_file_get_keys (metakey, FLATPAK_METADATA_GROUP_SESSION_BUS_POLICY, &keys_count, NULL);
       for (i = 0; i < keys_count; i++)
         {
           const char *key = keys[i];
-          g_autofree char *value = g_key_file_get_string (metakey, XDG_APP_METADATA_GROUP_SESSION_BUS_POLICY, key, NULL);
-          XdgAppPolicy policy;
+          g_autofree char *value = g_key_file_get_string (metakey, FLATPAK_METADATA_GROUP_SESSION_BUS_POLICY, key, NULL);
+          FlatpakPolicy policy;
 
-          if (!xdg_app_verify_dbus_name (key, error))
+          if (!flatpak_verify_dbus_name (key, error))
             return FALSE;
 
-          policy = xdg_app_policy_from_string (value, error);
+          policy = flatpak_policy_from_string (value, error);
           if ((int) policy == -1)
             return FALSE;
 
-          xdg_app_context_set_session_bus_policy (context, key, policy);
+          flatpak_context_set_session_bus_policy (context, key, policy);
         }
     }
 
-  if (g_key_file_has_group (metakey, XDG_APP_METADATA_GROUP_SYSTEM_BUS_POLICY))
+  if (g_key_file_has_group (metakey, FLATPAK_METADATA_GROUP_SYSTEM_BUS_POLICY))
     {
       g_auto(GStrv) keys = NULL;
       gsize i, keys_count;
 
-      keys = g_key_file_get_keys (metakey, XDG_APP_METADATA_GROUP_SYSTEM_BUS_POLICY, &keys_count, NULL);
+      keys = g_key_file_get_keys (metakey, FLATPAK_METADATA_GROUP_SYSTEM_BUS_POLICY, &keys_count, NULL);
       for (i = 0; i < keys_count; i++)
         {
           const char *key = keys[i];
-          g_autofree char *value = g_key_file_get_string (metakey, XDG_APP_METADATA_GROUP_SYSTEM_BUS_POLICY, key, NULL);
-          XdgAppPolicy policy;
+          g_autofree char *value = g_key_file_get_string (metakey, FLATPAK_METADATA_GROUP_SYSTEM_BUS_POLICY, key, NULL);
+          FlatpakPolicy policy;
 
-          if (!xdg_app_verify_dbus_name (key, error))
+          if (!flatpak_verify_dbus_name (key, error))
             return FALSE;
 
-          policy = xdg_app_policy_from_string (value, error);
+          policy = flatpak_policy_from_string (value, error);
           if ((int) policy == -1)
             return FALSE;
 
-          xdg_app_context_set_system_bus_policy (context, key, policy);
+          flatpak_context_set_system_bus_policy (context, key, policy);
         }
     }
 
-  if (g_key_file_has_group (metakey, XDG_APP_METADATA_GROUP_ENVIRONMENT))
+  if (g_key_file_has_group (metakey, FLATPAK_METADATA_GROUP_ENVIRONMENT))
     {
       g_auto(GStrv) keys = NULL;
       gsize i, keys_count;
 
-      keys = g_key_file_get_keys (metakey, XDG_APP_METADATA_GROUP_ENVIRONMENT, &keys_count, NULL);
+      keys = g_key_file_get_keys (metakey, FLATPAK_METADATA_GROUP_ENVIRONMENT, &keys_count, NULL);
       for (i = 0; i < keys_count; i++)
         {
           const char *key = keys[i];
-          g_autofree char *value = g_key_file_get_string (metakey, XDG_APP_METADATA_GROUP_ENVIRONMENT, key, NULL);
+          g_autofree char *value = g_key_file_get_string (metakey, FLATPAK_METADATA_GROUP_ENVIRONMENT, key, NULL);
 
-          xdg_app_context_set_env_var (context, key, value);
+          flatpak_context_set_env_var (context, key, value);
         }
     }
 
@@ -1012,57 +1012,57 @@ xdg_app_context_load_metadata (XdgAppContext *context,
 }
 
 void
-xdg_app_context_save_metadata (XdgAppContext *context,
-                               GKeyFile      *metakey)
+flatpak_context_save_metadata (FlatpakContext *context,
+                               GKeyFile       *metakey)
 {
-  g_auto(GStrv) shared = xdg_app_context_shared_to_string (context->shares, context->shares_valid);
-  g_auto(GStrv) sockets = xdg_app_context_sockets_to_string (context->sockets, context->sockets_valid);
-  g_auto(GStrv) devices = xdg_app_context_devices_to_string (context->devices, context->devices_valid);
+  g_auto(GStrv) shared = flatpak_context_shared_to_string (context->shares, context->shares_valid);
+  g_auto(GStrv) sockets = flatpak_context_sockets_to_string (context->sockets, context->sockets_valid);
+  g_auto(GStrv) devices = flatpak_context_devices_to_string (context->devices, context->devices_valid);
   GHashTableIter iter;
   gpointer key, value;
 
   if (shared[0] != NULL)
     {
       g_key_file_set_string_list (metakey,
-                                  XDG_APP_METADATA_GROUP_CONTEXT,
-                                  XDG_APP_METADATA_KEY_SHARED,
+                                  FLATPAK_METADATA_GROUP_CONTEXT,
+                                  FLATPAK_METADATA_KEY_SHARED,
                                   (const char * const *) shared, g_strv_length (shared));
     }
   else
     {
       g_key_file_remove_key (metakey,
-                             XDG_APP_METADATA_GROUP_CONTEXT,
-                             XDG_APP_METADATA_KEY_SHARED,
+                             FLATPAK_METADATA_GROUP_CONTEXT,
+                             FLATPAK_METADATA_KEY_SHARED,
                              NULL);
     }
 
   if (sockets[0] != NULL)
     {
       g_key_file_set_string_list (metakey,
-                                  XDG_APP_METADATA_GROUP_CONTEXT,
-                                  XDG_APP_METADATA_KEY_SOCKETS,
+                                  FLATPAK_METADATA_GROUP_CONTEXT,
+                                  FLATPAK_METADATA_KEY_SOCKETS,
                                   (const char * const *) sockets, g_strv_length (sockets));
     }
   else
     {
       g_key_file_remove_key (metakey,
-                             XDG_APP_METADATA_GROUP_CONTEXT,
-                             XDG_APP_METADATA_KEY_SOCKETS,
+                             FLATPAK_METADATA_GROUP_CONTEXT,
+                             FLATPAK_METADATA_KEY_SOCKETS,
                              NULL);
     }
 
   if (devices[0] != NULL)
     {
       g_key_file_set_string_list (metakey,
-                                  XDG_APP_METADATA_GROUP_CONTEXT,
-                                  XDG_APP_METADATA_KEY_DEVICES,
+                                  FLATPAK_METADATA_GROUP_CONTEXT,
+                                  FLATPAK_METADATA_KEY_DEVICES,
                                   (const char * const *) devices, g_strv_length (devices));
     }
   else
     {
       g_key_file_remove_key (metakey,
-                             XDG_APP_METADATA_GROUP_CONTEXT,
-                             XDG_APP_METADATA_KEY_DEVICES,
+                             FLATPAK_METADATA_GROUP_CONTEXT,
+                             FLATPAK_METADATA_KEY_DEVICES,
                              NULL);
     }
 
@@ -1073,24 +1073,24 @@ xdg_app_context_save_metadata (XdgAppContext *context,
       g_hash_table_iter_init (&iter, context->filesystems);
       while (g_hash_table_iter_next (&iter, &key, &value))
         {
-          XdgAppFilesystemMode mode = GPOINTER_TO_INT (value);
+          FlatpakFilesystemMode mode = GPOINTER_TO_INT (value);
 
-          if (mode == XDG_APP_FILESYSTEM_MODE_READ_ONLY)
+          if (mode == FLATPAK_FILESYSTEM_MODE_READ_ONLY)
             g_ptr_array_add (array, g_strconcat (key, ":ro", NULL));
           else if (value != NULL)
             g_ptr_array_add (array, g_strdup (key));
         }
 
       g_key_file_set_string_list (metakey,
-                                  XDG_APP_METADATA_GROUP_CONTEXT,
-                                  XDG_APP_METADATA_KEY_FILESYSTEMS,
+                                  FLATPAK_METADATA_GROUP_CONTEXT,
+                                  FLATPAK_METADATA_KEY_FILESYSTEMS,
                                   (const char * const *) array->pdata, array->len);
     }
   else
     {
       g_key_file_remove_key (metakey,
-                             XDG_APP_METADATA_GROUP_CONTEXT,
-                             XDG_APP_METADATA_KEY_FILESYSTEMS,
+                             FLATPAK_METADATA_GROUP_CONTEXT,
+                             FLATPAK_METADATA_KEY_FILESYSTEMS,
                              NULL);
     }
 
@@ -1099,54 +1099,54 @@ xdg_app_context_save_metadata (XdgAppContext *context,
       g_autofree char **keys = (char **) g_hash_table_get_keys_as_array (context->persistent, NULL);
 
       g_key_file_set_string_list (metakey,
-                                  XDG_APP_METADATA_GROUP_CONTEXT,
-                                  XDG_APP_METADATA_KEY_PERSISTENT,
+                                  FLATPAK_METADATA_GROUP_CONTEXT,
+                                  FLATPAK_METADATA_KEY_PERSISTENT,
                                   (const char * const *) keys, g_strv_length (keys));
     }
   else
     {
       g_key_file_remove_key (metakey,
-                             XDG_APP_METADATA_GROUP_CONTEXT,
-                             XDG_APP_METADATA_KEY_PERSISTENT,
+                             FLATPAK_METADATA_GROUP_CONTEXT,
+                             FLATPAK_METADATA_KEY_PERSISTENT,
                              NULL);
     }
 
-  g_key_file_remove_group (metakey, XDG_APP_METADATA_GROUP_SESSION_BUS_POLICY, NULL);
+  g_key_file_remove_group (metakey, FLATPAK_METADATA_GROUP_SESSION_BUS_POLICY, NULL);
   g_hash_table_iter_init (&iter, context->session_bus_policy);
   while (g_hash_table_iter_next (&iter, &key, &value))
     {
-      XdgAppPolicy policy = GPOINTER_TO_INT (value);
+      FlatpakPolicy policy = GPOINTER_TO_INT (value);
       if (policy > 0)
         g_key_file_set_string (metakey,
-                               XDG_APP_METADATA_GROUP_SESSION_BUS_POLICY,
-                               (char *) key, xdg_app_policy_to_string (policy));
+                               FLATPAK_METADATA_GROUP_SESSION_BUS_POLICY,
+                               (char *) key, flatpak_policy_to_string (policy));
     }
 
-  g_key_file_remove_group (metakey, XDG_APP_METADATA_GROUP_SYSTEM_BUS_POLICY, NULL);
+  g_key_file_remove_group (metakey, FLATPAK_METADATA_GROUP_SYSTEM_BUS_POLICY, NULL);
   g_hash_table_iter_init (&iter, context->system_bus_policy);
   while (g_hash_table_iter_next (&iter, &key, &value))
     {
-      XdgAppPolicy policy = GPOINTER_TO_INT (value);
+      FlatpakPolicy policy = GPOINTER_TO_INT (value);
       if (policy > 0)
         g_key_file_set_string (metakey,
-                               XDG_APP_METADATA_GROUP_SYSTEM_BUS_POLICY,
-                               (char *) key, xdg_app_policy_to_string (policy));
+                               FLATPAK_METADATA_GROUP_SYSTEM_BUS_POLICY,
+                               (char *) key, flatpak_policy_to_string (policy));
     }
 
-  g_key_file_remove_group (metakey, XDG_APP_METADATA_GROUP_ENVIRONMENT, NULL);
+  g_key_file_remove_group (metakey, FLATPAK_METADATA_GROUP_ENVIRONMENT, NULL);
   g_hash_table_iter_init (&iter, context->env_vars);
   while (g_hash_table_iter_next (&iter, &key, &value))
     {
       g_key_file_set_string (metakey,
-                             XDG_APP_METADATA_GROUP_ENVIRONMENT,
+                             FLATPAK_METADATA_GROUP_ENVIRONMENT,
                              (char *) key, (char *) value);
     }
 }
 
 void
-xdg_app_context_allow_host_fs (XdgAppContext *context)
+flatpak_context_allow_host_fs (FlatpakContext *context)
 {
-  xdg_app_context_add_filesystem (context, "host");
+  flatpak_context_add_filesystem (context, "host");
 }
 
 static char *
@@ -1292,7 +1292,7 @@ create_tmp_fd (const char *contents,
 }
 
 static void
-xdg_app_run_add_x11_args (GPtrArray *argv_array,
+flatpak_run_add_x11_args (GPtrArray *argv_array,
                           char    ***envp_p)
 {
   char *x11_socket = NULL;
@@ -1357,7 +1357,7 @@ xdg_app_run_add_x11_args (GPtrArray *argv_array,
 }
 
 static void
-xdg_app_run_add_wayland_args (GPtrArray *argv_array,
+flatpak_run_add_wayland_args (GPtrArray *argv_array,
                               char    ***envp_p)
 {
   g_autofree char *wayland_socket = g_build_filename (g_get_user_runtime_dir (), "wayland-0", NULL);
@@ -1372,7 +1372,7 @@ xdg_app_run_add_wayland_args (GPtrArray *argv_array,
 }
 
 static void
-xdg_app_run_add_pulseaudio_args (GPtrArray *argv_array,
+flatpak_run_add_pulseaudio_args (GPtrArray *argv_array,
                                  char    ***envp_p)
 {
   char *pulseaudio_socket = g_build_filename (g_get_user_runtime_dir (), "pulse/native", NULL);
@@ -1424,11 +1424,11 @@ create_proxy_socket (char *template)
 }
 
 gboolean
-xdg_app_run_add_system_dbus_args (XdgAppContext *context,
-                                  char        ***envp_p,
-                                  GPtrArray     *argv_array,
-                                  GPtrArray     *dbus_proxy_argv,
-                                  gboolean       unrestricted)
+flatpak_run_add_system_dbus_args (FlatpakContext *context,
+                                  char         ***envp_p,
+                                  GPtrArray      *argv_array,
+                                  GPtrArray      *dbus_proxy_argv,
+                                  gboolean        unrestricted)
 {
   const char *dbus_address = g_getenv ("DBUS_SYSTEM_BUS_ADDRESS");
   g_autofree char *real_dbus_address = NULL;
@@ -1476,7 +1476,7 @@ xdg_app_run_add_system_dbus_args (XdgAppContext *context,
 }
 
 gboolean
-xdg_app_run_add_session_dbus_args (GPtrArray *argv_array,
+flatpak_run_add_session_dbus_args (GPtrArray *argv_array,
                                    char    ***envp_p,
                                    GPtrArray *dbus_proxy_argv,
                                    gboolean   unrestricted)
@@ -1522,10 +1522,10 @@ xdg_app_run_add_session_dbus_args (GPtrArray *argv_array,
 }
 
 static void
-xdg_app_add_bus_filters (GPtrArray     *dbus_proxy_argv,
-                         GHashTable    *ht,
-                         const char    *app_id,
-                         XdgAppContext *context)
+flatpak_add_bus_filters (GPtrArray      *dbus_proxy_argv,
+                         GHashTable     *ht,
+                         const char     *app_id,
+                         FlatpakContext *context)
 {
   GHashTableIter iter;
   gpointer key, value;
@@ -1540,15 +1540,15 @@ xdg_app_add_bus_filters (GPtrArray     *dbus_proxy_argv,
   g_hash_table_iter_init (&iter, ht);
   while (g_hash_table_iter_next (&iter, &key, &value))
     {
-      XdgAppPolicy policy = GPOINTER_TO_INT (value);
+      FlatpakPolicy policy = GPOINTER_TO_INT (value);
 
       if (policy > 0)
-        g_ptr_array_add (dbus_proxy_argv, g_strdup_printf ("--%s=%s", xdg_app_policy_to_string (policy), (char *) key));
+        g_ptr_array_add (dbus_proxy_argv, g_strdup_printf ("--%s=%s", flatpak_policy_to_string (policy), (char *) key));
     }
 }
 
 gboolean
-xdg_app_run_add_extension_args (GPtrArray    *argv_array,
+flatpak_run_add_extension_args (GPtrArray    *argv_array,
                                 GKeyFile     *metakey,
                                 const char   *full_ref,
                                 GCancellable *cancellable,
@@ -1560,19 +1560,19 @@ xdg_app_run_add_extension_args (GPtrArray    *argv_array,
 
   parts = g_strsplit (full_ref, "/", 0);
   if (g_strv_length (parts) != 4)
-    return xdg_app_fail (error, "Failed to determine parts from ref: %s", full_ref);
+    return flatpak_fail (error, "Failed to determine parts from ref: %s", full_ref);
 
   is_app = strcmp (parts[0], "app") == 0;
 
-  extensions = xdg_app_list_extensions (metakey,
+  extensions = flatpak_list_extensions (metakey,
                                         parts[2], parts[3]);
 
   for (l = extensions; l != NULL; l = l->next)
     {
-      XdgAppExtension *ext = l->data;
+      FlatpakExtension *ext = l->data;
       g_autoptr(GFile) deploy = NULL;
 
-      deploy = xdg_app_find_deploy_dir_for_ref (ext->ref, cancellable, NULL);
+      deploy = flatpak_find_deploy_dir_for_ref (ext->ref, cancellable, NULL);
       if (deploy != NULL)
         {
           g_autoptr(GFile) files = g_file_get_child (deploy, "files");
@@ -1586,15 +1586,15 @@ xdg_app_run_add_extension_args (GPtrArray    *argv_array,
         }
     }
 
-  g_list_free_full (extensions, (GDestroyNotify) xdg_app_extension_free);
+  g_list_free_full (extensions, (GDestroyNotify) flatpak_extension_free);
 
   return TRUE;
 }
 
 static void
-add_file_arg (GPtrArray           *argv_array,
-              XdgAppFilesystemMode mode,
-              const char          *path)
+add_file_arg (GPtrArray            *argv_array,
+              FlatpakFilesystemMode mode,
+              const char           *path)
 {
   struct stat st;
 
@@ -1605,19 +1605,19 @@ add_file_arg (GPtrArray           *argv_array,
       S_ISREG (st.st_mode))
     {
       add_args (argv_array,
-                (mode == XDG_APP_FILESYSTEM_MODE_READ_WRITE) ? "--bind" : "--ro-bind",
+                (mode == FLATPAK_FILESYSTEM_MODE_READ_WRITE) ? "--bind" : "--ro-bind",
                 path, path, NULL);
     }
 }
 
 void
-xdg_app_run_add_environment_args (GPtrArray     *argv_array,
-                                  char        ***envp_p,
-                                  GPtrArray     *session_bus_proxy_argv,
-                                  GPtrArray     *system_bus_proxy_argv,
-                                  const char    *app_id,
-                                  XdgAppContext *context,
-                                  GFile         *app_id_dir)
+flatpak_run_add_environment_args (GPtrArray      *argv_array,
+                                  char         ***envp_p,
+                                  GPtrArray      *session_bus_proxy_argv,
+                                  GPtrArray      *system_bus_proxy_argv,
+                                  const char     *app_id,
+                                  FlatpakContext *context,
+                                  GFile          *app_id_dir)
 {
   GHashTableIter iter;
   gpointer key, value;
@@ -1625,21 +1625,21 @@ xdg_app_run_add_environment_args (GPtrArray     *argv_array,
   gboolean unrestricted_system_bus;
   gboolean home_access = FALSE;
   GString *xdg_dirs_conf = NULL;
-  XdgAppFilesystemMode fs_mode, home_mode;
+  FlatpakFilesystemMode fs_mode, home_mode;
 
-  if ((context->shares & XDG_APP_CONTEXT_SHARED_IPC) == 0)
+  if ((context->shares & FLATPAK_CONTEXT_SHARED_IPC) == 0)
     {
       g_debug ("Disallowing ipc access");
       add_args (argv_array, "--unshare-ipc", NULL);
     }
 
-  if ((context->shares & XDG_APP_CONTEXT_SHARED_NETWORK) == 0)
+  if ((context->shares & FLATPAK_CONTEXT_SHARED_NETWORK) == 0)
     {
       g_debug ("Disallowing network access");
       add_args (argv_array, "--unshare-net", NULL);
     }
 
-  if (context->devices & XDG_APP_CONTEXT_DEVICE_DRI)
+  if (context->devices & FLATPAK_CONTEXT_DEVICE_DRI)
     {
       g_debug ("Allowing dri access");
       if (g_file_test ("/dev/dri", G_FILE_TEST_IS_DIR))
@@ -1653,7 +1653,7 @@ xdg_app_run_add_environment_args (GPtrArray     *argv_array,
         }
     }
 
-  fs_mode = (XdgAppFilesystemMode) g_hash_table_lookup (context->filesystems, "host");
+  fs_mode = (FlatpakFilesystemMode) g_hash_table_lookup (context->filesystems, "host");
   if (fs_mode != 0)
     {
       DIR *dir;
@@ -1680,7 +1680,7 @@ xdg_app_run_add_environment_args (GPtrArray     *argv_array,
       add_file_arg (argv_array, fs_mode, "/run/media");
     }
 
-  home_mode = (XdgAppFilesystemMode) g_hash_table_lookup (context->filesystems, "home");
+  home_mode = (FlatpakFilesystemMode) g_hash_table_lookup (context->filesystems, "home");
   if (home_mode != 0)
     {
       g_debug ("Allowing homedir access");
@@ -1712,7 +1712,7 @@ xdg_app_run_add_environment_args (GPtrArray     *argv_array,
   while (g_hash_table_iter_next (&iter, &key, &value))
     {
       const char *filesystem = key;
-      XdgAppFilesystemMode mode = GPOINTER_TO_INT (value);
+      FlatpakFilesystemMode mode = GPOINTER_TO_INT (value);
 
       if (value == NULL ||
           strcmp (filesystem, "host") == 0 ||
@@ -1816,38 +1816,38 @@ xdg_app_run_add_environment_args (GPtrArray     *argv_array,
       g_string_free (xdg_dirs_conf, TRUE);
     }
 
-  if (context->sockets & XDG_APP_CONTEXT_SOCKET_X11)
+  if (context->sockets & FLATPAK_CONTEXT_SOCKET_X11)
     {
       g_debug ("Allowing x11 access");
-      xdg_app_run_add_x11_args (argv_array, envp_p);
+      flatpak_run_add_x11_args (argv_array, envp_p);
     }
 
-  if (context->sockets & XDG_APP_CONTEXT_SOCKET_WAYLAND)
+  if (context->sockets & FLATPAK_CONTEXT_SOCKET_WAYLAND)
     {
       g_debug ("Allowing wayland access");
-      xdg_app_run_add_wayland_args (argv_array, envp_p);
+      flatpak_run_add_wayland_args (argv_array, envp_p);
     }
 
-  if (context->sockets & XDG_APP_CONTEXT_SOCKET_PULSEAUDIO)
+  if (context->sockets & FLATPAK_CONTEXT_SOCKET_PULSEAUDIO)
     {
       g_debug ("Allowing pulseaudio access");
-      xdg_app_run_add_pulseaudio_args (argv_array, envp_p);
+      flatpak_run_add_pulseaudio_args (argv_array, envp_p);
     }
 
-  unrestricted_session_bus = (context->sockets & XDG_APP_CONTEXT_SOCKET_SESSION_BUS) != 0;
+  unrestricted_session_bus = (context->sockets & FLATPAK_CONTEXT_SOCKET_SESSION_BUS) != 0;
   if (unrestricted_session_bus)
     g_debug ("Allowing session-dbus access");
-  if (xdg_app_run_add_session_dbus_args (argv_array, envp_p, session_bus_proxy_argv, unrestricted_session_bus) &&
+  if (flatpak_run_add_session_dbus_args (argv_array, envp_p, session_bus_proxy_argv, unrestricted_session_bus) &&
       !unrestricted_session_bus && session_bus_proxy_argv)
-    xdg_app_add_bus_filters (session_bus_proxy_argv, context->session_bus_policy, app_id, context);
+    flatpak_add_bus_filters (session_bus_proxy_argv, context->session_bus_policy, app_id, context);
 
-  unrestricted_system_bus = (context->sockets & XDG_APP_CONTEXT_SOCKET_SYSTEM_BUS) != 0;
+  unrestricted_system_bus = (context->sockets & FLATPAK_CONTEXT_SOCKET_SYSTEM_BUS) != 0;
   if (unrestricted_system_bus)
     g_debug ("Allowing system-dbus access");
-  if (xdg_app_run_add_system_dbus_args (context, envp_p, argv_array, system_bus_proxy_argv,
+  if (flatpak_run_add_system_dbus_args (context, envp_p, argv_array, system_bus_proxy_argv,
                                         unrestricted_system_bus) &&
       !unrestricted_system_bus && system_bus_proxy_argv)
-    xdg_app_add_bus_filters (system_bus_proxy_argv, context->system_bus_policy, NULL, context);
+    flatpak_add_bus_filters (system_bus_proxy_argv, context->system_bus_policy, NULL, context);
 
 }
 
@@ -1873,7 +1873,7 @@ static const struct {const char *env;
 };
 
 char **
-xdg_app_run_get_minimal_env (gboolean devel)
+flatpak_run_get_minimal_env (gboolean devel)
 {
   GPtrArray *env_array;
   static const char * const copy[] = {
@@ -1943,7 +1943,7 @@ xdg_app_run_get_minimal_env (gboolean devel)
 }
 
 char **
-xdg_app_run_apply_env_default (char **envp)
+flatpak_run_apply_env_default (char **envp)
 {
   int i;
 
@@ -1954,7 +1954,7 @@ xdg_app_run_apply_env_default (char **envp)
 }
 
 char **
-xdg_app_run_apply_env_appid (char **envp,
+flatpak_run_apply_env_appid (char **envp,
                              GFile *app_dir)
 {
   g_autoptr(GFile) app_dir_data = NULL;
@@ -1972,7 +1972,7 @@ xdg_app_run_apply_env_appid (char **envp,
 }
 
 char **
-xdg_app_run_apply_env_vars (char **envp, XdgAppContext *context)
+flatpak_run_apply_env_vars (char **envp, FlatpakContext *context)
 {
   GHashTableIter iter;
   gpointer key, value;
@@ -1993,7 +1993,7 @@ xdg_app_run_apply_env_vars (char **envp, XdgAppContext *context)
 }
 
 GFile *
-xdg_app_get_data_dir (const char *app_id)
+flatpak_get_data_dir (const char *app_id)
 {
   g_autoptr(GFile) home = g_file_new_for_path (g_get_home_dir ());
   g_autoptr(GFile) var_app = g_file_resolve_relative_path (home, ".var/app");
@@ -2002,11 +2002,11 @@ xdg_app_get_data_dir (const char *app_id)
 }
 
 GFile *
-xdg_app_ensure_data_dir (const char   *app_id,
+flatpak_ensure_data_dir (const char   *app_id,
                          GCancellable *cancellable,
                          GError      **error)
 {
-  g_autoptr(GFile) dir = xdg_app_get_data_dir (app_id);
+  g_autoptr(GFile) dir = flatpak_get_data_dir (app_id);
   g_autoptr(GFile) data_dir = g_file_get_child (dir, "data");
   g_autoptr(GFile) cache_dir = g_file_get_child (dir, "cache");
   g_autoptr(GFile) config_dir = g_file_get_child (dir, "config");
@@ -2042,7 +2042,7 @@ job_removed_cb (SystemdManager *manager,
 }
 
 gboolean
-xdg_app_run_in_transient_unit (const char *appid, GError **error)
+flatpak_run_in_transient_unit (const char *appid, GError **error)
 {
   g_autoptr(GDBusConnection) conn = NULL;
   g_autofree char *path = NULL;
@@ -2062,7 +2062,7 @@ xdg_app_run_in_transient_unit (const char *appid, GError **error)
   path = g_strdup_printf ("/run/user/%d/systemd/private", getuid ());
 
   if (!g_file_test (path, G_FILE_TEST_EXISTS))
-    return xdg_app_fail (error,
+    return flatpak_fail (error,
                          "No systemd user session available, sandboxing not available");
 
   main_context = g_main_context_new ();
@@ -2164,40 +2164,40 @@ add_font_path_args (GPtrArray *argv_array)
 }
 
 static void
-add_default_permissions (XdgAppContext *app_context)
+add_default_permissions (FlatpakContext *app_context)
 {
-  xdg_app_context_set_session_bus_policy (app_context,
+  flatpak_context_set_session_bus_policy (app_context,
                                           "org.freedesktop.portal.Documents",
-                                          XDG_APP_POLICY_TALK);
+                                          FLATPAK_POLICY_TALK);
 }
 
-static XdgAppContext *
+static FlatpakContext *
 compute_permissions (GKeyFile *app_metadata,
                      GKeyFile *runtime_metadata,
                      GError  **error)
 {
-  g_autoptr(XdgAppContext) app_context = NULL;
+  g_autoptr(FlatpakContext) app_context = NULL;
 
-  app_context = xdg_app_context_new ();
+  app_context = flatpak_context_new ();
 
   add_default_permissions (app_context);
 
-  if (!xdg_app_context_load_metadata (app_context, runtime_metadata, error))
+  if (!flatpak_context_load_metadata (app_context, runtime_metadata, error))
     return NULL;
 
-  if (!xdg_app_context_load_metadata (app_context, app_metadata, error))
+  if (!flatpak_context_load_metadata (app_context, app_metadata, error))
     return NULL;
 
   return g_steal_pointer (&app_context);
 }
 
 static gboolean
-add_app_info_args (GPtrArray     *argv_array,
-                   XdgAppDeploy  *deploy,
-                   const char    *app_id,
-                   const char    *runtime_ref,
-                   XdgAppContext *final_app_context,
-                   GError       **error)
+add_app_info_args (GPtrArray      *argv_array,
+                   FlatpakDeploy  *deploy,
+                   const char     *app_id,
+                   const char     *runtime_ref,
+                   FlatpakContext *final_app_context,
+                   GError        **error)
 {
   g_autofree char *tmp_path = NULL;
   int fd;
@@ -2218,12 +2218,12 @@ add_app_info_args (GPtrArray     *argv_array,
       g_key_file_set_string (keyfile, "Application", "name", app_id);
       g_key_file_set_string (keyfile, "Application", "runtime", runtime_ref);
 
-      files = xdg_app_deploy_get_files (deploy);
+      files = flatpak_deploy_get_files (deploy);
       files_path = g_file_get_path (files);
 
       g_key_file_set_string (keyfile, "Application", "app-path", files_path);
 
-      xdg_app_context_save_metadata (final_app_context, keyfile);
+      flatpak_context_save_metadata (final_app_context, keyfile);
 
       if (!g_key_file_save_to_file (keyfile, tmp_path, error))
         return FALSE;
@@ -2253,8 +2253,8 @@ add_monitor_path_args (GPtrArray *argv_array,
   session_helper =
     xdg_app_session_helper_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
                                                    G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
-                                                   "org.freedesktop.XdgApp",
-                                                   "/org/freedesktop/XdgApp/SessionHelper",
+                                                   "org.freedesktop.Flatpak",
+                                                   "/org/freedesktop/Flatpak/SessionHelper",
                                                    NULL, NULL);
   if (session_helper &&
       xdg_app_session_helper_call_request_monitor_sync (session_helper,
@@ -2376,7 +2376,7 @@ add_dbus_proxy_args (GPtrArray *argv_array,
       add_args (argv_array, "--sync-fd", fd_str, NULL);
     }
 
-  proxy = g_getenv ("XDG_APP_DBUSPROXY");
+  proxy = g_getenv ("FLATPAK_DBUSPROXY");
   if (proxy == NULL)
     proxy = DBUSPROXY;
 
@@ -2527,7 +2527,7 @@ setup_seccomp (GPtrArray  *argv_array,
 
   seccomp = seccomp_init (SCMP_ACT_ALLOW);
   if (!seccomp)
-    return xdg_app_fail (error, "Initialize seccomp failed");
+    return flatpak_fail (error, "Initialize seccomp failed");
 
   if (arch != NULL)
     {
@@ -2549,7 +2549,7 @@ setup_seccomp (GPtrArray  *argv_array,
              couldn't continue runnning. */
           r = seccomp_arch_add (seccomp, arch_id);
           if (r < 0 && r != -EEXIST)
-            return xdg_app_fail (error, "Failed to add architecture to seccomp filter");
+            return flatpak_fail (error, "Failed to add architecture to seccomp filter");
         }
     }
 
@@ -2558,15 +2558,15 @@ setup_seccomp (GPtrArray  *argv_array,
 #if defined(__i386__) || defined(__x86_64__)
   r = seccomp_arch_add (seccomp, SCMP_ARCH_X86);
   if (r < 0 && r != -EEXIST)
-    return xdg_app_fail (error, "Failed to add x86 architecture to seccomp filter");
+    return flatpak_fail (error, "Failed to add x86 architecture to seccomp filter");
 
   r = seccomp_arch_add (seccomp, SCMP_ARCH_X86_64);
   if (r < 0 && r != -EEXIST)
-    return xdg_app_fail (error, "Failed to add x86_64 architecture to seccomp filter");
+    return flatpak_fail (error, "Failed to add x86_64 architecture to seccomp filter");
 
   r = seccomp_arch_add (seccomp, SCMP_ARCH_X32);
   if (r < 0 && r != -EEXIST)
-    return xdg_app_fail (error, "Failed to add x32 architecture to seccomp filter");
+    return flatpak_fail (error, "Failed to add x32 architecture to seccomp filter");
 #endif
 
   /* TODO: Should we filter the kernel keyring syscalls in some way?
@@ -2582,7 +2582,7 @@ setup_seccomp (GPtrArray  *argv_array,
       else
         r = seccomp_rule_add (seccomp, SCMP_ACT_ERRNO (EPERM), scall, 0);
       if (r < 0 && r == -EFAULT /* unknown syscall */)
-        return xdg_app_fail (error, "Failed to block syscall %d", scall);
+        return flatpak_fail (error, "Failed to block syscall %d", scall);
     }
 
   if (!devel)
@@ -2596,7 +2596,7 @@ setup_seccomp (GPtrArray  *argv_array,
             r = seccomp_rule_add (seccomp, SCMP_ACT_ERRNO (EPERM), scall, 0);
 
           if (r < 0 && r == -EFAULT /* unknown syscall */)
-            return xdg_app_fail (error, "Failed to block syscall %d", scall);
+            return flatpak_fail (error, "Failed to block syscall %d", scall);
         }
     }
 
@@ -2619,7 +2619,7 @@ setup_seccomp (GPtrArray  *argv_array,
   unlink (path);
 
   if (seccomp_export_bpf (seccomp, fd) != 0)
-    return xdg_app_fail (error, "Failed to export bpf");
+    return flatpak_fail (error, "Failed to export bpf");
 
   lseek (fd, 0, SEEK_SET);
 
@@ -2636,12 +2636,12 @@ setup_seccomp (GPtrArray  *argv_array,
 #endif
 
 gboolean
-xdg_app_run_setup_base_argv (GPtrArray     *argv_array,
-                             GFile         *runtime_files,
-                             GFile         *app_id_dir,
-                             const char    *arch,
-                             XdgAppRunFlags flags,
-                             GError       **error)
+flatpak_run_setup_base_argv (GPtrArray      *argv_array,
+                             GFile          *runtime_files,
+                             GFile          *app_id_dir,
+                             const char     *arch,
+                             FlatpakRunFlags flags,
+                             GError        **error)
 {
   const char *usr_links[] = {"lib", "lib32", "lib64", "bin", "sbin"};
   g_autofree char *run_dir = g_strdup_printf ("/run/user/%d", getuid ());
@@ -2781,7 +2781,7 @@ xdg_app_run_setup_base_argv (GPtrArray     *argv_array,
 #ifdef ENABLE_SECCOMP
   if (!setup_seccomp (argv_array,
                       arch,
-                      (flags & XDG_APP_RUN_FLAG_DEVEL) != 0,
+                      (flags & FLATPAK_RUN_FLAG_DEVEL) != 0,
                       error))
     return FALSE;
 #endif
@@ -2811,19 +2811,19 @@ join_args (GPtrArray *argv_array, gsize *len_out)
 }
 
 gboolean
-xdg_app_run_app (const char    *app_ref,
-                 XdgAppDeploy  *app_deploy,
-                 XdgAppContext *extra_context,
-                 const char    *custom_runtime,
-                 const char    *custom_runtime_version,
-                 XdgAppRunFlags flags,
-                 const char    *custom_command,
-                 char          *args[],
-                 int            n_args,
-                 GCancellable  *cancellable,
-                 GError       **error)
-{
-  g_autoptr(XdgAppDeploy) runtime_deploy = NULL;
+flatpak_run_app (const char     *app_ref,
+                 FlatpakDeploy  *app_deploy,
+                 FlatpakContext *extra_context,
+                 const char     *custom_runtime,
+                 const char     *custom_runtime_version,
+                 FlatpakRunFlags flags,
+                 const char     *custom_command,
+                 char           *args[],
+                 int             n_args,
+                 GCancellable   *cancellable,
+                 GError        **error)
+{
+  g_autoptr(FlatpakDeploy) runtime_deploy = NULL;
   g_autoptr(GFile) app_files = NULL;
   g_autoptr(GFile) runtime_files = NULL;
   g_autoptr(GFile) app_id_dir = NULL;
@@ -2842,22 +2842,22 @@ xdg_app_run_app (const char    *app_ref,
   g_autoptr(GError) my_error = NULL;
   g_auto(GStrv) runtime_parts = NULL;
   int i;
-  g_autoptr(XdgAppContext) app_context = NULL;
-  g_autoptr(XdgAppContext) overrides = NULL;
+  g_autoptr(FlatpakContext) app_context = NULL;
+  g_autoptr(FlatpakContext) overrides = NULL;
   g_auto(GStrv) app_ref_parts = NULL;
 
-  app_ref_parts = xdg_app_decompose_ref (app_ref, error);
+  app_ref_parts = flatpak_decompose_ref (app_ref, error);
   if (app_ref_parts == NULL)
     return FALSE;
 
-  metakey = xdg_app_deploy_get_metadata (app_deploy);
+  metakey = flatpak_deploy_get_metadata (app_deploy);
 
   argv_array = g_ptr_array_new_with_free_func (g_free);
   session_bus_proxy_argv = g_ptr_array_new_with_free_func (g_free);
   system_bus_proxy_argv = g_ptr_array_new_with_free_func (g_free);
 
   default_runtime = g_key_file_get_string (metakey, "Application",
-                                           (flags & XDG_APP_RUN_FLAG_DEVEL) != 0 ? "sdk" : "runtime",
+                                           (flags & FLATPAK_RUN_FLAG_DEVEL) != 0 ? "sdk" : "runtime",
                                            &my_error);
   if (my_error)
     {
@@ -2867,7 +2867,7 @@ xdg_app_run_app (const char    *app_ref,
 
   runtime_parts = g_strsplit (default_runtime, "/", 0);
   if (g_strv_length (runtime_parts) != 3)
-    return xdg_app_fail (error, "Wrong number of components in runtime %s", default_runtime);
+    return flatpak_fail (error, "Wrong number of components in runtime %s", default_runtime);
 
   if (custom_runtime)
     {
@@ -2889,7 +2889,7 @@ xdg_app_run_app (const char    *app_ref,
       runtime_parts[2] = g_strdup (custom_runtime_version);
     }
 
-  runtime_ref = xdg_app_compose_ref (FALSE,
+  runtime_ref = flatpak_compose_ref (FALSE,
                                      runtime_parts[0],
                                      runtime_parts[2],
                                      runtime_parts[1],
@@ -2897,32 +2897,32 @@ xdg_app_run_app (const char    *app_ref,
   if (runtime_ref == NULL)
     return FALSE;
 
-  runtime_deploy = xdg_app_find_deploy_for_ref (runtime_ref, cancellable, error);
+  runtime_deploy = flatpak_find_deploy_for_ref (runtime_ref, cancellable, error);
   if (runtime_deploy == NULL)
     return FALSE;
 
-  runtime_metakey = xdg_app_deploy_get_metadata (runtime_deploy);
+  runtime_metakey = flatpak_deploy_get_metadata (runtime_deploy);
 
   app_context = compute_permissions (metakey, runtime_metakey, error);
   if (app_context == NULL)
     return FALSE;
 
-  overrides = xdg_app_deploy_get_overrides (app_deploy);
-  xdg_app_context_merge (app_context, overrides);
+  overrides = flatpak_deploy_get_overrides (app_deploy);
+  flatpak_context_merge (app_context, overrides);
 
   if (extra_context)
-    xdg_app_context_merge (app_context, extra_context);
+    flatpak_context_merge (app_context, extra_context);
 
-  runtime_files = xdg_app_deploy_get_files (runtime_deploy);
-  app_files = xdg_app_deploy_get_files (app_deploy);
+  runtime_files = flatpak_deploy_get_files (runtime_deploy);
+  app_files = flatpak_deploy_get_files (app_deploy);
 
-  if ((app_id_dir = xdg_app_ensure_data_dir (app_ref_parts[1], cancellable, error)) == NULL)
+  if ((app_id_dir = flatpak_ensure_data_dir (app_ref_parts[1], cancellable, error)) == NULL)
     return FALSE;
 
   envp = g_get_environ ();
-  envp = xdg_app_run_apply_env_default (envp);
-  envp = xdg_app_run_apply_env_vars (envp, app_context);
-  envp = xdg_app_run_apply_env_appid (envp, app_id_dir);
+  envp = flatpak_run_apply_env_default (envp);
+  envp = flatpak_run_apply_env_vars (envp, app_context);
+  envp = flatpak_run_apply_env_appid (envp, app_id_dir);
 
   add_args (argv_array,
             "--ro-bind", gs_file_get_path_cached (runtime_files), "/usr",
@@ -2931,23 +2931,23 @@ xdg_app_run_app (const char    *app_ref,
             "--lock-file", "/app/.ref",
             NULL);
 
-  if (!xdg_app_run_setup_base_argv (argv_array, runtime_files, app_id_dir, app_ref_parts[2], flags, error))
+  if (!flatpak_run_setup_base_argv (argv_array, runtime_files, app_id_dir, app_ref_parts[2], flags, error))
     return FALSE;
 
   if (!add_app_info_args (argv_array, app_deploy, app_ref_parts[1], runtime_ref, app_context, error))
     return FALSE;
 
-  if (!xdg_app_run_add_extension_args (argv_array, metakey, app_ref, cancellable, error))
+  if (!flatpak_run_add_extension_args (argv_array, metakey, app_ref, cancellable, error))
     return FALSE;
 
-  if (!xdg_app_run_add_extension_args (argv_array, runtime_metakey, runtime_ref, cancellable, error))
+  if (!flatpak_run_add_extension_args (argv_array, runtime_metakey, runtime_ref, cancellable, error))
     return FALSE;
 
   add_monitor_path_args (argv_array, &envp);
 
   add_document_portal_args (argv_array, app_ref_parts[1]);
 
-  xdg_app_run_add_environment_args (argv_array, &envp,
+  flatpak_run_add_environment_args (argv_array, &envp,
                                     session_bus_proxy_argv,
                                     system_bus_proxy_argv,
                                     app_ref_parts[1], app_context, app_id_dir);
@@ -2956,13 +2956,13 @@ xdg_app_run_app (const char    *app_ref,
 
   /* Must run this before spawning the dbus proxy, to ensure it
      ends up in the app cgroup */
-  if (!xdg_app_run_in_transient_unit (app_ref_parts[1], error))
+  if (!flatpak_run_in_transient_unit (app_ref_parts[1], error))
     return FALSE;
 
-  if (!add_dbus_proxy_args (argv_array, session_bus_proxy_argv, (flags & XDG_APP_RUN_FLAG_LOG_SESSION_BUS) != 0, sync_fds, error))
+  if (!add_dbus_proxy_args (argv_array, session_bus_proxy_argv, (flags & FLATPAK_RUN_FLAG_LOG_SESSION_BUS) != 0, sync_fds, error))
     return FALSE;
 
-  if (!add_dbus_proxy_args (argv_array, system_bus_proxy_argv, (flags & XDG_APP_RUN_FLAG_LOG_SYSTEM_BUS) != 0, sync_fds, error))
+  if (!add_dbus_proxy_args (argv_array, system_bus_proxy_argv, (flags & FLATPAK_RUN_FLAG_LOG_SYSTEM_BUS) != 0, sync_fds, error))
     return FALSE;
 
   if (sync_fds[1] != -1)
@@ -3000,7 +3000,7 @@ xdg_app_run_app (const char    *app_ref,
     }
 
   real_argv_array = g_ptr_array_new_with_free_func (g_free);
-  g_ptr_array_add (real_argv_array, g_strdup (xdg_app_get_bwrap ()));
+  g_ptr_array_add (real_argv_array, g_strdup (flatpak_get_bwrap ()));
 
   {
     gsize len;
@@ -3025,7 +3025,7 @@ xdg_app_run_app (const char    *app_ref,
 
   g_ptr_array_add (real_argv_array, NULL);
 
-  if ((flags & XDG_APP_RUN_FLAG_BACKGROUND) != 0)
+  if ((flags & FLATPAK_RUN_FLAG_BACKGROUND) != 0)
     {
       if (!g_spawn_async (NULL,
                           (char **) real_argv_array->pdata,
@@ -3038,7 +3038,7 @@ xdg_app_run_app (const char    *app_ref,
     }
   else
     {
-      if (execvpe (xdg_app_get_bwrap (), (char **) real_argv_array->pdata, envp) == -1)
+      if (execvpe (flatpak_get_bwrap (), (char **) real_argv_array->pdata, envp) == -1)
         {
           g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), "Unable to start app");
           return FALSE;
diff --git a/common/xdg-app-run.h b/common/xdg-app-run.h
index e4ebb05..d066740 100644
--- a/common/xdg-app-run.h
+++ b/common/xdg-app-run.h
@@ -18,94 +18,94 @@
  *       Alexander Larsson <alexl@redhat.com>
  */
 
-#ifndef __XDG_APP_RUN_H__
-#define __XDG_APP_RUN_H__
+#ifndef __FLATPAK_RUN_H__
+#define __FLATPAK_RUN_H__
 
 #include "libglnx/libglnx.h"
 #include "dbus-proxy/xdg-app-proxy.h"
 #include "xdg-app-common-types.h"
 
-gboolean xdg_app_run_in_transient_unit (const char *app_id,
+gboolean flatpak_run_in_transient_unit (const char *app_id,
                                         GError    **error);
 
-#define XDG_APP_METADATA_GROUP_CONTEXT "Context"
-#define XDG_APP_METADATA_GROUP_SESSION_BUS_POLICY "Session Bus Policy"
-#define XDG_APP_METADATA_GROUP_SYSTEM_BUS_POLICY "System Bus Policy"
-#define XDG_APP_METADATA_GROUP_ENVIRONMENT "Environment"
-#define XDG_APP_METADATA_KEY_SHARED "shared"
-#define XDG_APP_METADATA_KEY_SOCKETS "sockets"
-#define XDG_APP_METADATA_KEY_FILESYSTEMS "filesystems"
-#define XDG_APP_METADATA_KEY_PERSISTENT "persistent"
-#define XDG_APP_METADATA_KEY_DEVICES "devices"
+#define FLATPAK_METADATA_GROUP_CONTEXT "Context"
+#define FLATPAK_METADATA_GROUP_SESSION_BUS_POLICY "Session Bus Policy"
+#define FLATPAK_METADATA_GROUP_SYSTEM_BUS_POLICY "System Bus Policy"
+#define FLATPAK_METADATA_GROUP_ENVIRONMENT "Environment"
+#define FLATPAK_METADATA_KEY_SHARED "shared"
+#define FLATPAK_METADATA_KEY_SOCKETS "sockets"
+#define FLATPAK_METADATA_KEY_FILESYSTEMS "filesystems"
+#define FLATPAK_METADATA_KEY_PERSISTENT "persistent"
+#define FLATPAK_METADATA_KEY_DEVICES "devices"
 
-XdgAppContext *xdg_app_context_new (void);
-void           xdg_app_context_free (XdgAppContext *context);
-void           xdg_app_context_merge (XdgAppContext *context,
-                                      XdgAppContext *other);
-GOptionGroup  *xdg_app_context_get_options (XdgAppContext *context);
-gboolean       xdg_app_context_load_metadata (XdgAppContext *context,
-                                              GKeyFile      *metakey,
-                                              GError       **error);
-void           xdg_app_context_save_metadata (XdgAppContext *context,
-                                              GKeyFile      *metakey);
-void           xdg_app_context_allow_host_fs (XdgAppContext *context);
-void           xdg_app_context_set_session_bus_policy (XdgAppContext *context,
-                                                       const char    *name,
-                                                       XdgAppPolicy   policy);
-void           xdg_app_context_set_system_bus_policy (XdgAppContext *context,
-                                                      const char    *name,
-                                                      XdgAppPolicy   policy);
+FlatpakContext *flatpak_context_new (void);
+void           flatpak_context_free (FlatpakContext *context);
+void           flatpak_context_merge (FlatpakContext *context,
+                                      FlatpakContext *other);
+GOptionGroup  *flatpak_context_get_options (FlatpakContext *context);
+gboolean       flatpak_context_load_metadata (FlatpakContext *context,
+                                              GKeyFile       *metakey,
+                                              GError        **error);
+void           flatpak_context_save_metadata (FlatpakContext *context,
+                                              GKeyFile       *metakey);
+void           flatpak_context_allow_host_fs (FlatpakContext *context);
+void           flatpak_context_set_session_bus_policy (FlatpakContext *context,
+                                                       const char     *name,
+                                                       FlatpakPolicy   policy);
+void           flatpak_context_set_system_bus_policy (FlatpakContext *context,
+                                                      const char     *name,
+                                                      FlatpakPolicy   policy);
 
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (XdgAppContext, xdg_app_context_free)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FlatpakContext, flatpak_context_free)
 
-gboolean  xdg_app_run_add_extension_args (GPtrArray    *argv_array,
+gboolean  flatpak_run_add_extension_args (GPtrArray    *argv_array,
                                           GKeyFile     *metakey,
                                           const char   *full_ref,
                                           GCancellable *cancellable,
                                           GError      **error);
-void     xdg_app_run_add_environment_args (GPtrArray     *argv_array,
-                                           char        ***envp_p,
-                                           GPtrArray     *session_bus_proxy_argv,
-                                           GPtrArray     *system_bus_proxy_argv,
-                                           const char    *app_id,
-                                           XdgAppContext *context,
-                                           GFile         *app_id_dir);
-char **  xdg_app_run_get_minimal_env (gboolean devel);
-char **  xdg_app_run_apply_env_default (char **envp);
-char **  xdg_app_run_apply_env_appid (char **envp,
+void     flatpak_run_add_environment_args (GPtrArray      *argv_array,
+                                           char         ***envp_p,
+                                           GPtrArray      *session_bus_proxy_argv,
+                                           GPtrArray      *system_bus_proxy_argv,
+                                           const char     *app_id,
+                                           FlatpakContext *context,
+                                           GFile          *app_id_dir);
+char **  flatpak_run_get_minimal_env (gboolean devel);
+char **  flatpak_run_apply_env_default (char **envp);
+char **  flatpak_run_apply_env_appid (char **envp,
                                       GFile *app_dir);
-char **  xdg_app_run_apply_env_vars (char         **envp,
-                                     XdgAppContext *context);
+char **  flatpak_run_apply_env_vars (char          **envp,
+                                     FlatpakContext *context);
 
-GFile *xdg_app_get_data_dir (const char *app_id);
-GFile *xdg_app_ensure_data_dir (const char   *app_id,
+GFile *flatpak_get_data_dir (const char *app_id);
+GFile *flatpak_ensure_data_dir (const char   *app_id,
                                 GCancellable *cancellable,
                                 GError      **error);
 
 typedef enum {
-  XDG_APP_RUN_FLAG_DEVEL           = (1 << 0),
-  XDG_APP_RUN_FLAG_BACKGROUND      = (1 << 1),
-  XDG_APP_RUN_FLAG_LOG_SESSION_BUS = (1 << 2),
-  XDG_APP_RUN_FLAG_LOG_SYSTEM_BUS  = (1 << 3),
-} XdgAppRunFlags;
+  FLATPAK_RUN_FLAG_DEVEL           = (1 << 0),
+  FLATPAK_RUN_FLAG_BACKGROUND      = (1 << 1),
+  FLATPAK_RUN_FLAG_LOG_SESSION_BUS = (1 << 2),
+  FLATPAK_RUN_FLAG_LOG_SYSTEM_BUS  = (1 << 3),
+} FlatpakRunFlags;
 
-gboolean xdg_app_run_setup_base_argv (GPtrArray     *argv_array,
-                                      GFile         *runtime_files,
-                                      GFile         *app_id_dir,
-                                      const char    *arch,
-                                      XdgAppRunFlags flags,
-                                      GError       **error);
-gboolean xdg_app_run_app (const char    *app_ref,
-                          XdgAppDeploy  *app_deploy,
-                          XdgAppContext *extra_context,
-                          const char    *custom_runtime,
-                          const char    *custom_runtime_version,
-                          XdgAppRunFlags flags,
-                          const char    *custom_command,
-                          char          *args[],
-                          int            n_args,
-                          GCancellable  *cancellable,
-                          GError       **error);
+gboolean flatpak_run_setup_base_argv (GPtrArray      *argv_array,
+                                      GFile          *runtime_files,
+                                      GFile          *app_id_dir,
+                                      const char     *arch,
+                                      FlatpakRunFlags flags,
+                                      GError        **error);
+gboolean flatpak_run_app (const char     *app_ref,
+                          FlatpakDeploy  *app_deploy,
+                          FlatpakContext *extra_context,
+                          const char     *custom_runtime,
+                          const char     *custom_runtime_version,
+                          FlatpakRunFlags flags,
+                          const char     *custom_command,
+                          char           *args[],
+                          int             n_args,
+                          GCancellable   *cancellable,
+                          GError        **error);
 
 
-#endif /* __XDG_APP_RUN_H__ */
+#endif /* __FLATPAK_RUN_H__ */
diff --git a/common/xdg-app-utils.c b/common/xdg-app-utils.c
index c2119af..5fbfabf 100644
--- a/common/xdg-app-utils.c
+++ b/common/xdg-app-utils.c
@@ -39,7 +39,7 @@
 #include <libsoup/soup.h>
 
 GBytes *
-xdg_app_read_stream (GInputStream *in,
+flatpak_read_stream (GInputStream *in,
                      gboolean      null_terminate,
                      GError      **error)
 {
@@ -63,7 +63,7 @@ xdg_app_read_stream (GInputStream *in,
 }
 
 gint
-xdg_app_strcmp0_ptr (gconstpointer a,
+flatpak_strcmp0_ptr (gconstpointer a,
                      gconstpointer b)
 {
   return g_strcmp0 (*(char * const *) a, *(char * const *) b);
@@ -71,7 +71,7 @@ xdg_app_strcmp0_ptr (gconstpointer a,
 
 /* Returns end of matching path prefix, or NULL if no match */
 const char *
-xdg_app_path_match_prefix (const char *pattern,
+flatpak_path_match_prefix (const char *pattern,
                            const char *string)
 {
   char c, test;
@@ -122,7 +122,7 @@ xdg_app_path_match_prefix (const char *pattern,
 
           while ((test = *string) != 0)
             {
-              tmp = xdg_app_path_match_prefix (pattern, string);
+              tmp = flatpak_path_match_prefix (pattern, string);
               if (tmp != NULL)
                 return tmp;
               if (test == '/')
@@ -142,7 +142,7 @@ xdg_app_path_match_prefix (const char *pattern,
 }
 
 gboolean
-xdg_app_fail (GError **error, const char *format, ...)
+flatpak_fail (GError **error, const char *format, ...)
 {
   g_autofree char *message = NULL;
   va_list args;
@@ -159,7 +159,7 @@ xdg_app_fail (GError **error, const char *format, ...)
 }
 
 const char *
-xdg_app_get_kernel_arch (void)
+flatpak_get_kernel_arch (void)
 {
   static struct utsname buf;
   static char *arch = NULL;
@@ -219,7 +219,7 @@ xdg_app_get_kernel_arch (void)
  * at least try to execute a 386, wheras an arm binary would not.
  */
 const char *
-xdg_app_get_arch (void)
+flatpak_get_arch (void)
 {
   /* Avoid using uname on multiarch machines, because uname reports the kernels
    * arch, and that may be different from userspace. If e.g. the kernel is 64bit and
@@ -238,14 +238,14 @@ xdg_app_get_arch (void)
   return "armeb";
 #endif
 #else
-  return xdg_app_get_kernel_arch ();
+  return flatpak_get_kernel_arch ();
 #endif
 }
 
 const char *
-xdg_app_get_bwrap (void)
+flatpak_get_bwrap (void)
 {
-  const char *e = g_getenv ("XDG_APP_BWRAP");
+  const char *e = g_getenv ("FLATPAK_BWRAP");
 
   if (e != NULL)
     return e;
@@ -269,7 +269,7 @@ is_valid_name_character (gint c)
     (c >= '0' && c <= '9');
 }
 
-/** xdg_app_is_name:
+/** flatpak_is_name:
  * @string: The string to check
  *
  * Checks if @string is a valid application name.
@@ -294,7 +294,7 @@ is_valid_name_character (gint c)
  * Since: 2.26
  */
 gboolean
-xdg_app_is_valid_name (const char *string)
+flatpak_is_valid_name (const char *string)
 {
   guint len;
   gboolean ret;
@@ -347,7 +347,7 @@ out:
 }
 
 gboolean
-xdg_app_has_name_prefix (const char *string,
+flatpak_has_name_prefix (const char *string,
                          const char *name)
 {
   const char *rest;
@@ -382,7 +382,7 @@ is_valid_branch_character (gint c)
     (c == '.');
 }
 
-/** xdg_app_is_valid_branch:
+/** flatpak_is_valid_branch:
  * @string: The string to check
  *
  * Checks if @string is a valid branch name.
@@ -397,7 +397,7 @@ is_valid_branch_character (gint c)
  * Since: 2.26
  */
 gboolean
-xdg_app_is_valid_branch (const char *string)
+flatpak_is_valid_branch (const char *string)
 {
   guint len;
   gboolean ret;
@@ -433,7 +433,7 @@ out:
 }
 
 char **
-xdg_app_decompose_ref (const char *full_ref,
+flatpak_decompose_ref (const char *full_ref,
                        GError    **error)
 {
   g_auto(GStrv) parts = NULL;
@@ -441,31 +441,31 @@ xdg_app_decompose_ref (const char *full_ref,
   parts = g_strsplit (full_ref, "/", 0);
   if (g_strv_length (parts) != 4)
     {
-      xdg_app_fail (error, "Wrong number of components in %s", full_ref);
+      flatpak_fail (error, "Wrong number of components in %s", full_ref);
       return NULL;
     }
 
   if (strcmp (parts[0], "app") != 0 && strcmp (parts[0], "runtime") != 0)
     {
-      xdg_app_fail (error, "Not application or runtime");
+      flatpak_fail (error, "Not application or runtime");
       return NULL;
     }
 
-  if (!xdg_app_is_valid_name (parts[1]))
+  if (!flatpak_is_valid_name (parts[1]))
     {
-      xdg_app_fail (error, "Invalid name %s", parts[1]);
+      flatpak_fail (error, "Invalid name %s", parts[1]);
       return NULL;
     }
 
   if (strlen (parts[2]) == 0)
     {
-      xdg_app_fail (error, "Invalid arch %s", parts[2]);
+      flatpak_fail (error, "Invalid arch %s", parts[2]);
       return NULL;
     }
 
-  if (!xdg_app_is_valid_branch (parts[3]))
+  if (!flatpak_is_valid_branch (parts[3]))
     {
-      xdg_app_fail (error, "Invalid branch %s", parts[3]);
+      flatpak_fail (error, "Invalid branch %s", parts[3]);
       return NULL;
     }
 
@@ -473,43 +473,43 @@ xdg_app_decompose_ref (const char *full_ref,
 }
 
 char *
-xdg_app_compose_ref (gboolean    app,
+flatpak_compose_ref (gboolean    app,
                      const char *name,
                      const char *branch,
                      const char *arch,
                      GError    **error)
 {
-  if (!xdg_app_is_valid_name (name))
+  if (!flatpak_is_valid_name (name))
     {
-      xdg_app_fail (error, "'%s' is not a valid name", name);
+      flatpak_fail (error, "'%s' is not a valid name", name);
       return NULL;
     }
 
-  if (branch && !xdg_app_is_valid_branch (branch))
+  if (branch && !flatpak_is_valid_branch (branch))
     {
-      xdg_app_fail (error, "'%s' is not a valid branch name", branch);
+      flatpak_fail (error, "'%s' is not a valid branch name", branch);
       return NULL;
     }
 
   if (app)
-    return xdg_app_build_app_ref (name, branch, arch);
+    return flatpak_build_app_ref (name, branch, arch);
   else
-    return xdg_app_build_runtime_ref (name, branch, arch);
+    return flatpak_build_runtime_ref (name, branch, arch);
 }
 
 char *
-xdg_app_build_untyped_ref (const char *runtime,
+flatpak_build_untyped_ref (const char *runtime,
                            const char *branch,
                            const char *arch)
 {
   if (arch == NULL)
-    arch = xdg_app_get_arch ();
+    arch = flatpak_get_arch ();
 
   return g_build_filename (runtime, arch, branch, NULL);
 }
 
 char *
-xdg_app_build_runtime_ref (const char *runtime,
+flatpak_build_runtime_ref (const char *runtime,
                            const char *branch,
                            const char *arch)
 {
@@ -517,13 +517,13 @@ xdg_app_build_runtime_ref (const char *runtime,
     branch = "master";
 
   if (arch == NULL)
-    arch = xdg_app_get_arch ();
+    arch = flatpak_get_arch ();
 
   return g_build_filename ("runtime", runtime, arch, branch, NULL);
 }
 
 char *
-xdg_app_build_app_ref (const char *app,
+flatpak_build_app_ref (const char *app,
                        const char *branch,
                        const char *arch)
 {
@@ -531,13 +531,13 @@ xdg_app_build_app_ref (const char *app,
     branch = "master";
 
   if (arch == NULL)
-    arch = xdg_app_get_arch ();
+    arch = flatpak_get_arch ();
 
   return g_build_filename ("app", app, arch, branch, NULL);
 }
 
 char **
-xdg_app_list_deployed_refs (const char   *type,
+flatpak_list_deployed_refs (const char   *type,
                             const char   *name_prefix,
                             const char   *branch,
                             const char   *arch,
@@ -548,22 +548,22 @@ xdg_app_list_deployed_refs (const char   *type,
 
   g_autoptr(GPtrArray) names = NULL;
   g_autoptr(GHashTable) hash = NULL;
-  g_autoptr(XdgAppDir) user_dir = NULL;
-  g_autoptr(XdgAppDir) system_dir = NULL;
+  g_autoptr(FlatpakDir) user_dir = NULL;
+  g_autoptr(FlatpakDir) system_dir = NULL;
   const char *key;
   GHashTableIter iter;
 
   hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 
-  user_dir = xdg_app_dir_get_user ();
-  system_dir = xdg_app_dir_get_system ();
+  user_dir = flatpak_dir_get_user ();
+  system_dir = flatpak_dir_get_system ();
 
-  if (!xdg_app_dir_collect_deployed_refs (user_dir, type, name_prefix,
+  if (!flatpak_dir_collect_deployed_refs (user_dir, type, name_prefix,
                                           branch, arch, hash, cancellable,
                                           error))
     goto out;
 
-  if (!xdg_app_dir_collect_deployed_refs (system_dir, type, name_prefix,
+  if (!flatpak_dir_collect_deployed_refs (system_dir, type, name_prefix,
                                           branch, arch, hash, cancellable,
                                           error))
     goto out;
@@ -573,7 +573,7 @@ xdg_app_list_deployed_refs (const char   *type,
   while (g_hash_table_iter_next (&iter, (gpointer *) &key, NULL))
     g_ptr_array_add (names, g_strdup (key));
 
-  g_ptr_array_sort (names, xdg_app_strcmp0_ptr);
+  g_ptr_array_sort (names, flatpak_strcmp0_ptr);
   g_ptr_array_add (names, NULL);
 
   ret = (char **) g_ptr_array_free (names, FALSE);
@@ -584,20 +584,20 @@ out:
 }
 
 GFile *
-xdg_app_find_deploy_dir_for_ref (const char   *ref,
+flatpak_find_deploy_dir_for_ref (const char   *ref,
                                  GCancellable *cancellable,
                                  GError      **error)
 {
-  g_autoptr(XdgAppDir) user_dir = NULL;
-  g_autoptr(XdgAppDir) system_dir = NULL;
+  g_autoptr(FlatpakDir) user_dir = NULL;
+  g_autoptr(FlatpakDir) system_dir = NULL;
   GFile *deploy = NULL;
 
-  user_dir = xdg_app_dir_get_user ();
-  system_dir = xdg_app_dir_get_system ();
+  user_dir = flatpak_dir_get_user ();
+  system_dir = flatpak_dir_get_system ();
 
-  deploy = xdg_app_dir_get_if_deployed (user_dir, ref, NULL, cancellable);
+  deploy = flatpak_dir_get_if_deployed (user_dir, ref, NULL, cancellable);
   if (deploy == NULL)
-    deploy = xdg_app_dir_get_if_deployed (system_dir, ref, NULL, cancellable);
+    deploy = flatpak_dir_get_if_deployed (system_dir, ref, NULL, cancellable);
   if (deploy == NULL)
     {
       g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "%s not installed", ref);
@@ -608,24 +608,24 @@ xdg_app_find_deploy_dir_for_ref (const char   *ref,
 
 }
 
-XdgAppDeploy *
-xdg_app_find_deploy_for_ref (const char   *ref,
+FlatpakDeploy *
+flatpak_find_deploy_for_ref (const char   *ref,
                              GCancellable *cancellable,
                              GError      **error)
 {
-  g_autoptr(XdgAppDir) user_dir = NULL;
-  g_autoptr(XdgAppDir) system_dir = NULL;
-  g_autoptr(XdgAppDeploy) deploy = NULL;
+  g_autoptr(FlatpakDir) user_dir = NULL;
+  g_autoptr(FlatpakDir) system_dir = NULL;
+  g_autoptr(FlatpakDeploy) deploy = NULL;
   g_autoptr(GError) my_error = NULL;
 
-  user_dir = xdg_app_dir_get_user ();
-  system_dir = xdg_app_dir_get_system ();
+  user_dir = flatpak_dir_get_user ();
+  system_dir = flatpak_dir_get_system ();
 
-  deploy = xdg_app_dir_load_deployed (user_dir, ref, NULL, cancellable, &my_error);
-  if (deploy == NULL && g_error_matches (my_error, XDG_APP_DIR_ERROR, XDG_APP_DIR_ERROR_NOT_DEPLOYED))
+  deploy = flatpak_dir_load_deployed (user_dir, ref, NULL, cancellable, &my_error);
+  if (deploy == NULL && g_error_matches (my_error, FLATPAK_DIR_ERROR, FLATPAK_DIR_ERROR_NOT_DEPLOYED))
     {
       g_clear_error (&my_error);
-      deploy = xdg_app_dir_load_deployed (system_dir, ref, NULL, cancellable, &my_error);
+      deploy = flatpak_dir_load_deployed (system_dir, ref, NULL, cancellable, &my_error);
     }
   if (deploy == NULL)
     g_propagate_error (error, g_steal_pointer (&my_error));
@@ -711,7 +711,7 @@ out:
 }
 
 gboolean
-xdg_app_overlay_symlink_tree (GFile        *source,
+flatpak_overlay_symlink_tree (GFile        *source,
                               GFile        *destination,
                               const char   *symlink_prefix,
                               GCancellable *cancellable,
@@ -782,7 +782,7 @@ out:
 }
 
 gboolean
-xdg_app_remove_dangling_symlinks (GFile        *dir,
+flatpak_remove_dangling_symlinks (GFile        *dir,
                                   GCancellable *cancellable,
                                   GError      **error)
 {
@@ -802,7 +802,7 @@ out:
 /* Based on g_mkstemp from glib */
 
 gint
-xdg_app_mkstempat (int    dir_fd,
+flatpak_mkstempat (int    dir_fd,
                    gchar *tmpl,
                    int    flags,
                    int    mode)
@@ -864,17 +864,17 @@ xdg_app_mkstempat (int    dir_fd,
   return -1;
 }
 
-struct XdgAppTablePrinter
+struct FlatpakTablePrinter
 {
   GPtrArray *rows;
   GPtrArray *current;
   int        n_columns;
 };
 
-XdgAppTablePrinter *
-xdg_app_table_printer_new (void)
+FlatpakTablePrinter *
+flatpak_table_printer_new (void)
 {
-  XdgAppTablePrinter *printer = g_new0 (XdgAppTablePrinter, 1);
+  FlatpakTablePrinter *printer = g_new0 (FlatpakTablePrinter, 1);
 
   printer->rows = g_ptr_array_new_with_free_func ((GDestroyNotify) g_strfreev);
   printer->current = g_ptr_array_new_with_free_func (g_free);
@@ -883,7 +883,7 @@ xdg_app_table_printer_new (void)
 }
 
 void
-xdg_app_table_printer_free (XdgAppTablePrinter *printer)
+flatpak_table_printer_free (FlatpakTablePrinter *printer)
 {
   g_ptr_array_free (printer->rows, TRUE);
   g_ptr_array_free (printer->current, TRUE);
@@ -891,15 +891,15 @@ xdg_app_table_printer_free (XdgAppTablePrinter *printer)
 }
 
 void
-xdg_app_table_printer_add_column (XdgAppTablePrinter *printer,
-                                  const char         *text)
+flatpak_table_printer_add_column (FlatpakTablePrinter *printer,
+                                  const char          *text)
 {
   g_ptr_array_add (printer->current, text ? g_strdup (text) : g_strdup (""));
 }
 
 void
-xdg_app_table_printer_append_with_comma (XdgAppTablePrinter *printer,
-                                         const char         *text)
+flatpak_table_printer_append_with_comma (FlatpakTablePrinter *printer,
+                                         const char          *text)
 {
   char *old, *new;
 
@@ -918,7 +918,7 @@ xdg_app_table_printer_append_with_comma (XdgAppTablePrinter *printer,
 
 
 void
-xdg_app_table_printer_finish_row (XdgAppTablePrinter *printer)
+flatpak_table_printer_finish_row (FlatpakTablePrinter *printer)
 {
   if (printer->current->len == 0)
     return; /* Ignore empty rows */
@@ -931,13 +931,13 @@ xdg_app_table_printer_finish_row (XdgAppTablePrinter *printer)
 }
 
 void
-xdg_app_table_printer_print (XdgAppTablePrinter *printer)
+flatpak_table_printer_print (FlatpakTablePrinter *printer)
 {
   g_autofree int *widths = NULL;
   int i, j;
 
   if (printer->current->len != 0)
-    xdg_app_table_printer_finish_row (printer);
+    flatpak_table_printer_finish_row (printer);
 
   widths = g_new0 (int, printer->n_columns);
 
@@ -1049,7 +1049,7 @@ got_credentials_cb (GObject      *source_object,
       GTask *task = l->data;
 
       if (info->app_id == NULL)
-        g_task_return_new_error (task, XDG_APP_PORTAL_ERROR, XDG_APP_PORTAL_ERROR_FAILED,
+        g_task_return_new_error (task, FLATPAK_PORTAL_ERROR, FLATPAK_PORTAL_ERROR_FAILED,
                                  "Can't find app id");
       else
         g_task_return_pointer (task, g_strdup (info->app_id), g_free);
@@ -1063,7 +1063,7 @@ got_credentials_cb (GObject      *source_object,
 }
 
 void
-xdg_app_invocation_lookup_app_id (GDBusMethodInvocation *invocation,
+flatpak_invocation_lookup_app_id (GDBusMethodInvocation *invocation,
                                   GCancellable          *cancellable,
                                   GAsyncReadyCallback    callback,
                                   gpointer               user_data)
@@ -1115,7 +1115,7 @@ xdg_app_invocation_lookup_app_id (GDBusMethodInvocation *invocation,
 }
 
 char *
-xdg_app_invocation_lookup_app_id_finish (GDBusMethodInvocation *invocation,
+flatpak_invocation_lookup_app_id_finish (GDBusMethodInvocation *invocation,
                                          GAsyncResult          *result,
                                          GError               **error)
 {
@@ -1153,7 +1153,7 @@ name_owner_changed (GDBusConnection *connection,
 }
 
 void
-xdg_app_connection_track_name_owners (GDBusConnection *connection)
+flatpak_connection_track_name_owners (GDBusConnection *connection)
 {
   g_dbus_connection_signal_subscribe (connection,
                                       "org.freedesktop.DBus",
@@ -1205,7 +1205,7 @@ spawn_exit_cb (GObject      *obj,
 }
 
 gboolean
-xdg_app_spawn (GFile       *dir,
+flatpak_spawn (GFile       *dir,
                char       **output,
                GError     **error,
                const gchar *argv0,
@@ -1292,20 +1292,20 @@ xdg_app_spawn (GFile       *dir,
 
 
 gboolean
-xdg_app_cp_a (GFile        *src,
-              GFile        *dest,
-              XdgAppCpFlags flags,
-              GCancellable *cancellable,
-              GError      **error)
+flatpak_cp_a (GFile         *src,
+              GFile         *dest,
+              FlatpakCpFlags flags,
+              GCancellable  *cancellable,
+              GError       **error)
 {
   gboolean ret = FALSE;
   GFileEnumerator *enumerator = NULL;
   GFileInfo *src_info = NULL;
   GFile *dest_child = NULL;
   int dest_dfd = -1;
-  gboolean merge = (flags & XDG_APP_CP_FLAGS_MERGE) != 0;
-  gboolean no_chown = (flags & XDG_APP_CP_FLAGS_NO_CHOWN) != 0;
-  gboolean move = (flags & XDG_APP_CP_FLAGS_MOVE) != 0;
+  gboolean merge = (flags & FLATPAK_CP_FLAGS_MERGE) != 0;
+  gboolean no_chown = (flags & FLATPAK_CP_FLAGS_NO_CHOWN) != 0;
+  gboolean move = (flags & FLATPAK_CP_FLAGS_MOVE) != 0;
   int r;
 
   enumerator = g_file_enumerate_children (src, "standard::type,standard::name,unix::uid,unix::gid,unix::mode",
@@ -1377,7 +1377,7 @@ xdg_app_cp_a (GFile        *src,
 
       if (g_file_info_get_file_type (file_info) == G_FILE_TYPE_DIRECTORY)
         {
-          if (!xdg_app_cp_a (src_child, dest_child, flags,
+          if (!flatpak_cp_a (src_child, dest_child, flags,
                              cancellable, error))
             goto out;
         }
@@ -1417,7 +1417,7 @@ out:
 }
 
 gboolean
-xdg_app_variant_save (GFile        *dest,
+flatpak_variant_save (GFile        *dest,
                       GVariant     *variant,
                       GCancellable *cancellable,
                       GError      **error)
@@ -1447,7 +1447,7 @@ xdg_app_variant_save (GFile        *dest,
 
 
 gboolean
-xdg_app_variant_bsearch_str (GVariant   *array,
+flatpak_variant_bsearch_str (GVariant   *array,
                              const char *str,
                              int        *out_pos)
 {
@@ -1495,7 +1495,7 @@ xdg_app_variant_bsearch_str (GVariant   *array,
 }
 
 gboolean
-xdg_app_summary_lookup_ref (GVariant *summary, const char *ref, char **out_checksum)
+flatpak_summary_lookup_ref (GVariant *summary, const char *ref, char **out_checksum)
 {
   g_autoptr(GVariant) refs = g_variant_get_child_value (summary, 0);
   int pos;
@@ -1506,7 +1506,7 @@ xdg_app_summary_lookup_ref (GVariant *summary, const char *ref, char **out_check
   g_autoptr(GVariant) commit_csum_v = NULL;
   g_autoptr(GBytes) commit_bytes = NULL;
 
-  if (!xdg_app_variant_bsearch_str (refs, ref, &pos))
+  if (!flatpak_variant_bsearch_str (refs, ref, &pos))
     return FALSE;
 
   refdata = g_variant_get_child_value (refs, pos);
@@ -1523,7 +1523,7 @@ xdg_app_summary_lookup_ref (GVariant *summary, const char *ref, char **out_check
 }
 
 gboolean
-xdg_app_repo_set_title (OstreeRepo *repo,
+flatpak_repo_set_title (OstreeRepo *repo,
                         const char *title,
                         GError    **error)
 {
@@ -1546,7 +1546,7 @@ xdg_app_repo_set_title (OstreeRepo *repo,
                                    "unix::device,unix::inode,unix::mode,unix::uid,unix::gid,unix::rdev")
 
 static gboolean
-_xdg_app_repo_collect_sizes (OstreeRepo   *repo,
+_flatpak_repo_collect_sizes (OstreeRepo   *repo,
                              GFile        *file,
                              GFileInfo    *file_info,
                              guint64      *installed_size,
@@ -1593,7 +1593,7 @@ _xdg_app_repo_collect_sizes (OstreeRepo   *repo,
           const char *name = g_file_info_get_name (child_info);
           g_autoptr(GFile) child = g_file_get_child (file, name);
 
-          if (!_xdg_app_repo_collect_sizes (repo, child, child_info, installed_size, download_size, cancellable, error))
+          if (!_flatpak_repo_collect_sizes (repo, child, child_info, installed_size, download_size, cancellable, error))
             return FALSE;
         }
     }
@@ -1602,18 +1602,18 @@ _xdg_app_repo_collect_sizes (OstreeRepo   *repo,
 }
 
 gboolean
-xdg_app_repo_collect_sizes (OstreeRepo   *repo,
+flatpak_repo_collect_sizes (OstreeRepo   *repo,
                             GFile        *root,
                             guint64      *installed_size,
                             guint64      *download_size,
                             GCancellable *cancellable,
                             GError      **error)
 {
-  return _xdg_app_repo_collect_sizes (repo, root, NULL, installed_size, download_size, cancellable, error);
+  return _flatpak_repo_collect_sizes (repo, root, NULL, installed_size, download_size, cancellable, error);
 }
 
 gboolean
-xdg_app_repo_update (OstreeRepo   *repo,
+flatpak_repo_update (OstreeRepo   *repo,
                      const char  **gpg_key_ids,
                      const char   *gpg_homedir,
                      GCancellable *cancellable,
@@ -1660,7 +1660,7 @@ xdg_app_repo_update (OstreeRepo   *repo,
       if (!ostree_repo_read_commit (repo, ref, &root, NULL, NULL, error))
         return FALSE;
 
-      if (!xdg_app_repo_collect_sizes (repo, root, &installed_size, &download_size, cancellable, error))
+      if (!flatpak_repo_collect_sizes (repo, root, &installed_size, &download_size, cancellable, error))
         return FALSE;
 
       metadata = g_file_get_child (root, "metadata");
@@ -1695,7 +1695,7 @@ xdg_app_repo_update (OstreeRepo   *repo,
 }
 
 gboolean
-xdg_app_mtree_create_root (OstreeRepo        *repo,
+flatpak_mtree_create_root (OstreeRepo        *repo,
                            OstreeMutableTree *mtree,
                            GCancellable      *cancellable,
                            GError           **error)
@@ -1742,25 +1742,25 @@ commit_filter (OstreeRepo *repo,
 }
 
 static gboolean
-validate_component (XdgAppXml  *component,
+validate_component (FlatpakXml *component,
                     const char *ref,
                     const char *id,
                     char      **tags,
                     const char *runtime,
                     const char *sdk)
 {
-  XdgAppXml *bundle, *text, *prev, *id_node, *id_text_node, *metadata, *value;
+  FlatpakXml *bundle, *text, *prev, *id_node, *id_text_node, *metadata, *value;
   g_autofree char *id_text = NULL;
   int i;
 
   if (g_strcmp0 (component->element_name, "component") != 0)
     return FALSE;
 
-  id_node = xdg_app_xml_find (component, "id", NULL);
+  id_node = flatpak_xml_find (component, "id", NULL);
   if (id_node == NULL)
     return FALSE;
 
-  id_text_node = xdg_app_xml_find (id_node, NULL, NULL);
+  id_text_node = flatpak_xml_find (id_node, NULL, NULL);
   if (id_text_node == NULL || id_text_node->text == NULL)
     return FALSE;
 
@@ -1772,10 +1772,10 @@ validate_component (XdgAppXml  *component,
       return FALSE;
     }
 
-  while ((bundle = xdg_app_xml_find (component, "bundle", &prev)) != NULL)
-    xdg_app_xml_free (xdg_app_xml_unlink (component, bundle));
+  while ((bundle = flatpak_xml_find (component, "bundle", &prev)) != NULL)
+    flatpak_xml_free (flatpak_xml_unlink (component, bundle));
 
-  bundle = xdg_app_xml_new ("bundle");
+  bundle = flatpak_xml_new ("bundle");
   bundle->attribute_names = g_new0 (char *, 2 * 4);
   bundle->attribute_values = g_new0 (char *, 2 * 4);
   bundle->attribute_names[0] = g_strdup ("type");
@@ -1796,40 +1796,40 @@ validate_component (XdgAppXml  *component,
       i++;
     }
 
-  text = xdg_app_xml_new (NULL);
+  text = flatpak_xml_new (NULL);
   text->text = g_strdup (ref);
-  xdg_app_xml_add (bundle, text);
+  flatpak_xml_add (bundle, text);
 
-  xdg_app_xml_add (component, xdg_app_xml_new_text ("  "));
-  xdg_app_xml_add (component, bundle);
-  xdg_app_xml_add (component, xdg_app_xml_new_text ("\n  "));
+  flatpak_xml_add (component, flatpak_xml_new_text ("  "));
+  flatpak_xml_add (component, bundle);
+  flatpak_xml_add (component, flatpak_xml_new_text ("\n  "));
 
   if (tags != NULL && tags[0] != NULL)
     {
-      metadata = xdg_app_xml_find (component, "metadata", NULL);
+      metadata = flatpak_xml_find (component, "metadata", NULL);
       if (metadata == NULL)
         {
-          metadata = xdg_app_xml_new ("metadata");
+          metadata = flatpak_xml_new ("metadata");
           metadata->attribute_names = g_new0 (char *, 1);
           metadata->attribute_values = g_new0 (char *, 1);
 
-          xdg_app_xml_add (component, xdg_app_xml_new_text ("  "));
-          xdg_app_xml_add (component, metadata);
-          xdg_app_xml_add (component, xdg_app_xml_new_text ("\n  "));
+          flatpak_xml_add (component, flatpak_xml_new_text ("  "));
+          flatpak_xml_add (component, metadata);
+          flatpak_xml_add (component, flatpak_xml_new_text ("\n  "));
         }
 
-      value = xdg_app_xml_new ("value");
+      value = flatpak_xml_new ("value");
       value->attribute_names = g_new0 (char *, 2);
       value->attribute_values = g_new0 (char *, 2);
       value->attribute_names[0] = g_strdup ("key");
-      value->attribute_values[0] = g_strdup ("X-XdgApp-Tags");
-      xdg_app_xml_add (metadata, xdg_app_xml_new_text ("\n       "));
-      xdg_app_xml_add (metadata, value);
-      xdg_app_xml_add (metadata, xdg_app_xml_new_text ("\n    "));
+      value->attribute_values[0] = g_strdup ("X-Flatpak-Tags");
+      flatpak_xml_add (metadata, flatpak_xml_new_text ("\n       "));
+      flatpak_xml_add (metadata, value);
+      flatpak_xml_add (metadata, flatpak_xml_new_text ("\n    "));
 
-      text = xdg_app_xml_new (NULL);
+      text = flatpak_xml_new (NULL);
       text->text = g_strjoinv (",", tags);
-      xdg_app_xml_add (value, text);
+      flatpak_xml_add (value, text);
 
     }
 
@@ -1837,16 +1837,16 @@ validate_component (XdgAppXml  *component,
 }
 
 gboolean
-xdg_app_appstream_xml_migrate (XdgAppXml  *source,
-                               XdgAppXml  *dest,
+flatpak_appstream_xml_migrate (FlatpakXml *source,
+                               FlatpakXml *dest,
                                const char *ref,
                                const char *id,
                                GKeyFile   *metadata)
 {
-  XdgAppXml *source_components;
-  XdgAppXml *dest_components;
-  XdgAppXml *component;
-  XdgAppXml *prev_component;
+  FlatpakXml *source_components;
+  FlatpakXml *dest_components;
+  FlatpakXml *component;
+  FlatpakXml *prev_component;
   gboolean migrated = FALSE;
 
   g_auto(GStrv) tags = NULL;
@@ -1875,12 +1875,12 @@ xdg_app_appstream_xml_migrate (XdgAppXml  *source,
   prev_component = NULL;
   while (component != NULL)
     {
-      XdgAppXml *next = component->next_sibling;
+      FlatpakXml *next = component->next_sibling;
 
       if (validate_component (component, ref, id, tags, runtime, sdk))
         {
-          xdg_app_xml_add (dest_components,
-                           xdg_app_xml_unlink (component, prev_component));
+          flatpak_xml_add (dest_components,
+                           flatpak_xml_unlink (component, prev_component));
           migrated = TRUE;
         }
       else
@@ -1939,7 +1939,7 @@ copy_icon (const char *id,
 
 static gboolean
 extract_appstream (OstreeRepo   *repo,
-                   XdgAppXml    *appstream_root,
+                   FlatpakXml   *appstream_root,
                    const char   *ref,
                    const char   *id,
                    GFile        *dest,
@@ -1952,7 +1952,7 @@ extract_appstream (OstreeRepo   *repo,
   g_autoptr(GFile) metadata = NULL;
   g_autofree char *appstream_basename = NULL;
   g_autoptr(GInputStream) in = NULL;
-  g_autoptr(XdgAppXml) xml_root = NULL;
+  g_autoptr(FlatpakXml) xml_root = NULL;
   g_autoptr(GKeyFile) keyfile = NULL;
 
   if (!ostree_repo_read_commit (repo, ref, &root, NULL, NULL, error))
@@ -1980,20 +1980,20 @@ extract_appstream (OstreeRepo   *repo,
   if (!in)
     return FALSE;
 
-  xml_root = xdg_app_xml_parse (in, TRUE, cancellable, error);
+  xml_root = flatpak_xml_parse (in, TRUE, cancellable, error);
   if (xml_root == NULL)
     return FALSE;
 
-  if (xdg_app_appstream_xml_migrate (xml_root, appstream_root,
+  if (flatpak_appstream_xml_migrate (xml_root, appstream_root,
                                      ref, id, keyfile))
     {
       g_autoptr(GError) my_error = NULL;
-      XdgAppXml *components = appstream_root->first_child;
-      XdgAppXml *component = components->first_child;
+      FlatpakXml *components = appstream_root->first_child;
+      FlatpakXml *component = components->first_child;
 
       while (component != NULL)
         {
-          XdgAppXml *component_id, *component_id_text_node;
+          FlatpakXml *component_id, *component_id_text_node;
           g_autofree char *component_id_text = NULL;
 
           if (g_strcmp0 (component->element_name, "component") != 0)
@@ -2002,8 +2002,8 @@ extract_appstream (OstreeRepo   *repo,
               continue;
             }
 
-          component_id = xdg_app_xml_find (component, "id", NULL);
-          component_id_text_node = xdg_app_xml_find (component_id, NULL, NULL);
+          component_id = flatpak_xml_find (component, "id", NULL);
+          component_id_text_node = flatpak_xml_find (component_id, NULL, NULL);
 
           component_id_text = g_strstrip (g_strdup (component_id_text_node->text));
           if (!g_str_has_suffix (component_id_text, ".desktop"))
@@ -2033,16 +2033,16 @@ extract_appstream (OstreeRepo   *repo,
   return TRUE;
 }
 
-XdgAppXml *
-xdg_app_appstream_xml_new (void)
+FlatpakXml *
+flatpak_appstream_xml_new (void)
 {
-  XdgAppXml *appstream_root = NULL;
-  XdgAppXml *appstream_components;
+  FlatpakXml *appstream_root = NULL;
+  FlatpakXml *appstream_components;
 
-  appstream_root = xdg_app_xml_new ("root");
-  appstream_components = xdg_app_xml_new ("components");
-  xdg_app_xml_add (appstream_root, appstream_components);
-  xdg_app_xml_add (appstream_components, xdg_app_xml_new_text ("\n  "));
+  appstream_root = flatpak_xml_new ("root");
+  appstream_components = flatpak_xml_new ("components");
+  flatpak_xml_add (appstream_root, appstream_components);
+  flatpak_xml_add (appstream_components, flatpak_xml_new_text ("\n  "));
 
   appstream_components->attribute_names = g_new0 (char *, 3);
   appstream_components->attribute_values = g_new0 (char *, 3);
@@ -2055,18 +2055,18 @@ xdg_app_appstream_xml_new (void)
 }
 
 GBytes *
-xdg_app_appstream_xml_root_to_data (XdgAppXml *appstream_root,
-                                    GError   **error)
+flatpak_appstream_xml_root_to_data (FlatpakXml *appstream_root,
+                                    GError    **error)
 {
   g_autoptr(GString) xml = NULL;
   g_autoptr(GZlibCompressor) compressor = NULL;
   g_autoptr(GOutputStream) out2 = NULL;
   g_autoptr(GOutputStream) out = NULL;
 
-  xdg_app_xml_add (appstream_root->first_child, xdg_app_xml_new_text ("\n"));
+  flatpak_xml_add (appstream_root->first_child, flatpak_xml_new_text ("\n"));
 
   xml = g_string_new ("");
-  xdg_app_xml_to_string (appstream_root, xml);
+  flatpak_xml_to_string (appstream_root, xml);
 
   compressor = g_zlib_compressor_new (G_ZLIB_COMPRESSOR_FORMAT_GZIP, -1);
   out = g_memory_output_stream_new_resizable ();
@@ -2081,7 +2081,7 @@ xdg_app_appstream_xml_root_to_data (XdgAppXml *appstream_root,
 }
 
 gboolean
-xdg_app_repo_generate_appstream (OstreeRepo   *repo,
+flatpak_repo_generate_appstream (OstreeRepo   *repo,
                                  const char  **gpg_key_ids,
                                  const char   *gpg_homedir,
                                  GCancellable *cancellable,
@@ -2110,7 +2110,7 @@ xdg_app_repo_generate_appstream (OstreeRepo   *repo,
       const char *arch;
       g_auto(GStrv) split = NULL;
 
-      split = xdg_app_decompose_ref (ref, NULL);
+      split = flatpak_decompose_ref (ref, NULL);
       if (!split)
         continue;
 
@@ -2125,7 +2125,7 @@ xdg_app_repo_generate_appstream (OstreeRepo   *repo,
       GHashTableIter iter2;
       const char *arch = key;
       g_autofree char *tmpdir = g_strdup ("/tmp/xdg-app-appstream-XXXXXX");
-      g_autoptr(XdgAppTempDir) tmpdir_file = NULL;
+      g_autoptr(FlatpakTempDir) tmpdir_file = NULL;
       g_autoptr(GFile) appstream_file = NULL;
       g_autoptr(GFile) root = NULL;
       g_autoptr(OstreeMutableTree) mtree = NULL;
@@ -2134,15 +2134,15 @@ xdg_app_repo_generate_appstream (OstreeRepo   *repo,
       g_autoptr(OstreeRepoCommitModifier) modifier = NULL;
       g_autofree char *parent = NULL;
       g_autofree char *branch = NULL;
-      g_autoptr(XdgAppXml) appstream_root = NULL;
+      g_autoptr(FlatpakXml) appstream_root = NULL;
       g_autoptr(GBytes) xml_data = NULL;
 
       if (g_mkdtemp (tmpdir) == NULL)
-        return xdg_app_fail (error, "Can't create temporary directory");
+        return flatpak_fail (error, "Can't create temporary directory");
 
       tmpdir_file = g_file_new_for_path (tmpdir);
 
-      appstream_root = xdg_app_appstream_xml_new ();
+      appstream_root = flatpak_appstream_xml_new ();
 
       g_hash_table_iter_init (&iter2, all_refs);
       while (g_hash_table_iter_next (&iter2, &key, &value))
@@ -2151,7 +2151,7 @@ xdg_app_repo_generate_appstream (OstreeRepo   *repo,
           g_auto(GStrv) split = NULL;
           g_autoptr(GError) my_error = NULL;
 
-          split = xdg_app_decompose_ref (ref, NULL);
+          split = flatpak_decompose_ref (ref, NULL);
           if (!split)
             continue;
 
@@ -2167,7 +2167,7 @@ xdg_app_repo_generate_appstream (OstreeRepo   *repo,
             }
         }
 
-      xml_data = xdg_app_appstream_xml_root_to_data (appstream_root, error);
+      xml_data = flatpak_appstream_xml_root_to_data (appstream_root, error);
       if (xml_data == NULL)
         return FALSE;
 
@@ -2260,7 +2260,7 @@ out:
 }
 
 void
-xdg_app_extension_free (XdgAppExtension *extension)
+flatpak_extension_free (FlatpakExtension *extension)
 {
   g_free (extension->id);
   g_free (extension->installed_id);
@@ -2269,14 +2269,14 @@ xdg_app_extension_free (XdgAppExtension *extension)
   g_free (extension);
 }
 
-static XdgAppExtension *
-xdg_app_extension_new (const char *id,
+static FlatpakExtension *
+flatpak_extension_new (const char *id,
                        const char *extension,
                        const char *arch,
                        const char *branch,
                        const char *directory)
 {
-  XdgAppExtension *ext = g_new0 (XdgAppExtension, 1);
+  FlatpakExtension *ext = g_new0 (FlatpakExtension, 1);
 
   ext->id = g_strdup (id);
   ext->installed_id = g_strdup (extension);
@@ -2286,7 +2286,7 @@ xdg_app_extension_new (const char *id,
 }
 
 GList *
-xdg_app_list_extensions (GKeyFile   *metakey,
+flatpak_list_extensions (GKeyFile   *metakey,
                          const char *arch,
                          const char *default_branch)
 {
@@ -2297,12 +2297,12 @@ xdg_app_list_extensions (GKeyFile   *metakey,
   res = NULL;
 
   if (arch == NULL)
-    arch = xdg_app_get_arch ();
+    arch = flatpak_get_arch ();
 
   groups = g_key_file_get_groups (metakey, NULL);
   for (i = 0; groups[i] != NULL; i++)
     {
-      XdgAppExtension *ext;
+      FlatpakExtension *ext;
       char *extension;
 
       if (g_str_has_prefix (groups[i], "Extension ") &&
@@ -2324,11 +2324,11 @@ xdg_app_list_extensions (GKeyFile   *metakey,
 
           ref = g_build_filename ("runtime", extension, arch, branch, NULL);
 
-          deploy = xdg_app_find_deploy_dir_for_ref (ref, NULL, NULL);
+          deploy = flatpak_find_deploy_dir_for_ref (ref, NULL, NULL);
           /* Prefer a full extension (org.freedesktop.Locale) over subdirectory ones (org.freedesktop.Locale.sv) */
           if (deploy != NULL)
             {
-              ext = xdg_app_extension_new (extension, extension, arch, branch, directory);
+              ext = flatpak_extension_new (extension, extension, arch, branch, directory);
               res = g_list_prepend (res, ext);
             }
           else if (g_key_file_get_boolean (metakey, groups[i],
@@ -2338,13 +2338,13 @@ xdg_app_list_extensions (GKeyFile   *metakey,
               g_auto(GStrv) refs = NULL;
               int j;
 
-              refs = xdg_app_list_deployed_refs ("runtime", prefix, arch, branch,
+              refs = flatpak_list_deployed_refs ("runtime", prefix, arch, branch,
                                                  NULL, NULL);
               for (j = 0; refs != NULL && refs[j] != NULL; j++)
                 {
                   g_autofree char *extended_dir = g_build_filename (directory, refs[j] + strlen (prefix), NULL);
 
-                  ext = xdg_app_extension_new (extension, refs[j], arch, branch, extended_dir);
+                  ext = flatpak_extension_new (extension, refs[j], arch, branch, extended_dir);
                   res = g_list_prepend (res, ext);
                 }
             }
@@ -2357,29 +2357,29 @@ xdg_app_list_extensions (GKeyFile   *metakey,
 
 typedef struct
 {
-  XdgAppXml *current;
+  FlatpakXml *current;
 } XmlData;
 
-XdgAppXml *
-xdg_app_xml_new (const gchar *element_name)
+FlatpakXml *
+flatpak_xml_new (const gchar *element_name)
 {
-  XdgAppXml *node = g_new0 (XdgAppXml, 1);
+  FlatpakXml *node = g_new0 (FlatpakXml, 1);
 
   node->element_name = g_strdup (element_name);
   return node;
 }
 
-XdgAppXml *
-xdg_app_xml_new_text (const gchar *text)
+FlatpakXml *
+flatpak_xml_new_text (const gchar *text)
 {
-  XdgAppXml *node = g_new0 (XdgAppXml, 1);
+  FlatpakXml *node = g_new0 (FlatpakXml, 1);
 
   node->text = g_strdup (text);
   return node;
 }
 
 void
-xdg_app_xml_add (XdgAppXml *parent, XdgAppXml *node)
+flatpak_xml_add (FlatpakXml *parent, FlatpakXml *node)
 {
   node->parent = parent;
 
@@ -2399,13 +2399,13 @@ xml_start_element (GMarkupParseContext *context,
                    GError             **error)
 {
   XmlData *data = user_data;
-  XdgAppXml *node;
+  FlatpakXml *node;
 
-  node = xdg_app_xml_new (element_name);
+  node = flatpak_xml_new (element_name);
   node->attribute_names = g_strdupv ((char **) attribute_names);
   node->attribute_values = g_strdupv ((char **) attribute_values);
 
-  xdg_app_xml_add (data->current, node);
+  flatpak_xml_add (data->current, node);
   data->current = node;
 }
 
@@ -2428,11 +2428,11 @@ xml_text (GMarkupParseContext *context,
           GError             **error)
 {
   XmlData *data = user_data;
-  XdgAppXml *node;
+  FlatpakXml *node;
 
-  node = xdg_app_xml_new (NULL);
+  node = flatpak_xml_new (NULL);
   node->text = g_strndup (text, text_len);
-  xdg_app_xml_add (data->current, node);
+  flatpak_xml_add (data->current, node);
 }
 
 static void
@@ -2453,9 +2453,9 @@ static GMarkupParser xml_parser = {
 };
 
 void
-xdg_app_xml_free (XdgAppXml *node)
+flatpak_xml_free (FlatpakXml *node)
 {
-  XdgAppXml *child;
+  FlatpakXml *child;
 
   if (node == NULL)
     return;
@@ -2463,8 +2463,8 @@ xdg_app_xml_free (XdgAppXml *node)
   child = node->first_child;
   while (child != NULL)
     {
-      XdgAppXml *next = child->next_sibling;
-      xdg_app_xml_free (child);
+      FlatpakXml *next = child->next_sibling;
+      flatpak_xml_free (child);
       child = next;
     }
 
@@ -2477,10 +2477,10 @@ xdg_app_xml_free (XdgAppXml *node)
 
 
 void
-xdg_app_xml_to_string (XdgAppXml *node, GString *res)
+flatpak_xml_to_string (FlatpakXml *node, GString *res)
 {
   int i;
-  XdgAppXml *child;
+  FlatpakXml *child;
 
   if (node->parent == NULL)
     g_string_append (res, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
@@ -2509,7 +2509,7 @@ xdg_app_xml_to_string (XdgAppXml *node, GString *res)
       child = node->first_child;
       while (child != NULL)
         {
-          xdg_app_xml_to_string (child, res);
+          flatpak_xml_to_string (child, res);
           child = child->next_sibling;
         }
       if (node->parent != NULL)
@@ -2526,11 +2526,11 @@ xdg_app_xml_to_string (XdgAppXml *node, GString *res)
     }
 }
 
-XdgAppXml *
-xdg_app_xml_unlink (XdgAppXml *node,
-                    XdgAppXml *prev_sibling)
+FlatpakXml *
+flatpak_xml_unlink (FlatpakXml *node,
+                    FlatpakXml *prev_sibling)
 {
-  XdgAppXml *parent = node->parent;
+  FlatpakXml *parent = node->parent;
 
   if (parent == NULL)
     return node;
@@ -2550,19 +2550,19 @@ xdg_app_xml_unlink (XdgAppXml *node,
   return node;
 }
 
-XdgAppXml *
-xdg_app_xml_find (XdgAppXml  *node,
-                  const char *type,
-                  XdgAppXml **prev_child_out)
+FlatpakXml *
+flatpak_xml_find (FlatpakXml  *node,
+                  const char  *type,
+                  FlatpakXml **prev_child_out)
 {
-  XdgAppXml *child = NULL;
-  XdgAppXml *prev_child = NULL;
+  FlatpakXml *child = NULL;
+  FlatpakXml *prev_child = NULL;
 
   child = node->first_child;
   prev_child = NULL;
   while (child != NULL)
     {
-      XdgAppXml *next = child->next_sibling;
+      FlatpakXml *next = child->next_sibling;
 
       if (g_strcmp0 (child->element_name, type) == 0)
         {
@@ -2579,14 +2579,14 @@ xdg_app_xml_find (XdgAppXml  *node,
 }
 
 
-XdgAppXml *
-xdg_app_xml_parse (GInputStream *in,
+FlatpakXml *
+flatpak_xml_parse (GInputStream *in,
                    gboolean      compressed,
                    GCancellable *cancellable,
                    GError      **error)
 {
   g_autoptr(GInputStream) real_in = NULL;
-  g_autoptr(XdgAppXml) xml_root = NULL;
+  g_autoptr(FlatpakXml) xml_root = NULL;
   XmlData data = { 0 };
   char buffer[32 * 1024];
   gssize len;
@@ -2603,7 +2603,7 @@ xdg_app_xml_parse (GInputStream *in,
       real_in = g_object_ref (in);
     }
 
-  xml_root = xdg_app_xml_new ("root");
+  xml_root = flatpak_xml_new ("root");
   data.current = xml_root;
 
   ctx = g_markup_parse_context_new (&xml_parser,
@@ -2638,7 +2638,7 @@ maybe_swap_endian_u64 (gboolean swap,
 }
 
 static guint64
-xdg_app_bundle_get_installed_size (GVariant *bundle, gboolean byte_swap)
+flatpak_bundle_get_installed_size (GVariant *bundle, gboolean byte_swap)
 {
   guint64 total_size = 0, total_usize = 0;
 
@@ -2666,7 +2666,7 @@ xdg_app_bundle_get_installed_size (GVariant *bundle, gboolean byte_swap)
 }
 
 GVariant *
-xdg_app_bundle_load (GFile   *file,
+flatpak_bundle_load (GFile   *file,
                      char   **commit,
                      char   **ref,
                      char   **origin,
@@ -2700,7 +2700,7 @@ xdg_app_bundle_load (GFile   *file,
     *commit = ostree_checksum_from_bytes_v (to_csum_v);
 
   if (installed_size)
-    *installed_size = xdg_app_bundle_get_installed_size (delta, byte_swap);
+    *installed_size = flatpak_bundle_get_installed_size (delta, byte_swap);
 
   metadata = g_variant_get_child_value (delta, 0);
 
@@ -2728,7 +2728,7 @@ xdg_app_bundle_load (GFile   *file,
     {
       if (!g_variant_lookup (metadata, "ref", "s", ref))
         {
-          xdg_app_fail (error, "Invalid bundle, no ref in metadata");
+          flatpak_fail (error, "Invalid bundle, no ref in metadata");
           return NULL;
         }
     }
@@ -2763,7 +2763,7 @@ xdg_app_bundle_load (GFile   *file,
 }
 
 gboolean
-xdg_app_pull_from_bundle (OstreeRepo   *repo,
+flatpak_pull_from_bundle (OstreeRepo   *repo,
                           GFile        *file,
                           const char   *remote,
                           const char   *ref,
@@ -2782,7 +2782,7 @@ xdg_app_pull_from_bundle (OstreeRepo   *repo,
   g_autoptr(GVariant) metadata = NULL;
   gboolean metadata_valid;
 
-  metadata = xdg_app_bundle_load (file, &to_checksum, NULL, NULL, NULL, NULL, error);
+  metadata = flatpak_bundle_load (file, &to_checksum, NULL, NULL, NULL, NULL, error);
   if (metadata == NULL)
     return FALSE;
 
@@ -2824,7 +2824,7 @@ xdg_app_pull_from_bundle (OstreeRepo   *repo,
          trust the source bundle. */
       if (ostree_gpg_verify_result_count_valid (gpg_result) == 0  &&
           require_gpg_signature)
-        return xdg_app_fail (error, "GPG signatures found, but none are in trusted keyring");
+        return flatpak_fail (error, "GPG signatures found, but none are in trusted keyring");
     }
 
   if (!ostree_repo_read_commit (repo, to_checksum, &root, NULL, NULL, error))
@@ -2863,7 +2863,7 @@ xdg_app_pull_from_bundle (OstreeRepo   *repo,
     {
       /* Immediately remove this broken commit */
       ostree_repo_set_ref_immediate (repo, remote, ref, NULL, cancellable, error);
-      return xdg_app_fail (error, "Metadata in header and app are inconsistent");
+      return flatpak_fail (error, "Metadata in header and app are inconsistent");
     }
 
   return TRUE;
@@ -2872,7 +2872,7 @@ xdg_app_pull_from_bundle (OstreeRepo   *repo,
 /* This allocates and locks a subdir of the tmp dir, using an existing
  * one with the same prefix if it is not in use already. */
 gboolean
-xdg_app_allocate_tmpdir (int           tmpdir_dfd,
+flatpak_allocate_tmpdir (int           tmpdir_dfd,
                          const char   *tmpdir_relpath,
                          const char   *tmpdir_prefix,
                          char        **tmpdir_name_out,
diff --git a/common/xdg-app-utils.h b/common/xdg-app-utils.h
index e342145..a2f7e45 100644
--- a/common/xdg-app-utils.h
+++ b/common/xdg-app-utils.h
@@ -18,8 +18,8 @@
  *       Alexander Larsson <alexl@redhat.com>
  */
 
-#ifndef __XDG_APP_UTILS_H__
-#define __XDG_APP_UTILS_H__
+#ifndef __FLATPAK_UTILS_H__
+#define __FLATPAK_UTILS_H__
 
 #include <string.h>
 
@@ -31,90 +31,90 @@
 #include "xdg-app-dir.h"
 #include <ostree.h>
 
-gboolean xdg_app_fail (GError    **error,
+gboolean flatpak_fail (GError    **error,
                        const char *format,
                        ...);
 
-gint xdg_app_strcmp0_ptr (gconstpointer a,
+gint flatpak_strcmp0_ptr (gconstpointer a,
                           gconstpointer b);
 
-const char * xdg_app_path_match_prefix (const char *pattern,
+const char * flatpak_path_match_prefix (const char *pattern,
                                         const char *path);
 
-const char * xdg_app_get_arch (void);
+const char * flatpak_get_arch (void);
 
-const char * xdg_app_get_bwrap (void);
+const char * flatpak_get_bwrap (void);
 
-GBytes * xdg_app_read_stream (GInputStream *in,
+GBytes * flatpak_read_stream (GInputStream *in,
                               gboolean      null_terminate,
                               GError      **error);
 
-gboolean xdg_app_variant_save (GFile        *dest,
+gboolean flatpak_variant_save (GFile        *dest,
                                GVariant     *variant,
                                GCancellable *cancellable,
                                GError      **error);
-gboolean xdg_app_variant_bsearch_str (GVariant   *array,
+gboolean flatpak_variant_bsearch_str (GVariant   *array,
                                       const char *str,
                                       int        *out_pos);
-gboolean xdg_app_summary_lookup_ref (GVariant   *summary,
+gboolean flatpak_summary_lookup_ref (GVariant   *summary,
                                      const char *ref,
                                      char      **out_checksum);
 
-gboolean xdg_app_has_name_prefix (const char *string,
+gboolean flatpak_has_name_prefix (const char *string,
                                   const char *name);
-gboolean xdg_app_is_valid_name (const char *string);
-gboolean xdg_app_is_valid_branch (const char *string);
+gboolean flatpak_is_valid_name (const char *string);
+gboolean flatpak_is_valid_branch (const char *string);
 
-char **xdg_app_decompose_ref (const char *ref,
+char **flatpak_decompose_ref (const char *ref,
                               GError    **error);
 
-char * xdg_app_compose_ref (gboolean    app,
+char * flatpak_compose_ref (gboolean    app,
                             const char *name,
                             const char *branch,
                             const char *arch,
                             GError    **error);
 
-char * xdg_app_build_untyped_ref (const char *runtime,
+char * flatpak_build_untyped_ref (const char *runtime,
                                   const char *branch,
                                   const char *arch);
-char * xdg_app_build_runtime_ref (const char *runtime,
+char * flatpak_build_runtime_ref (const char *runtime,
                                   const char *branch,
                                   const char *arch);
-char * xdg_app_build_app_ref (const char *app,
+char * flatpak_build_app_ref (const char *app,
                               const char *branch,
                               const char *arch);
-GFile * xdg_app_find_deploy_dir_for_ref (const char   *ref,
+GFile * flatpak_find_deploy_dir_for_ref (const char   *ref,
                                          GCancellable *cancellable,
                                          GError      **error);
-XdgAppDeploy * xdg_app_find_deploy_for_ref (const char   *ref,
-                                            GCancellable *cancellable,
-                                            GError      **error);
-char ** xdg_app_list_deployed_refs (const char   *type,
+FlatpakDeploy * flatpak_find_deploy_for_ref (const char   *ref,
+                                             GCancellable *cancellable,
+                                             GError      **error);
+char ** flatpak_list_deployed_refs (const char   *type,
                                     const char   *name_prefix,
                                     const char   *branch,
                                     const char   *arch,
                                     GCancellable *cancellable,
                                     GError      **error);
 
-gboolean xdg_app_overlay_symlink_tree (GFile        *source,
+gboolean flatpak_overlay_symlink_tree (GFile        *source,
                                        GFile        *destination,
                                        const char   *symlink_prefix,
                                        GCancellable *cancellable,
                                        GError      **error);
-gboolean xdg_app_remove_dangling_symlinks (GFile        *dir,
+gboolean flatpak_remove_dangling_symlinks (GFile        *dir,
                                            GCancellable *cancellable,
                                            GError      **error);
 
-void  xdg_app_invocation_lookup_app_id (GDBusMethodInvocation *invocation,
+void  flatpak_invocation_lookup_app_id (GDBusMethodInvocation *invocation,
                                         GCancellable          *cancellable,
                                         GAsyncReadyCallback    callback,
                                         gpointer               user_data);
 
-char *xdg_app_invocation_lookup_app_id_finish (GDBusMethodInvocation *invocation,
+char *flatpak_invocation_lookup_app_id_finish (GDBusMethodInvocation *invocation,
                                                GAsyncResult          *result,
                                                GError               **error);
 
-void  xdg_app_connection_track_name_owners (GDBusConnection *connection);
+void  flatpak_connection_track_name_owners (GDBusConnection *connection);
 
 #if !GLIB_CHECK_VERSION (2, 40, 0)
 static inline gboolean
@@ -154,58 +154,58 @@ g_strv_subset (const gchar * const *strv,
 }
 
 static inline void
-xdg_app_auto_unlock_helper (GMutex **mutex)
+flatpak_auto_unlock_helper (GMutex **mutex)
 {
   if (*mutex)
     g_mutex_unlock (*mutex);
 }
 
 static inline GMutex *
-xdg_app_auto_lock_helper (GMutex *mutex)
+flatpak_auto_lock_helper (GMutex *mutex)
 {
   if (mutex)
     g_mutex_lock (mutex);
   return mutex;
 }
 
-gint xdg_app_mkstempat (int    dir_fd,
+gint flatpak_mkstempat (int    dir_fd,
                         gchar *tmpl,
                         int    flags,
                         int    mode);
 
 
-typedef struct XdgAppTablePrinter XdgAppTablePrinter;
+typedef struct FlatpakTablePrinter FlatpakTablePrinter;
 
-XdgAppTablePrinter *xdg_app_table_printer_new (void);
-void                xdg_app_table_printer_free (XdgAppTablePrinter *printer);
-void                xdg_app_table_printer_add_column (XdgAppTablePrinter *printer,
-                                                      const char         *text);
-void                xdg_app_table_printer_append_with_comma (XdgAppTablePrinter *printer,
-                                                             const char         *text);
-void                xdg_app_table_printer_finish_row (XdgAppTablePrinter *printer);
-void                xdg_app_table_printer_print (XdgAppTablePrinter *printer);
+FlatpakTablePrinter *flatpak_table_printer_new (void);
+void                flatpak_table_printer_free (FlatpakTablePrinter *printer);
+void                flatpak_table_printer_add_column (FlatpakTablePrinter *printer,
+                                                      const char          *text);
+void                flatpak_table_printer_append_with_comma (FlatpakTablePrinter *printer,
+                                                             const char          *text);
+void                flatpak_table_printer_finish_row (FlatpakTablePrinter *printer);
+void                flatpak_table_printer_print (FlatpakTablePrinter *printer);
 
-gboolean xdg_app_repo_set_title (OstreeRepo *repo,
+gboolean flatpak_repo_set_title (OstreeRepo *repo,
                                  const char *title,
                                  GError    **error);
-gboolean xdg_app_repo_update (OstreeRepo   *repo,
+gboolean flatpak_repo_update (OstreeRepo   *repo,
                               const char  **gpg_key_ids,
                               const char   *gpg_homedir,
                               GCancellable *cancellable,
                               GError      **error);
-gboolean xdg_app_repo_collect_sizes (OstreeRepo   *repo,
+gboolean flatpak_repo_collect_sizes (OstreeRepo   *repo,
                                      GFile        *root,
                                      guint64      *installed_size,
                                      guint64      *download_size,
                                      GCancellable *cancellable,
                                      GError      **error);
 
-gboolean xdg_app_mtree_create_root (OstreeRepo        *repo,
+gboolean flatpak_mtree_create_root (OstreeRepo        *repo,
                                     OstreeMutableTree *mtree,
                                     GCancellable      *cancellable,
                                     GError           **error);
 
-GVariant * xdg_app_bundle_load (GFile   *file,
+GVariant * flatpak_bundle_load (GFile   *file,
                                 char   **commit,
                                 char   **ref,
                                 char   **origin,
@@ -213,7 +213,7 @@ GVariant * xdg_app_bundle_load (GFile   *file,
                                 GBytes **gpg_keys,
                                 GError **error);
 
-gboolean xdg_app_pull_from_bundle (OstreeRepo   *repo,
+gboolean flatpak_pull_from_bundle (OstreeRepo   *repo,
                                    GFile        *file,
                                    const char   *remote,
                                    const char   *ref,
@@ -228,38 +228,38 @@ typedef struct
   char *installed_id;
   char *ref;
   char *directory;
-} XdgAppExtension;
+} FlatpakExtension;
 
-void xdg_app_extension_free (XdgAppExtension *extension);
+void flatpak_extension_free (FlatpakExtension *extension);
 
-GList *xdg_app_list_extensions (GKeyFile   *metakey,
+GList *flatpak_list_extensions (GKeyFile   *metakey,
                                 const char *arch,
                                 const char *branch);
 
-gboolean            xdg_app_spawn (GFile       *dir,
+gboolean            flatpak_spawn (GFile       *dir,
                                    char       **output,
                                    GError     **error,
                                    const gchar *argv0,
                                    va_list      args);
 
 typedef enum {
-  XDG_APP_CP_FLAGS_NONE = 0,
-  XDG_APP_CP_FLAGS_MERGE = 1<<0,
-  XDG_APP_CP_FLAGS_NO_CHOWN = 1<<1,
-  XDG_APP_CP_FLAGS_MOVE = 1<<2,
-} XdgAppCpFlags;
+  FLATPAK_CP_FLAGS_NONE = 0,
+  FLATPAK_CP_FLAGS_MERGE = 1<<0,
+  FLATPAK_CP_FLAGS_NO_CHOWN = 1<<1,
+  FLATPAK_CP_FLAGS_MOVE = 1<<2,
+} FlatpakCpFlags;
 
-gboolean   xdg_app_cp_a (GFile        *src,
-                         GFile        *dest,
-                         XdgAppCpFlags flags,
-                         GCancellable *cancellable,
-                         GError      **error);
+gboolean   flatpak_cp_a (GFile         *src,
+                         GFile         *dest,
+                         FlatpakCpFlags flags,
+                         GCancellable  *cancellable,
+                         GError       **error);
 
 
-#define xdg_app_autorm_rf _GLIB_CLEANUP (g_autoptr_cleanup_generic_gfree)
+#define flatpak_autorm_rf _GLIB_CLEANUP (g_autoptr_cleanup_generic_gfree)
 
 static inline void
-xdg_app_temp_dir_destroy (void *p)
+flatpak_temp_dir_destroy (void *p)
 {
   GFile *dir = p;
 
@@ -270,11 +270,11 @@ xdg_app_temp_dir_destroy (void *p)
     }
 }
 
-typedef GFile XdgAppTempDir;
+typedef GFile FlatpakTempDir;
 
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (XdgAppTempDir, xdg_app_temp_dir_destroy)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FlatpakTempDir, flatpak_temp_dir_destroy)
 
-#define AUTOLOCK(name) G_GNUC_UNUSED __attribute__((cleanup (xdg_app_auto_unlock_helper))) GMutex * G_PASTE (auto_unlock, __LINE__) = xdg_app_auto_lock_helper (&G_LOCK_NAME (name))
+#define AUTOLOCK(name) G_GNUC_UNUSED __attribute__((cleanup (flatpak_auto_unlock_helper))) GMutex * G_PASTE (auto_unlock, __LINE__) = flatpak_auto_lock_helper (&G_LOCK_NAME (name))
 
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (OstreeRepo, g_object_unref)
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (OstreeMutableTree, g_object_unref)
@@ -295,55 +295,55 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (SoupURI, soup_uri_free)
 typedef XdgAppSessionHelper AutoXdgAppSessionHelper;
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (AutoXdgAppSessionHelper, g_object_unref)
 
-typedef struct XdgAppXml XdgAppXml;
+typedef struct FlatpakXml FlatpakXml;
 
-struct XdgAppXml
+struct FlatpakXml
 {
-  gchar     *element_name; /* NULL == text */
-  char     **attribute_names;
-  char     **attribute_values;
-  char      *text;
-  XdgAppXml *parent;
-  XdgAppXml *first_child;
-  XdgAppXml *last_child;
-  XdgAppXml *next_sibling;
+  gchar      *element_name; /* NULL == text */
+  char      **attribute_names;
+  char      **attribute_values;
+  char       *text;
+  FlatpakXml *parent;
+  FlatpakXml *first_child;
+  FlatpakXml *last_child;
+  FlatpakXml *next_sibling;
 };
 
-XdgAppXml *xdg_app_xml_new (const gchar *element_name);
-XdgAppXml *xdg_app_xml_new_text (const gchar *text);
-void       xdg_app_xml_add (XdgAppXml *parent,
-                            XdgAppXml *node);
-void       xdg_app_xml_free (XdgAppXml *node);
-XdgAppXml *xdg_app_xml_parse (GInputStream *in,
-                              gboolean      compressed,
-                              GCancellable *cancellable,
-                              GError      **error);
-void       xdg_app_xml_to_string (XdgAppXml *node,
-                                  GString   *res);
-XdgAppXml *xdg_app_xml_unlink (XdgAppXml *node,
-                               XdgAppXml *prev_sibling);
-XdgAppXml *xdg_app_xml_find (XdgAppXml  *node,
-                             const char *type,
-                             XdgAppXml **prev_child_out);
+FlatpakXml *flatpak_xml_new (const gchar *element_name);
+FlatpakXml *flatpak_xml_new_text (const gchar *text);
+void       flatpak_xml_add (FlatpakXml *parent,
+                            FlatpakXml *node);
+void       flatpak_xml_free (FlatpakXml *node);
+FlatpakXml *flatpak_xml_parse (GInputStream *in,
+                               gboolean      compressed,
+                               GCancellable *cancellable,
+                               GError      **error);
+void       flatpak_xml_to_string (FlatpakXml *node,
+                                  GString    *res);
+FlatpakXml *flatpak_xml_unlink (FlatpakXml *node,
+                                FlatpakXml *prev_sibling);
+FlatpakXml *flatpak_xml_find (FlatpakXml  *node,
+                              const char  *type,
+                              FlatpakXml **prev_child_out);
 
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (XdgAppXml, xdg_app_xml_free);
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FlatpakXml, flatpak_xml_free);
 
 
-XdgAppXml *xdg_app_appstream_xml_new (void);
-gboolean   xdg_app_appstream_xml_migrate (XdgAppXml  *source,
-                                          XdgAppXml  *dest,
+FlatpakXml *flatpak_appstream_xml_new (void);
+gboolean   flatpak_appstream_xml_migrate (FlatpakXml *source,
+                                          FlatpakXml *dest,
                                           const char *ref,
                                           const char *id,
                                           GKeyFile   *metadata);
-GBytes *xdg_app_appstream_xml_root_to_data (XdgAppXml *appstream_root,
-                                            GError   **error);
-gboolean   xdg_app_repo_generate_appstream (OstreeRepo   *repo,
+GBytes *flatpak_appstream_xml_root_to_data (FlatpakXml *appstream_root,
+                                            GError    **error);
+gboolean   flatpak_repo_generate_appstream (OstreeRepo   *repo,
                                             const char  **gpg_key_ids,
                                             const char   *gpg_homedir,
                                             GCancellable *cancellable,
                                             GError      **error);
 
-gboolean xdg_app_allocate_tmpdir (int           tmpdir_dfd,
+gboolean flatpak_allocate_tmpdir (int           tmpdir_dfd,
                                   const char   *tmpdir_relpath,
                                   const char   *tmpdir_prefix,
                                   char        **tmpdir_name_out,
@@ -354,4 +354,4 @@ gboolean xdg_app_allocate_tmpdir (int           tmpdir_dfd,
                                   GError      **error);
 
 
-#endif /* __XDG_APP_UTILS_H__ */
+#endif /* __FLATPAK_UTILS_H__ */