[libsecret/wip/dueno/backend: 4/4] secret-backend: Add instantiation logic [ci-skip]

[Daiki Ueno <dueno src gnome org>]

commit ed054b2275ffc15dda692a7c03518ae229cb6eb1
Author: Daiki Ueno <dueno src gnome org>
Date:   Mon Jul 1 07:46:53 2019 +0200

    secret-backend: Add instantiation logic [ci-skip]

 libsecret/secret-backend.c |  97 ++++++++++++++++++++++++++++++++++++++
 libsecret/secret-backend.h | 115 ++++++++++++++++++++++++++++-----------------
 2 files changed, 169 insertions(+), 43 deletions(-)
---
diff --git a/libsecret/secret-backend.c b/libsecret/secret-backend.c
index 1cd3f1f..ef46756 100644
--- a/libsecret/secret-backend.c
+++ b/libsecret/secret-backend.c
@@ -17,6 +17,8 @@
 #include "secret-backend.h"
 #include "secret-private.h"
 
+#include "libsecret/secret-enum-types.h"
+
 /**
  * SECTION:secret-backend
  * @title: SecretBackend
@@ -93,3 +95,98 @@ _secret_backend_ensure_extension_point (void)
 
        registered = TRUE;
 }
+
+G_LOCK_DEFINE (backend_instance);
+static gpointer backend_instance = NULL;
+
+static SecretBackend *
+backend_get_instance (void)
+{
+       SecretBackend *instance = NULL;
+
+       G_LOCK (backend_instance);
+       if (backend_instance != NULL)
+               instance = g_object_ref (backend_instance);
+       G_UNLOCK (backend_instance);
+
+       return instance;
+}
+
+void
+secret_backend_get (SecretBackendFlags flags,
+                   GCancellable *cancellable,
+                   GAsyncReadyCallback callback,
+                   gpointer user_data)
+{
+       SecretBackend *backend = NULL;
+       SecretBackendInterface *iface;
+       GTask *task;
+       InitClosure *closure;
+
+       backend = backend_get_instance ();
+
+       /* Create a whole new service */
+       if (service == NULL) {
+               GType impl_type = backend_get_impl_type ();
+               g_return_if_fail (g_type_is_a (impl_type, G_TYPE_ASYNC_INITABLE));
+               g_async_initable_new_async (impl_type,
+                                           G_PRIORITY_DEFAULT,
+                                           cancellable, callback, user_data,
+                                           "flags", flags,
+                                           NULL);
+
+       /* Just have to ensure that the service matches flags */
+       } else {
+               iface = SECRET_BACKEND_GET_IFACE (self);
+               g_return_if_fail (iface->ensure_for_flags != NULL);
+
+               task = g_task_new (backend, cancellable, callback, usear_data);
+               g_task_set_source_tag (task, secret_backend_get);
+               iface->ensure_for_flags (service, flags, cancellable,
+                                        on_ensure_for_flags, task);
+
+               g_object_unref (backend);
+               g_object_unref (task);
+       }
+}
+
+SecretBackend *
+secret_backend_get_finish (GAsyncResult *result,
+                          GError **error)
+{
+       GTask *task;
+       GObject *backend = NULL;
+       GObject *source_object;
+
+       g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
+       g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+
+       task = G_TASK (result);
+       source_object = g_task_get_source_object (task);
+
+       g_return_val_if_fail (g_task_is_valid (result, source_object), NULL);
+
+       /* Just ensuring that the backend matches flags */
+       if (g_task_get_source_tag (task) == secret_backend_get) {
+               if (g_task_had_error (task)) {
+                       g_task_propagate_pointer (task, error);
+               } else {
+                       backend = g_object_ref (source_object);
+               }
+
+       /* Creating a whole new service */
+       } else {
+               backend = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), result, error);
+               if (backend) {
+                       G_LOCK (backend_instance);
+                       if (backend_instance == NULL)
+                               backend_instance = instance;
+                       G_UNLOCK (service_instance);
+               }
+       }
+
+       if (backend == NULL)
+               return NULL;
+
+       return SECRET_BACKEND (backend);
+}
diff --git a/libsecret/secret-backend.h b/libsecret/secret-backend.h
index eb7f0ab..72eacd8 100644
--- a/libsecret/secret-backend.h
+++ b/libsecret/secret-backend.h
@@ -20,61 +20,90 @@
 #define __SECRET_BACKEND_H__
 
 #include <glib-object.h>
+#include "secret-schema.h"
+#include "secret-value.h"
 
 G_BEGIN_DECLS
 
+typedef enum {
+        SECRET_BACKEND_NONE = SECRET_SERVICE_NONE,
+        SECRET_BACKEND_OPEN_SESSION = SECRET_SERVICE_OPEN_SESSION,
+        SECRET_BACKEND_LOAD_COLLECTIONS = SECRET_SERVICE_LOAD_COLLECTIONS,
+} SecretBackendFlags;
+
 #define SECRET_TYPE_BACKEND secret_backend_get_type ()
 G_DECLARE_INTERFACE (SecretBackend, secret_backend, SECRET, BACKEND, GObject)
 
 struct _SecretBackendInterface
 {
-       GTypeInterface parent_iface;
-
-       void         (*store)         (SecretBackend *self,
-                                      const SecretSchema *schema,
-                                      GHashTable *attributes,
-                                      const gchar *collection,
-                                      const gchar *label,
-                                      SecretValue *value,
-                                      GCancellable *cancellable,
-                                      GAsyncReadyCallback callback,
-                                      gpointer user_data);
-       gboolean     (*store_finish)  (SecretBackend *self,
-                                      GAsyncResult *result,
-                                      GError **error);
-       void         (*lookup)        (SecretBackend *self,
-                                      const SecretSchema *schema,
-                                      GHashTable *attributes,
-                                      GCancellable *cancellable,
-                                      GAsyncReadyCallback callback,
-                                      gpointer user_data);
-       SecretValue *(*lookup_finish) (SecretBackend *self,
-                                      GAsyncResult *result,
-                                      GError **error);
-       void         (*clear)         (SecretBackend *self,
-                                      const SecretSchema *schema,
-                                      GHashTable *attributes,
-                                      GCancellable *cancellable,
-                                      GAsyncReadyCallback callback,
-                                      gpointer user_data);
-       gboolean     (*clear_finish)  (SecretBackend *self,
-                                      GAsyncResult *result,
-                                      GError **error);
-       void         (*search)        (SecretBackend *self,
-                                      const SecretSchema *schema,
-                                      GHashTable *attributes,
-                                      SecretSearchFlags flags,
-                                      GCancellable *cancellable,
-                                      GAsyncReadyCallback callback,
-                                      gpointer user_data);
-       GList *      (*search_finish) (SecretBackend *self,
-                                      GAsyncResult *result,
-                                      GError **error);
+        GTypeInterface parent_iface;
+
+        void         (*ensure_for_flags)        (SecretBackend *self,
+                                                 SecretBackendFlags flags,
+                                                GCancellable *cancellable,
+                                                GAsyncReadyCallback callback,
+                                                 gpointer user_data);
+        gboolean     (*ensure_for_flags_finish) (SecretBackend *self,
+                                                 GAsyncResult *result,
+                                                 GError **error);
+
+        void         (*store)                   (SecretBackend *self,
+                                                 const SecretSchema *schema,
+                                                 GHashTable *attributes,
+                                                 const gchar *collection,
+                                                 const gchar *label,
+                                                 SecretValue *value,
+                                                 GCancellable *cancellable,
+                                                 GAsyncReadyCallback callback,
+                                                 gpointer user_data);
+        gboolean     (*store_finish)            (SecretBackend *self,
+                                                 GAsyncResult *result,
+                                                 GError **error);
+
+        void         (*lookup)                  (SecretBackend *self,
+                                                 const SecretSchema *schema,
+                                                 GHashTable *attributes,
+                                                 GCancellable *cancellable,
+                                                 GAsyncReadyCallback callback,
+                                                 gpointer user_data);
+        SecretValue *(*lookup_finish)           (SecretBackend *self,
+                                                 GAsyncResult *result,
+                                                 GError **error);
+
+        void         (*clear)                   (SecretBackend *self,
+                                                 const SecretSchema *schema,
+                                                 GHashTable *attributes,
+                                                 GCancellable *cancellable,
+                                                 GAsyncReadyCallback callback,
+                                                 gpointer user_data);
+        gboolean     (*clear_finish)            (SecretBackend *self,
+                                                 GAsyncResult *result,
+                                                 GError **error);
+
+        void         (*search)                  (SecretBackend *self,
+                                                 const SecretSchema *schema,
+                                                 GHashTable *attributes,
+                                                 SecretSearchFlags flags,
+                                                 GCancellable *cancellable,
+                                                 GAsyncReadyCallback callback,
+                                                 gpointer user_data);
+        GList *      (*search_finish)           (SecretBackend *self,
+                                                 GAsyncResult *result,
+                                                 GError **error);
 };
 
 #define SECRET_BACKEND_EXTENSION_POINT_NAME "secret-backend"
 
-void _secret_backend_ensure_extension_point (void);
+void           _secret_backend_ensure_extension_point
+                                         (void);
+
+void           secret_backend_get        (SecretBackendFlags flags,
+                                          GCancellable *cancellable,
+                                          GAsyncReadyCallback callback,
+                                          gpointer user_data);
+
+SecretBackend *secret_backend_get_finish (GAsyncResult *result,
+                                          GError **error);
 
 G_END_DECLS