eina: Remove unnecessary indirection to promises

Now when dealing with pointer types, we will not get pointer to
pointer semantics in callbacks and eina_promise_owner_value_set
for Eina_Promise.

It will work as expected:

Eina_Promise_Owner* promise = eina_promise_add();

void* p = malloc(sizeof(T));
eina_promise_owner_value_set(promise, p, &free);

21 files changed, 554 insertions, 220 deletions

diff --git a/src/benchmarks/eina/eina_bench_promise.c b/src/benchmarks/eina/eina_bench_promise.c
index 0d1afc5d5d..ee6153ca22 100644
--- a/src/benchmarks/eina/eina_bench_promise.c
+++ b/src/benchmarks/eina/eina_bench_promise.c
@@ -67,7 +67,7 @@ eina_bench_promise_sync_then(int request)
 
    eina_init();
 
-   Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type));
+   Eina_Promise_Owner* owner = eina_promise_value_add(sizeof(struct value_type));
    Eina_Promise* promise = eina_promise_owner_promise_get(owner);
    eina_promise_ref(promise);
 
@@ -101,7 +101,7 @@ eina_bench_promise_copy_value_set_after_then(int request)
    for (j = 0; j != 200; ++j)
       for (i = 0; i != request; ++i)
         {
-           Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type));
+           Eina_Promise_Owner* owner = eina_promise_value_add(sizeof(struct value_type));
            Eina_Promise* promise = eina_promise_owner_promise_get(owner);
 
            eina_promise_then(promise, &cb, NULL, NULL);
@@ -126,7 +126,7 @@ eina_bench_promise_no_copy_value_set_after_then(int request)
    for (j = 0; j != 200; ++j)
       for (i = 0; i != request; ++i)
         {
-           Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type));
+           Eina_Promise_Owner* owner = eina_promise_value_add(sizeof(struct value_type));
            Eina_Promise* promise = eina_promise_owner_promise_get(owner);
            struct value_type* v = eina_promise_owner_buffer_get(owner);
 
@@ -154,7 +154,7 @@ eina_bench_promise_no_copy_value_set_before_then(int request)
    for (j = 0; j != 200; ++j)
       for (i = 0; i != request; ++i)
         {
-           Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type));
+           Eina_Promise_Owner* owner = eina_promise_value_add(sizeof(struct value_type));
            Eina_Promise* promise = eina_promise_owner_promise_get(owner);
            struct value_type* v = eina_promise_owner_buffer_get(owner);
 
@@ -184,7 +184,7 @@ eina_bench_promise_copy_value_set_before_then(int request)
    for (j = 0; j != 200; ++j)
       for (i = 0; i != request; ++i)
         {
-           Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type));
+           Eina_Promise_Owner* owner = eina_promise_value_add(sizeof(struct value_type));
            Eina_Promise* promise = eina_promise_owner_promise_get(owner);
 
            eina_promise_then(promise, &cb, NULL, NULL);
@@ -214,15 +214,14 @@ eina_bench_promise_pointer_value_set_before_then(int request)
    for (j = 0; j != 200; ++j)
       for (i = 0; i != request; ++i)
         {
-           Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type*));
+           Eina_Promise_Owner* owner = eina_promise_add();
            Eina_Promise* promise = eina_promise_owner_promise_get(owner);
 
-           struct value_type* p = *(struct value_type**)eina_promise_owner_buffer_get(owner)
-             = malloc(sizeof(struct value_type));
+           struct value_type* p = malloc(sizeof(struct value_type));
            p->x = p->y = p->w = p->h = 0;
 
            eina_promise_then(promise, &pointer_cb, NULL, NULL);
-           eina_promise_owner_value_set(owner, NULL, &indirect_free);
+           eina_promise_owner_value_set(owner, p, &indirect_free);
         }
 
    /* Suppress warnings as we really don't want to do anything. */
@@ -243,14 +242,13 @@ eina_bench_promise_pointer_value_set_after_then(int request)
    for (j = 0; j != 200; ++j)
       for (i = 0; i != request; ++i)
         {
-           Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type*));
+           Eina_Promise_Owner* owner = eina_promise_add();
            Eina_Promise* promise = eina_promise_owner_promise_get(owner);
 
-           struct value_type* p = *(struct value_type**)eina_promise_owner_buffer_get(owner)
-             = malloc(sizeof(struct value_type));
+           struct value_type* p = malloc(sizeof(struct value_type));
            p->x = p->y = p->w = p->h = 0;
 
-           eina_promise_owner_value_set(owner, NULL, &indirect_free);
+           eina_promise_owner_value_set(owner, p, &indirect_free);
            eina_promise_then(promise, &pointer_cb, NULL, NULL);
         }
 
@@ -282,15 +280,14 @@ eina_bench_promise_pointer_value_set_before_then_pooled(int request)
    for (j = 0; j != 200; ++j)
       for (i = 0; i != request; ++i)
         {
-           Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type*));
+           Eina_Promise_Owner* owner = eina_promise_add();
            Eina_Promise* promise = eina_promise_owner_promise_get(owner);
 
-           struct value_type* p = *(struct value_type**)eina_promise_owner_buffer_get(owner)
-             = eina_mempool_malloc(mempool, sizeof(struct value_type));
+           struct value_type* p = eina_mempool_malloc(mempool, sizeof(struct value_type));
            p->x = p->y = p->w = p->h = 0;
 
            eina_promise_then(promise, &pointer_cb, NULL, NULL);
-           eina_promise_owner_value_set(owner, NULL, &indirect_mempool_free);
+           eina_promise_owner_value_set(owner, p, &indirect_mempool_free);
         }
 
    /* Suppress warnings as we really don't want to do anything. */
@@ -316,14 +313,13 @@ eina_bench_promise_pointer_value_set_after_then_pooled(int request)
    for (j = 0; j != 200; ++j)
       for (i = 0; i != request; ++i)
         {
-           Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type*));
+           Eina_Promise_Owner* owner = eina_promise_add();
            Eina_Promise* promise = eina_promise_owner_promise_get(owner);
 
-           struct value_type* p = *(struct value_type**)eina_promise_owner_buffer_get(owner)
-             = eina_mempool_malloc(mempool, sizeof(struct value_type));
+           struct value_type* p = eina_mempool_malloc(mempool, sizeof(struct value_type));
            p->x = p->y = p->w = p->h = 0;
 
-           eina_promise_owner_value_set(owner, NULL, &indirect_mempool_free);
+           eina_promise_owner_value_set(owner, p, &indirect_mempool_free);
            eina_promise_then(promise, &pointer_cb, NULL, NULL);
         }
 
@@ -349,14 +345,13 @@ eina_bench_promise_pointer_value_set_before_then_non_alloc(int request)
    for (j = 0; j != 200; ++j)
       for (i = 0; i != request; ++i)
         {
-           Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type*));
+           Eina_Promise_Owner* owner = eina_promise_add();
            Eina_Promise* promise = eina_promise_owner_promise_get(owner);
 
            struct value_type v = {0,0,0,0};
-           *(struct value_type**)eina_promise_owner_buffer_get(owner) = &v;
 
            eina_promise_then(promise, &pointer_cb, NULL, NULL);
-           eina_promise_owner_value_set(owner, NULL, &indirect_mempool_free);
+           eina_promise_owner_value_set(owner, &v, NULL);
         }
 
    /* Suppress warnings as we really don't want to do anything. */
@@ -382,13 +377,12 @@ eina_bench_promise_pointer_value_set_after_then_non_alloc(int request)
    for (j = 0; j != 200; ++j)
       for (i = 0; i != request; ++i)
         {
-           Eina_Promise_Owner* owner = eina_promise_default_add(sizeof(struct value_type*));
+           Eina_Promise_Owner* owner = eina_promise_add();
            Eina_Promise* promise = eina_promise_owner_promise_get(owner);
 
            struct value_type v = {0,0,0,0};
-           *(struct value_type**)eina_promise_owner_buffer_get(owner) = &v;
 
-           eina_promise_owner_value_set(owner, NULL, &indirect_mempool_free);
+           eina_promise_owner_value_set(owner, &v, NULL);
            eina_promise_then(promise, &pointer_cb, NULL, NULL);
         }
 
diff --git a/src/bin/eolian/eo_generator.c b/src/bin/eolian/eo_generator.c
index 0d3516d360..6a6f279ca2 100644
--- a/src/bin/eolian/eo_generator.c
+++ b/src/bin/eolian/eo_generator.c
@@ -312,6 +312,7 @@ eo_bind_func_generate(const Eolian_Class *class, const Eolian_Function *funcid,
    Eina_Bool is_prop = (ftype == EOLIAN_PROP_GET || ftype == EOLIAN_PROP_SET);
 
    Eina_Bool has_promise = EINA_FALSE;
+   Eina_Bool is_pointer_promise = EINA_FALSE;
    const char* promise_param_name = NULL;
    const char* promise_value_type = NULL;
    Eina_Bool need_implementation = EINA_TRUE;
@@ -394,7 +395,11 @@ eo_bind_func_generate(const Eolian_Class *class, const Eolian_Function *funcid,
                   promise_values = eolian_type_subtypes_get(ptypet);
                   Eolian_Type* subtype;
                   if(eina_iterator_next(promise_values, (void**)&subtype))
+                    {
                       promise_value_type = eolian_type_c_type_get(subtype);
+                      is_pointer_promise = eolian_type_type_get(subtype) == EOLIAN_TYPE_POINTER
+                        || eolian_type_type_get(subtype) == EOLIAN_TYPE_COMPLEX;
+                    }
                   eina_strbuf_append_printf(impl_full_params, ", Eina_Promise_Owner *%s%s",
                          pname, is_empty && !dflt_value ?" EINA_UNUSED":"");
                   eina_strbuf_append_printf(params, "__eo_promise");
@@ -576,9 +581,10 @@ eo_bind_func_generate(const Eolian_Class *class, const Eolian_Function *funcid,
           {
              eina_strbuf_append_printf(fbody,
                                        "#undef _EO_API_BEFORE_HOOK\n#undef _EO_API_AFTER_HOOK\n#undef _EO_API_CALL_HOOK\n"
-                                       "#define _EO_API_BEFORE_HOOK _EINA_PROMISE_BEFORE_HOOK(%s, %s%s)\n"
+                                       "#define _EO_API_BEFORE_HOOK _EINA_PROMISE_%sBEFORE_HOOK(%s, %s%s)\n"
                                        "#define _EO_API_AFTER_HOOK _EINA_PROMISE_AFTER_HOOK(%s)\n"
                                        "#define _EO_API_CALL_HOOK(x) _EINA_PROMISE_CALL_HOOK(EO_FUNC_CALL(%s))\n\n",
+                                       (is_pointer_promise? "POINTER_": ""),
                                        promise_value_type, !rettype ? "void" : rettype,
                                        eina_strbuf_string_get(impl_full_params),
                                        promise_param_name,
diff --git a/src/lib/ecore/Ecore_Common.h b/src/lib/ecore/Ecore_Common.h
index 6877e26ab8..1dac86927a 100644
--- a/src/lib/ecore/Ecore_Common.h
+++ b/src/lib/ecore/Ecore_Common.h
@@ -3098,7 +3098,7 @@ typedef void(*Ecore_Thread_Promise_Cb)(const void* data, Eina_Promise_Owner* pro
  */
 EAPI Ecore_Thread* ecore_thread_promise_run(Ecore_Thread_Promise_Cb func_heavy,
                                             Ecore_Thread_Promise_Cb func_cancel,
-                                            const void* data, size_t value_size,
+                                            const void* data,
                                             Eina_Promise** promise);
 
 #endif
diff --git a/src/lib/ecore/ecore_main.c b/src/lib/ecore/ecore_main.c
index a361289654..b9d5699fb0 100644
--- a/src/lib/ecore/ecore_main.c
+++ b/src/lib/ecore/ecore_main.c
@@ -2821,7 +2821,7 @@ _efl_loop_job_cb(void *data)
 {
    Efl_Internal_Promise *j = data;
 
-   eina_promise_owner_value_set(j->promise, &j->data, NULL);
+   eina_promise_owner_value_set(j->promise, j->data, NULL);
 
    free(j);
 }
@@ -2831,7 +2831,7 @@ _efl_loop_timeout_cb(void *data, const Eo_Event *event EINA_UNUSED)
 {
    Efl_Internal_Promise *t = data;
 
-   eina_promise_owner_value_set(t->promise, &t->data, NULL);
+   eina_promise_owner_value_set(t->promise, t->data, NULL);
 
    eo_del(t->u.timer);
 
@@ -2902,7 +2902,7 @@ _efl_loop_job(Eo *obj EINA_UNUSED, Efl_Loop_Data *pd EINA_UNUSED, const void *da
    Efl_Internal_Promise *j;
    Eina_Promise_Owner *promise;
 
-   promise = eina_promise_default_add(sizeof (void*));
+   promise = eina_promise_add();
    if (!promise) return NULL;
 
    j = _efl_internal_promise_new(promise, data);
@@ -2940,7 +2940,7 @@ _efl_loop_timeout(Eo *obj, Efl_Loop_Data *pd EINA_UNUSED, double time, const voi
    Efl_Internal_Promise *t;
    Eina_Promise_Owner *promise;
 
-   promise = eina_promise_default_add(sizeof (void*));
+   promise = eina_promise_add();
    if (!promise) return NULL;
 
    t = _efl_internal_promise_new(promise, data);
diff --git a/src/lib/ecore/ecore_thread_promise.c b/src/lib/ecore/ecore_thread_promise.c
index caf312cff3..dcdd653292 100644
--- a/src/lib/ecore/ecore_thread_promise.c
+++ b/src/lib/ecore/ecore_thread_promise.c
@@ -197,22 +197,17 @@ static size_t _ecore_promise_value_size_get(Eina_Promise const* promise)
    _Ecore_Thread_Promise_Owner* v = ECORE_PROMISE_GET_OWNER(promise);
    return v->eina_promise->value_size_get(v->eina_promise);
 }
-static void* _ecore_promise_release_value_ownership(Eina_Promise* promise)
-{
-   _Ecore_Thread_Promise_Owner* v = ECORE_PROMISE_GET_OWNER(promise);
-   return v->eina_promise->release_value_ownership(v->eina_promise);
-}
 
 Ecore_Thread* ecore_thread_promise_run(Ecore_Thread_Promise_Cb func_blocking,
                                        Ecore_Thread_Promise_Cb func_cancel,
-                                       const void* data, size_t value_size,
+                                       const void* data,
                                        Eina_Promise** promise)
 {
    _Ecore_Thread_Promise_Owner* priv;
 
    priv = malloc(sizeof(_Ecore_Thread_Promise_Owner));
 
-   priv->eina_owner = eina_promise_default_add(value_size);
+   priv->eina_owner = eina_promise_add();
 
    priv->owner_vtable.version = EINA_PROMISE_VERSION;
    priv->owner_vtable.value_set = EINA_FUNC_PROMISE_OWNER_VALUE_SET(&_ecore_promise_owner_value_set);
@@ -235,8 +230,6 @@ Ecore_Thread* ecore_thread_promise_run(Ecore_Thread_Promise_Cb func_blocking,
    priv->promise_vtable.unref = EINA_FUNC_PROMISE_UNREF(&_ecore_promise_unref);
    priv->promise_vtable.value_size_get = EINA_FUNC_PROMISE_VALUE_SIZE_GET(&_ecore_promise_value_size_get);
    priv->promise_vtable.buffer_get = EINA_FUNC_PROMISE_BUFFER_GET(&_ecore_promise_buffer_get);
-   priv->promise_vtable.release_value_ownership = EINA_FUNC_PROMISE_RELEASE_VALUE_OWNERSHIP
-     (&_ecore_promise_release_value_ownership);
    
    priv->thread_callback_data.data = data;
    priv->thread_callback_data.func_blocking = func_blocking;
diff --git a/src/lib/eina/eina_promise.c b/src/lib/eina/eina_promise.c
index 2c5a14a1ad..71f0381e70 100644
--- a/src/lib/eina/eina_promise.c
+++ b/src/lib/eina/eina_promise.c
@@ -79,6 +79,7 @@ struct _Eina_Promise_Default
    Eina_Bool is_cancelled : 1;
    Eina_Bool is_manual_then : 1;
    Eina_Bool is_first_then : 1;
+   Eina_Bool is_pointer : 1;
 };
 
 struct _Eina_Promise_Default_Owner
@@ -93,7 +94,6 @@ struct _Eina_Promise_Default_Owner
 
 struct _Eina_Promise_Iterator
 {
-   Eina_Iterator* success_iterator;
    struct _Eina_Promise_Success_Iterator
    {
       Eina_Iterator success_iterator_impl;
@@ -173,7 +173,14 @@ _eina_promise_then_calls(_Eina_Promise_Default_Owner* promise)
          }
        else if (callback->callback)
          {
-            (*callback->callback)(callback->data, &promise->value[0], &promise->promise.vtable);
+            if(promise->promise.is_pointer)
+              {
+                 char* buffer = promise->value;
+                 void** p = (void**)buffer;
+                 (*callback->callback)(callback->data, *p, &promise->promise.vtable);
+              }
+            else
+              (*callback->callback)(callback->data, &promise->value[0], &promise->promise.vtable);
          }
        free(callback);
        _eina_promise_unref(&promise->promise);
@@ -211,7 +218,16 @@ _eina_promise_del(_Eina_Promise_Default_Owner* promise)
      }
 
    if (promise->promise.value_free_cb)
-     promise->promise.value_free_cb((void*)&promise->value[0]);
+     {
+        if(promise->promise.is_pointer)
+          {
+             char* buffer = promise->value;
+             void** p = (void**)buffer;
+             promise->promise.value_free_cb(*p);
+          }
+        else
+          promise->promise.value_free_cb((void*)&promise->value[0]);
+     }
 
    _eina_promise_free_callback_list(&promise->promise.progress_callbacks,
                                     &_eina_promise_free_progress_callback_node);
@@ -227,6 +243,14 @@ _eina_promise_owner_buffer_get(_Eina_Promise_Default_Owner* promise)
 }
 
 static void *
+_eina_promise_owner_pointer_buffer_get(_Eina_Promise_Default_Owner* promise)
+{
+   char* buffer = promise->value;
+   void** p = (void**)buffer;
+   return *p;
+}
+
+static void *
 _eina_promise_buffer_get(_Eina_Promise_Default const* promise)
 {
    _Eina_Promise_Default_Owner const* p = EINA_PROMISE_GET_OWNER(promise);
@@ -248,13 +272,14 @@ _eina_promise_value_get(_Eina_Promise_Default const* p)
 }
 
 static void *
-_eina_promise_release_value_ownership(_Eina_Promise_Default* p)
+_eina_promise_pointer_value_get(_Eina_Promise_Default const* p)
 {
-   _Eina_Promise_Default_Owner* promise = EINA_PROMISE_GET_OWNER(p);
+   _Eina_Promise_Default_Owner const* promise = EINA_PROMISE_GET_OWNER(p);
    if (p->has_finished && !p->has_errored)
      {
-       p->value_free_cb = NULL;
-       return (void*)&promise->value[0];
+        char const* buffer = promise->value;
+        void** p = (void**)buffer;
+        return *p;
      }
    else
      {
@@ -276,6 +301,16 @@ _eina_promise_owner_value_set(_Eina_Promise_Default_Owner* promise, const void*
 }
 
 static void
+_eina_promise_owner_pointer_value_set(_Eina_Promise_Default_Owner* promise, const void* data, Eina_Promise_Free_Cb free)
+{
+   char* buffer = promise->value;
+   void** p = (void**)buffer;
+   *p = (void*)data;
+   promise->promise.value_free_cb = free;
+   _eina_promise_finish(promise);
+}
+
+static void
 _eina_promise_then(_Eina_Promise_Default* p, Eina_Promise_Cb callback,
 		   Eina_Promise_Error_Cb error_cb, void* data)
 {
@@ -485,7 +520,7 @@ _eina_promise_owner_progress_notify(_Eina_Promise_Default_Owner* promise, Eina_P
 }
 
 Eina_Promise_Owner *
-eina_promise_default_add(int value_size)
+eina_promise_value_add(int value_size)
 {
    _Eina_Promise_Default_Owner* p;
 
@@ -501,9 +536,8 @@ eina_promise_default_add(int value_size)
    p->promise.vtable.unref = EINA_FUNC_PROMISE_UNREF(_eina_promise_unref);
    p->promise.vtable.value_size_get = EINA_FUNC_PROMISE_VALUE_SIZE_GET(_eina_promise_value_size_get);
    p->promise.vtable.buffer_get = EINA_FUNC_PROMISE_BUFFER_GET(_eina_promise_buffer_get);
-   p->promise.vtable.release_value_ownership = EINA_FUNC_PROMISE_RELEASE_VALUE_OWNERSHIP(_eina_promise_release_value_ownership);
    p->promise.has_finished = p->promise.has_errored =
-     p->promise.is_cancelled = p->promise.is_manual_then = EINA_FALSE;
+     p->promise.is_cancelled = p->promise.is_manual_then = p->promise.is_pointer = EINA_FALSE;
    p->promise.is_first_then = EINA_TRUE;
    p->promise.ref = 1;
    memset(&p->promise.then_callbacks, 0, sizeof(p->promise.then_callbacks));
@@ -528,6 +562,49 @@ eina_promise_default_add(int value_size)
    return &p->owner_vtable;
 }
 
+EAPI Eina_Promise_Owner *
+eina_promise_add()
+{
+   _Eina_Promise_Default_Owner* p;
+
+   p = malloc(sizeof(_Eina_Promise_Default_Owner) + sizeof(void*));
+   p->promise.vtable.version = EINA_PROMISE_VERSION;
+   p->promise.vtable.then = EINA_FUNC_PROMISE_THEN(_eina_promise_then);
+   p->promise.vtable.value_get = EINA_FUNC_PROMISE_VALUE_GET(_eina_promise_pointer_value_get);
+   p->promise.vtable.error_get = EINA_FUNC_PROMISE_ERROR_GET(_eina_promise_error_get);
+   p->promise.vtable.pending_is = EINA_FUNC_PROMISE_PENDING_IS(_eina_promise_pending_is);
+   p->promise.vtable.progress_cb_add = EINA_FUNC_PROMISE_PROGRESS_CB_ADD(_eina_promise_progress_cb_add);
+   p->promise.vtable.cancel = EINA_FUNC_PROMISE_CANCEL(_eina_promise_cancel);
+   p->promise.vtable.ref = EINA_FUNC_PROMISE_REF(_eina_promise_ref);
+   p->promise.vtable.unref = EINA_FUNC_PROMISE_UNREF(_eina_promise_unref);
+   p->promise.vtable.value_size_get = EINA_FUNC_PROMISE_VALUE_SIZE_GET(_eina_promise_value_size_get);
+   p->promise.vtable.buffer_get = EINA_FUNC_PROMISE_BUFFER_GET(_eina_promise_buffer_get);
+   p->promise.has_finished = p->promise.has_errored =
+     p->promise.is_cancelled = p->promise.is_manual_then = EINA_FALSE;
+   p->promise.is_first_then = p->promise.is_pointer = EINA_TRUE;
+   p->promise.ref = 1;
+   memset(&p->promise.then_callbacks, 0, sizeof(p->promise.then_callbacks));
+   memset(&p->promise.progress_callbacks, 0, sizeof(p->promise.progress_callbacks));
+   memset(&p->promise.progress_notify_callbacks, 0, sizeof(p->promise.progress_notify_callbacks));
+   memset(&p->promise.cancel_callbacks, 0, sizeof(p->promise.cancel_callbacks));
+   p->promise.value_size = 0;
+   p->promise.value_free_cb = NULL;
+   p->promise.error = 0;
+
+   p->owner_vtable.version = EINA_PROMISE_VERSION;
+   p->owner_vtable.value_set = EINA_FUNC_PROMISE_OWNER_VALUE_SET(_eina_promise_owner_pointer_value_set);
+   p->owner_vtable.error_set = EINA_FUNC_PROMISE_OWNER_ERROR_SET(_eina_promise_owner_error_set);
+   p->owner_vtable.buffer_get = EINA_FUNC_PROMISE_OWNER_BUFFER_GET(_eina_promise_owner_pointer_buffer_get);
+   p->owner_vtable.value_size_get = EINA_FUNC_PROMISE_OWNER_VALUE_SIZE_GET(_eina_promise_owner_value_size_get);
+   p->owner_vtable.promise_get = EINA_FUNC_PROMISE_OWNER_PROMISE_GET(_eina_promise_owner_promise_get);
+   p->owner_vtable.pending_is = EINA_FUNC_PROMISE_OWNER_PENDING_IS(_eina_promise_owner_pending_is);
+   p->owner_vtable.cancelled_is = EINA_FUNC_PROMISE_OWNER_CANCELLED_IS(_eina_promise_owner_cancelled_is);
+   p->owner_vtable.progress = EINA_FUNC_PROMISE_OWNER_PROGRESS(_eina_promise_owner_progress);
+   p->owner_vtable.progress_notify = EINA_FUNC_PROMISE_OWNER_PROGRESS_NOTIFY(_eina_promise_owner_progress_notify);
+
+   return &p->owner_vtable;
+}
+
 void
 eina_promise_owner_default_manual_then_set(Eina_Promise_Owner* owner, Eina_Bool is_manual)
 {
@@ -575,8 +652,6 @@ _eina_promise_all_free(_Eina_Promise_Iterator* value)
 {
    unsigned i = 0;
 
-   eina_iterator_free(value->success_iterator);
-
    for (;i != value->data.num_promises; ++i)
      {
         eina_promise_unref(value->data.promises[i]);
@@ -602,8 +677,8 @@ eina_promise_all(Eina_Iterator* it)
    eina_iterator_free(it);
 
    promise = (_Eina_Promise_Default_Owner*)
-     eina_promise_default_add(sizeof(_Eina_Promise_Iterator) +
-                              sizeof(_Eina_Promise_Default_Owner*)*eina_array_count_get(promises));
+     eina_promise_value_add(sizeof(_Eina_Promise_Iterator) +
+                            sizeof(_Eina_Promise_Default_Owner*)*eina_array_count_get(promises));
    internal_it = (_Eina_Promise_Iterator*)&promise->value[0];
    _eina_promise_iterator_setup(internal_it, promises);
    eina_array_free(promises);
@@ -655,7 +730,6 @@ _eina_promise_iterator_setup(_Eina_Promise_Iterator* it, Eina_Array* promises_ar
 {
    Eina_Promise** promises;
 
-   it->success_iterator = &it->data.success_iterator_impl;
    it->data.num_promises = eina_array_count_get(promises_array);
    it->data.promise_index = 0;
    it->data.promises_finished = 0;
@@ -695,7 +769,7 @@ eina_promise_progress_notification(Eina_Promise_Owner* promise)
 {
   Eina_Promise_Owner* owner;
 
-  owner = eina_promise_default_add(0);
+  owner = eina_promise_value_add(0);
 
   eina_promise_owner_progress_notify(promise, &_eina_promise_progress_notify_fulfilled, owner,
                                      &_eina_promise_progress_notify_failed);
@@ -768,8 +842,8 @@ eina_promise_race(Eina_Iterator* it)
 
    num_promises = eina_array_count_get(promises);
    promise = (_Eina_Promise_Default_Owner*)
-     eina_promise_default_add(sizeof(_Eina_Promise_Race_Value_Type) +
-                              sizeof(struct _Eina_Promise_Race_Information)*num_promises);
+     eina_promise_value_add(sizeof(_Eina_Promise_Race_Value_Type) +
+                            sizeof(struct _Eina_Promise_Race_Information)*num_promises);
    value = eina_promise_owner_buffer_get((Eina_Promise_Owner*)promise);
    value->value = NULL;
    value->promise_index = -1;
@@ -868,12 +942,6 @@ eina_promise_buffer_get(Eina_Promise* promise)
    return promise->buffer_get(promise);
 }
 
-EAPI void *
-eina_promise_release_value_ownership(Eina_Promise* promise)
-{
-   return promise->release_value_ownership(promise);
-}
-
 EAPI size_t
 eina_promise_value_size_get(Eina_Promise const* promise)
 {
diff --git a/src/lib/eina/eina_promise.h b/src/lib/eina/eina_promise.h
index 8bba454107..b1aa7fbc78 100644
--- a/src/lib/eina/eina_promise.h
+++ b/src/lib/eina/eina_promise.h
@@ -107,13 +107,6 @@ typedef void*(*Eina_Promise_Buffer_Get_Cb)(Eina_Promise* promise);
 #define EINA_FUNC_PROMISE_BUFFER_GET(Function) ((Eina_Promise_Buffer_Get_Cb)Function)
 
 /*
- * @brief Function callback type for promise's release_value_ownership function override
- */
-typedef void*(*Eina_Promise_Release_Value_Ownership_Cb)(Eina_Promise* promise);
-
-#define EINA_FUNC_PROMISE_RELEASE_VALUE_OWNERSHIP(Function) ((Eina_Promise_Release_Value_Ownership_Cb)Function)
-
-/*
  * @brief Function callback type for promise's value_size_get function override
  */
 typedef size_t(*Eina_Promise_Value_Size_Get_Cb)(Eina_Promise const* promise);
@@ -201,7 +194,6 @@ struct _Eina_Promise
   Eina_Promise_Unref_Cb unref;
   Eina_Promise_Value_Size_Get_Cb value_size_get;
   Eina_Promise_Buffer_Get_Cb buffer_get;
-  Eina_Promise_Release_Value_Ownership_Cb release_value_ownership;
 #define EINA_MAGIC_PROMISE 0x07932A5B
   EINA_MAGIC;
 };
@@ -304,15 +296,6 @@ EAPI void* eina_promise_value_get(Eina_Promise const* promise);
 EAPI void* eina_promise_buffer_get(Eina_Promise* promise);
 
 /*
- * @brief Returns the pointer to the value and releases ownership of
- * the value by the promise.
- * 
- * @param promise The promise for which to release value ownership
- * @return Pointer to value
- */
-EAPI void* eina_promise_release_value_ownership(Eina_Promise* promise);
-
-/*
  * @brief Returns the pointer to the buffer that holds the value.
  *
  * This function always return the buffer pointer independently if the
@@ -485,7 +468,24 @@ typedef void(*Eina_Promise_Default_Cancel_Cb)(void* data, Eina_Promise_Owner* pr
  * @param value_size Size of value-type that Eina_Promise will hold
  * @return @Eina_Promise_Owner just instantiated
  */
-EAPI Eina_Promise_Owner* eina_promise_default_add(int value_size);
+EAPI Eina_Promise_Owner* eina_promise_value_add(int value_size);
+
+/*
+ * @brief Creates a @Eina_Promise_Owner
+ *
+ * Create a @Eina_Promise_Owner for a pointer-type. Which is a promise
+ * with ownership of the pointer when its value is set.  The Promise
+ * itself, returned by eina_promise_owner_promise_get, represents the
+ * asynchronicity of the value itself and is used solely to get the
+ * value and to handle users of the asynchronous value. That's why
+ * Promises have a reference count while Promise Owners do not, the
+ * eina_promise_owner_value_set must be done only once, and
+ * consequently, has a unique ownership of the owner lifetime, while
+ * the promise can be queried and used by multiple users.
+ *
+ * @return @Eina_Promise_Owner just instantiated
+ */
+EAPI Eina_Promise_Owner* eina_promise_add();
 
 /*
  * @brief Adds a cancel callback to be called when the promise is
@@ -532,7 +532,12 @@ EAPI extern Eina_Error EINA_ERROR_PROMISE_CANCEL;
  * @internal
  */
 #define _EINA_PROMISE_BEFORE_HOOK(PromiseValue, Ret, ...)               \
-  Eina_Promise_Owner* const __eo_promise = eina_promise_default_add(sizeof(PromiseValue)); \
+  Eina_Promise_Owner* const __eo_promise = eina_promise_value_add(sizeof(PromiseValue)); \
+  typedef Ret (*_Eo_Promise_func_t_)(Eo*, void *obj_data, ##__VA_ARGS__); \
+  _Eo_Promise_func_t_ const _eo_promise_func_ = (_Eo_Promise_func_t_)_func_;
+
+#define _EINA_PROMISE_POINTER_BEFORE_HOOK(PromiseValue, Ret, ...)               \
+  Eina_Promise_Owner* const __eo_promise = eina_promise_add();          \
   typedef Ret (*_Eo_Promise_func_t_)(Eo*, void *obj_data, ##__VA_ARGS__); \
   _Eo_Promise_func_t_ const _eo_promise_func_ = (_Eo_Promise_func_t_)_func_;
 
diff --git a/src/lib/eio/eio_job.c b/src/lib/eio/eio_job.c
index 2524a59898..a8fccdb96b 100644
--- a/src/lib/eio/eio_job.c
+++ b/src/lib/eio/eio_job.c
@@ -318,7 +318,7 @@ _eio_job_file_direct_ls(Eo *obj,
       Eio_Job_Data *pd,
       const char *path)
 {
-   Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(int));
+   Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(int));
    _job_direct_ls_helper(&eio_file_direct_ls, obj, pd, path, promise);
    return eina_promise_owner_promise_get(promise);
 }
@@ -328,7 +328,7 @@ _eio_job_file_stat_ls(Eo *obj,
       Eio_Job_Data *pd,
       const char *path)
 {
-   Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(int));
+   Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(int));
    _job_direct_ls_helper(&eio_file_stat_ls, obj, pd, path, promise);
    return eina_promise_owner_promise_get(promise);
 }
@@ -338,7 +338,7 @@ _eio_job_dir_stat_ls(Eo *obj,
       Eio_Job_Data *pd,
       const char *path)
 {
-   Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(int));
+   Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(int));
    _job_direct_ls_helper(&eio_dir_stat_ls, obj, pd, path, promise);
    return eina_promise_owner_promise_get(promise);
 }
@@ -348,7 +348,7 @@ _eio_job_dir_direct_ls(Eo *obj,
                        Eio_Job_Data *pd,
                        const char *path)
 {
-   Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(int));
+   Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(int));
    // Had to add the cast as dir_direct differs in the filter callback constness of one of
    // its arguments.
    _job_direct_ls_helper((Eio_Job_Direct_Ls_Func)&eio_dir_direct_ls, obj, pd, path, promise);
@@ -360,7 +360,7 @@ _eio_job_file_ls(Eo *obj,
       Eio_Job_Data *pd,
       const char *path)
 {
-   Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(int));
+   Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(int));
    Job_Closure *operation_data = _job_closure_create(obj, pd, promise);
 
    Eina_Promise* p = eina_promise_owner_promise_get(promise);
@@ -403,7 +403,7 @@ _eio_job_file_direct_stat(Eo *obj,
                           Eio_Job_Data *pd,
                           const char *path)
 {
-   Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(Eina_Stat));
+   Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(Eina_Stat));
    Job_Closure *operation_data = _job_closure_create(obj, pd, promise);
 
    Eina_Promise* p = eina_promise_owner_promise_get(promise);
@@ -430,7 +430,7 @@ _eio_job_file_xattr_list_get(Eo *obj,
                     Eio_Job_Data *pd,
                     const char *path)
 {
-   Eina_Promise_Owner *promise = eina_promise_default_add(sizeof(int));
+   Eina_Promise_Owner *promise = eina_promise_value_add(sizeof(int));
    Job_Closure *operation_data = _job_closure_create(obj, pd, promise);
 
    Eina_Promise* p = eina_promise_owner_promise_get(promise);
@@ -461,7 +461,7 @@ _eio_job_file_xattr_set(Eo *obj,
                         unsigned int xattr_size,
                         Eina_Xattr_Flags flags)
 {
-   Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(int));
+   Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(int));
    Job_Closure *operation_data = _job_closure_create(obj, pd, promise);
 
    Eina_Promise* p = eina_promise_owner_promise_get(promise);
@@ -492,7 +492,7 @@ _eio_job_file_xattr_get(Eo *obj,
                         const char *path,
                         const char *attribute)
 {
-   Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(Eio_Xattr_Data));
+   Eina_Promise_Owner* promise = eina_promise_value_add(sizeof(Eio_Xattr_Data));
    Job_Closure *operation_data = _job_closure_create(obj, pd, promise);
 
    Eina_Promise* p = eina_promise_owner_promise_get(promise);
@@ -513,24 +513,13 @@ _eio_job_file_xattr_get(Eo *obj,
    return p;
 }
 
-/* Eina_File mapping and handling. */
-static void
-_eina_file_close(void* file)
-{
-   eina_file_close(*(Eina_File**)file);
-}
-
 static void
 _file_open_open_cb(void *data, Eio_File *handler EINA_UNUSED, Eina_File *file)
 {
    Job_Closure *operation = data;
    EINA_SAFETY_ON_NULL_RETURN(operation);
    EINA_SAFETY_ON_NULL_RETURN(operation->promise);
-   // FIXME On promise composition, a successfully open file would leak open
-   //       another promise in the composition fails as there is no free/close
-   //       function. Calling eina_file_close blocks on a lock_take call on a
-   //       field of the Eina_File file.
-   eina_promise_owner_value_set(operation->promise, &file, &_eina_file_close);
+   eina_promise_owner_value_set(operation->promise, file, (Eina_Promise_Free_Cb)&eina_file_close);
 
    _job_closure_del(operation);
 }
@@ -541,7 +530,7 @@ _eio_job_file_open(Eo *obj,
                    const char *path,
                    Eina_Bool shared)
 {
-   Eina_Promise_Owner* promise = eina_promise_default_add(sizeof(Eina_File*));
+   Eina_Promise_Owner* promise = eina_promise_add();
    Job_Closure *operation_data = _job_closure_create(obj, pd, promise);
 
    Eina_Promise* p = eina_promise_owner_promise_get(promise);
@@ -564,8 +553,7 @@ _file_close_done_cb(void *data, Eio_File *handler EINA_UNUSED)
 {
    EINA_SAFETY_ON_NULL_RETURN(data);
    Job_Closure *operation = data;
-   Eina_Bool result = EINA_TRUE;
-   eina_promise_owner_value_set(operation->promise, &result, NULL);
+   eina_promise_owner_value_set(operation->promise, NULL, NULL);
 
    _job_closure_del(operation);
 }
diff --git a/src/lib/eldbus/eldbus_model_arguments.c b/src/lib/eldbus/eldbus_model_arguments.c
index 645125486f..91192c9411 100644
--- a/src/lib/eldbus/eldbus_model_arguments.c
+++ b/src/lib/eldbus/eldbus_model_arguments.c
@@ -136,7 +136,8 @@ _eldbus_model_arguments_efl_model_property_set(Eo *obj EINA_UNUSED,
 
    eina_value_flush(prop_value);
    eina_value_copy(value, prop_value);
-   eina_promise_owner_value_set(promise, prop_value, NULL);
+   eina_value_copy(value, eina_promise_owner_buffer_get(promise));
+   eina_promise_owner_value_set(promise, NULL, (Eina_Promise_Free_Cb)&eina_value_flush);
 }
 
 static void
diff --git a/src/lib/eldbus/eldbus_model_connection.c b/src/lib/eldbus/eldbus_model_connection.c
index 591bc373f8..b05d9f7b34 100644
--- a/src/lib/eldbus/eldbus_model_connection.c
+++ b/src/lib/eldbus/eldbus_model_connection.c
@@ -149,7 +149,7 @@ _eldbus_model_connection_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
    if (pd->is_listed)
      {
         Eina_Accessor *ac = efl_model_list_slice(pd->children_list, start, count);
-        eina_promise_owner_value_set(promise, &ac, (Eina_Promise_Free_Cb)&_accessor_free);
+        eina_promise_owner_value_set(promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
         return;
      }
 
@@ -338,7 +338,7 @@ _eldbus_model_connection_names_list_cb(void *data,
    EINA_LIST_FOREACH(pd->children_promises, i, p)
      {
         Eina_Accessor *ac = efl_model_list_slice(pd->children_list, p->start, p->count);
-        eina_promise_owner_value_set(p->promise, &ac, (Eina_Promise_Free_Cb)&_accessor_free);
+        eina_promise_owner_value_set(p->promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
         free(p);
      }
    eina_list_free(pd->children_promises);
diff --git a/src/lib/eldbus/eldbus_model_object.c b/src/lib/eldbus/eldbus_model_object.c
index 9efc270779..b2ab91e05f 100644
--- a/src/lib/eldbus/eldbus_model_object.c
+++ b/src/lib/eldbus/eldbus_model_object.c
@@ -22,13 +22,6 @@ static void _eldbus_model_object_introspect_nodes(Eldbus_Model_Object_Data *, co
 static char *_eldbus_model_object_concatenate_path(const char *, const char *);
 static void _eldbus_model_object_create_children(Eldbus_Model_Object_Data *, Eldbus_Object *, Eina_List *);
 
-void
-_accessor_free(void *data)
-{
-  Eina_Accessor **ac = data;
-  eina_accessor_free(*ac);
-}
-
 static Eo_Base*
 _eldbus_model_object_eo_base_constructor(Eo *obj, Eldbus_Model_Object_Data *pd)
 {
@@ -190,7 +183,7 @@ _eldbus_model_object_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
    if (pd->is_listed)
      {
         Eina_Accessor* ac = efl_model_list_slice(pd->children_list, start, count);
-        eina_promise_owner_value_set(promise, &ac, &_accessor_free);
+        eina_promise_owner_value_set(promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
         return;
      }
 
@@ -437,7 +430,7 @@ _eldbus_model_object_introspect_cb(void *data,
         EINA_LIST_FOREACH(pd->children_promises, i, p)
           {
             Eina_Accessor* ac = efl_model_list_slice(pd->children_list, p->start, p->count);
-            eina_promise_owner_value_set(p->promise, &ac, &_accessor_free);
+            eina_promise_owner_value_set(p->promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
             free(p);
           }
         eina_list_free(pd->children_promises);
diff --git a/src/lib/eldbus/eldbus_model_private.h b/src/lib/eldbus/eldbus_model_private.h
index 29d7bddb18..eed5deb234 100644
--- a/src/lib/eldbus/eldbus_model_private.h
+++ b/src/lib/eldbus/eldbus_model_private.h
@@ -23,8 +23,6 @@ struct _Eldbus_Property_Promise
   Eina_Promise_Owner* promise;
 };
 
-void _accessor_free(void *data);
-
 /* logging support */
 extern int eldbus_model_log_dom;
 
diff --git a/src/lib/eldbus/eldbus_model_proxy.c b/src/lib/eldbus/eldbus_model_proxy.c
index 41a5f9b685..d6b104766f 100644
--- a/src/lib/eldbus/eldbus_model_proxy.c
+++ b/src/lib/eldbus/eldbus_model_proxy.c
@@ -233,7 +233,7 @@ _eldbus_model_proxy_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
      }
 
    Eina_Accessor *ac = efl_model_list_slice(pd->children_list, start, count);
-   eina_promise_owner_value_set(promise, &ac, (Eina_Promise_Free_Cb)&_accessor_free);
+   eina_promise_owner_value_set(promise, ac, (Eina_Promise_Free_Cb)&eina_accessor_free);
 }
 
 static void
diff --git a/src/lib/elementary/elm_view_form.c b/src/lib/elementary/elm_view_form.c
index 8f2fb85f88..57aafdc499 100644
--- a/src/lib/elementary/elm_view_form.c
+++ b/src/lib/elementary/elm_view_form.c
@@ -46,8 +46,10 @@ struct _Elm_View_Form_Promise
 
 
 static void
-_efl_promise_then_widget(Elm_View_Form_Widget *w, Eina_Value *value, Eina_Promise* promise EINA_UNUSED)
+_efl_promise_then_widget(void* data, void* v, Eina_Promise* promise EINA_UNUSED)
 {
+    Elm_View_Form_Widget *w = data;
+    Eina_Value *value = v;
     w->widget_obj_set_cb(w->widget_obj, value, w->widget_propname);
 }
 
@@ -57,14 +59,16 @@ _efl_promise_error_widget(void *data EINA_UNUSED, Eina_Error err EINA_UNUSED, Ei
 }
 
 static void
-_efl_model_promise_then_cb(Elm_View_Form_Promise *p, Eina_Value *value, Eina_Promise* promise EINA_UNUSED)
+_efl_model_promise_then_cb(void* data, void* v, Eina_Promise* promise EINA_UNUSED)
 {
-   EINA_SAFETY_ON_NULL_RETURN(p);
-
+   Elm_View_Form_Promise *p = data;
+   Eina_Value *value = v;
    Elm_View_Form_Data *priv = p->priv;
    Elm_View_Form_Widget *w = NULL;
    Eina_List *l = NULL;
 
+   EINA_SAFETY_ON_NULL_RETURN(p);
+
    EINA_LIST_FOREACH(priv->widgets, l, w)
      {
         if (!strcmp(w->widget_propname, p->property_name))
@@ -78,8 +82,9 @@ _efl_model_promise_then_cb(Elm_View_Form_Promise *p, Eina_Value *value, Eina_Pro
 }
 
 static void
-_efl_model_promise_error_cb(Elm_View_Form_Promise *p, Eina_Error error EINA_UNUSED, Eina_Promise* promise EINA_UNUSED)
+_efl_model_promise_error_cb(void* data, Eina_Error error EINA_UNUSED, Eina_Promise* promise EINA_UNUSED)
 {
+   Elm_View_Form_Promise *p = data;
    EINA_SAFETY_ON_NULL_RETURN(p);
 
    eina_stringshare_del(p->property_name);
@@ -110,8 +115,8 @@ _efl_model_properties_change_cb(void *data, const Eo_Event *event)
         p->property_name = eina_stringshare_add(prop);
         p->priv = priv;
         efl_model_property_get(priv->model_obj, prop, &promise);
-        eina_promise_then(promise, (Eina_Promise_Cb)&_efl_model_promise_then_cb,
-                    (Eina_Promise_Error_Cb)&_efl_model_promise_error_cb, p);
+        eina_promise_then(promise, &_efl_model_promise_then_cb,
+                          &_efl_model_promise_error_cb, p);
      }
 
    return EINA_TRUE;
@@ -130,7 +135,7 @@ _update_model_properties(Elm_View_Form_Data *priv)
    EINA_LIST_FOREACH(priv->widgets, l, w)
      {
         efl_model_property_get(priv->model_obj, w->widget_propname, &promise);
-        eina_promise_then(promise, (Eina_Promise_Cb)&_efl_promise_then_widget, &_efl_promise_error_widget, w);
+        eina_promise_then(promise, &_efl_promise_then_widget, &_efl_promise_error_widget, w);
      }
 }
 
@@ -239,8 +244,8 @@ _elm_view_widget_add(Elm_View_Form_Data *priv, const char *propname, Evas_Object
    if (priv->model_obj != NULL)
      {
          efl_model_property_get(priv->model_obj, w->widget_propname, &promise);
-         eina_promise_then(promise, (Eina_Promise_Cb)&_efl_promise_then_widget,
-                         &_efl_promise_error_widget, priv);
+         eina_promise_then(promise, &_efl_promise_then_widget,
+                           &_efl_promise_error_widget, priv);
      }
    return EINA_TRUE;
 }
diff --git a/src/lib/elementary/elm_view_list.c b/src/lib/elementary/elm_view_list.c
index 0b2bd8f2c2..33363f8cda 100644
--- a/src/lib/elementary/elm_view_list.c
+++ b/src/lib/elementary/elm_view_list.c
@@ -93,8 +93,10 @@ _item_del(void *data, Evas_Object *obj EINA_UNUSED)
 }
 
 static void
-_property_get_cb(View_List_ValueItem *vitem, Eina_Value *value)
+_property_get_cb(void* data, void* v, Eina_Promise* promise EINA_UNUSED)
 {
+    View_List_ValueItem *vitem = data;
+    Eina_Value *value = v;
     vitem->value = eina_value_new(eina_value_type_get(value));
     eina_value_copy(value, vitem->value);
 
@@ -103,8 +105,9 @@ _property_get_cb(View_List_ValueItem *vitem, Eina_Value *value)
 }
 
 static void
-_property_get_error_cb(View_List_ValueItem *vitem, const Eina_Error *err EINA_UNUSED)
+_property_get_error_cb(void* data, Eina_Error err EINA_UNUSED, Eina_Promise* promise EINA_UNUSED)
 {
+    View_List_ValueItem *vitem = data;
     eina_stringshare_del(vitem->part);
 }
 
@@ -150,8 +153,8 @@ _item_get_value(View_List_ItemData *idata, const char *part)
          vitem->item = idata->item;
          idata->values = eina_list_append(idata->values, vitem);
          efl_model_property_get(idata->model, prop, &promise);
-         eina_promise_then(promise, (Eina_Promise_Cb)&_property_get_cb,
-                         (Eina_Promise_Error_Cb)&_property_get_error_cb, vitem);
+         eina_promise_then(promise, &_property_get_cb,
+                           &_property_get_error_cb, vitem);
      }
    else
      {
@@ -302,17 +305,19 @@ _efl_model_properties_change_cb(void *data, const Eo_Event *event)
 }
 
 static void
-_efl_model_load_children_then(View_List_ItemData *pdata, Eina_Accessor **accessor)
+_efl_model_load_children_then(void * data, void* value, Eina_Promise* promise EINA_UNUSED)
 {
+   View_List_ItemData *pdata = data;
+   Eina_Accessor *accessor = value;
    Eo *child;
    unsigned i = 0;
    EINA_SAFETY_ON_NULL_RETURN(pdata);
    EINA_SAFETY_ON_NULL_RETURN(pdata->priv);
-   EINA_SAFETY_ON_NULL_RETURN(*accessor);
+   EINA_SAFETY_ON_NULL_RETURN(accessor);
 
    Elm_View_List_Data *priv = pdata->priv;
 
-   EINA_ACCESSOR_FOREACH(*accessor, i, child)
+   EINA_ACCESSOR_FOREACH(accessor, i, child)
      {
         View_List_ItemData *idata = calloc(1, sizeof(View_List_ItemData));
         EINA_SAFETY_ON_NULL_RETURN(idata);
@@ -335,7 +340,7 @@ _efl_model_load_children(View_List_ItemData *pdata)
    Eina_Promise *promise;
 
    efl_model_children_slice_get(pdata->model, 0, 0, &promise);
-   eina_promise_then(promise, (Eina_Promise_Cb)&_efl_model_load_children_then, NULL, pdata);
+   eina_promise_then(promise, &_efl_model_load_children_then, NULL, pdata);
 }
 
 static Eina_Bool
diff --git a/src/tests/ecore/ecore_test_job.c b/src/tests/ecore/ecore_test_job.c
index 47257104f6..60eebdef86 100644
--- a/src/tests/ecore/ecore_test_job.c
+++ b/src/tests/ecore/ecore_test_job.c
@@ -10,7 +10,7 @@ _ecore_promise_quit(void *data, void *value, Eina_Promise* promise EINA_UNUSED)
 {
    Eina_Bool *bob = data;
 
-   fail_if(data != *(Eina_Bool**)value);
+   fail_if(data != value);
    *bob = EINA_TRUE;
    ecore_main_loop_quit();
 }
@@ -18,12 +18,10 @@ _ecore_promise_quit(void *data, void *value, Eina_Promise* promise EINA_UNUSED)
 START_TEST(ecore_test_job_promise)
 {
    Eina_Bool bob = EINA_FALSE;
-   Eina_Promise *job = NULL;
 
    ecore_init();
 
-   job = efl_loop_job(ecore_main_loop_get(), &bob);
-   eina_promise_then(job, &_ecore_promise_quit, NULL, &bob);
+   eina_promise_then(efl_loop_job(ecore_main_loop_get(), &bob), &_ecore_promise_quit, NULL, &bob);
 
    ecore_main_loop_begin();
 
diff --git a/src/tests/ecore/ecore_test_promise.c b/src/tests/ecore/ecore_test_promise.c
index decd5c9588..f016580360 100644
--- a/src/tests/ecore/ecore_test_promise.c
+++ b/src/tests/ecore/ecore_test_promise.c
@@ -22,7 +22,7 @@ START_TEST(ecore_test_promise)
 
    ecore_init();
 
-   ecore_thread_promise_run(&promised_thread, NULL, NULL, 0, &promise);
+   ecore_thread_promise_run(&promised_thread, NULL, NULL, &promise);
    eina_promise_then(promise, &promise_callback, NULL, NULL);
 
    ecore_main_loop_begin();
@@ -48,7 +48,7 @@ START_TEST(ecore_test_promise_error)
 
    ecore_init();
 
-   ecore_thread_promise_run(&promise_error_thread, NULL, NULL, 0, &promise);
+   ecore_thread_promise_run(&promise_error_thread, NULL, NULL, &promise);
    eina_promise_then(promise, NULL, &promise_error_callback, NULL);
 
    ecore_main_loop_begin();
@@ -64,7 +64,7 @@ START_TEST(ecore_test_promise_all)
 
    ecore_init();
 
-   ecore_thread_promise_run(&promised_thread, NULL, NULL, 0, &first[0]);
+   ecore_thread_promise_run(&promised_thread, NULL, NULL, &first[0]);
    promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
    eina_promise_then(promise, &promise_callback, NULL, NULL);
 
@@ -89,7 +89,7 @@ START_TEST(ecore_test_promise_all_then_then)
 
    int i = 0;
 
-   ecore_thread_promise_run(&promised_thread, NULL, NULL, 0, &first[0]);
+   ecore_thread_promise_run(&promised_thread, NULL, NULL, &first[0]);
    eina_promise_then(first[0], &promise_callback2, NULL, &i);
    promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
    eina_promise_then(promise, &promise_callback2, NULL, &i);
@@ -126,7 +126,7 @@ static void _ecore_test_promise_then_after_thread_finished_main_cb()
    eina_lock_new(&data.lock);
    eina_condition_new(&data.cond, &data.lock);
 
-   thread = ecore_thread_promise_run((Ecore_Thread_Promise_Cb)&promised_exit_thread, NULL, &data, 0, &promise);
+   thread = ecore_thread_promise_run((Ecore_Thread_Promise_Cb)&promised_exit_thread, NULL, &data, &promise);
 
    eina_lock_take(&data.lock);
    while(!data.var)
@@ -161,7 +161,7 @@ static void _ecore_test_promise_then_after_thread_finished_all_main_cb()
    eina_lock_new(&data.lock);
    eina_condition_new(&data.cond, &data.lock);
 
-   thread = ecore_thread_promise_run((Ecore_Thread_Promise_Cb)&promised_exit_thread, NULL, &data, 0, &first[0]);
+   thread = ecore_thread_promise_run((Ecore_Thread_Promise_Cb)&promised_exit_thread, NULL, &data, &first[0]);
    promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
 
    eina_lock_take(&data.lock);
@@ -186,19 +186,19 @@ START_TEST(ecore_test_promise_then_after_thread_finished_all)
 }
 END_TEST
 
-void promised_block_thread(const void* data EINA_UNUSED, Eina_Promise_Owner* promise, Ecore_Thread* thread EINA_UNUSED)
-{
-   struct timespec v = {.tv_sec = 1, .tv_nsec = 0}, rem;
-   if(nanosleep(&v, &rem) == -1 && errno == EINTR)
-     do
-       {
-         v = rem;
-       }
-     while(nanosleep(&v, &rem) == -1 && errno == EINTR);
-
-  int r = 10;
-  eina_promise_owner_value_set(promise, &r, NULL);
-}
+/* void promised_block_thread(const void* data EINA_UNUSED, Eina_Promise_Owner* promise, Ecore_Thread* thread EINA_UNUSED) */
+/* { */
+/*    struct timespec v = {.tv_sec = 1, .tv_nsec = 0}, rem; */
+/*    if(nanosleep(&v, &rem) == -1 && errno == EINTR) */
+/*      do */
+/*        { */
+/*          v = rem; */
+/*        } */
+/*      while(nanosleep(&v, &rem) == -1 && errno == EINTR); */
+
+/*   int r = 10; */
+/*   eina_promise_owner_value_set(promise, &r, NULL); */
+/* } */
 
 static void
 _ecore_test_promise_normal_lifetime_cb(void* data EINA_UNUSED, void* value EINA_UNUSED, Eina_Promise* promise EINA_UNUSED)
@@ -219,7 +219,7 @@ START_TEST(ecore_test_promise_normal_lifetime)
    
    ecore_init();
 
-   promise_owner = eina_promise_default_add(0);
+   promise_owner = eina_promise_value_add(0);
 
    promise = eina_promise_owner_promise_get(promise_owner);
 
@@ -240,7 +240,7 @@ START_TEST(ecore_test_promise_normal_lifetime_all)
    
    ecore_init();
 
-   promise_owner = eina_promise_default_add(0);
+   promise_owner = eina_promise_value_add(0);
    first[0] = eina_promise_owner_promise_get(promise_owner);
    promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
    
@@ -266,7 +266,7 @@ START_TEST(ecore_test_promise_immediate_set_lifetime)
    
    ecore_init();
 
-   owner = eina_promise_default_add(0);
+   owner = eina_promise_value_add(0);
    promise = eina_promise_owner_promise_get(owner);
 
    eina_promise_owner_value_set(owner, NULL, NULL);
@@ -286,7 +286,7 @@ START_TEST(ecore_test_promise_immediate_set_lifetime_all)
 
    ecore_init();
 
-   owner = eina_promise_default_add(0);
+   owner = eina_promise_value_add(0);
    first[0] = eina_promise_owner_promise_get(owner);
    promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
 
@@ -343,7 +343,7 @@ START_TEST(ecore_test_promise_cancel_promise)
    eina_lock_new(&v.lock);
    eina_condition_new(&v.condvar, &v.lock);
 
-   ecore_thread_promise_run(&promise_cancel_thread, &_cancel_callback, &v, 0, &promise);
+   ecore_thread_promise_run(&promise_cancel_thread, &_cancel_callback, &v, &promise);
    eina_promise_then(promise, NULL, &_cancel_promise_callback, NULL);
 
    eina_promise_cancel(promise);
@@ -376,7 +376,7 @@ START_TEST(ecore_test_promise_progress_promise)
 
    ecore_init();
 
-   ecore_thread_promise_run(&promise_progress_thread, NULL, NULL, 0, &promise);
+   ecore_thread_promise_run(&promise_progress_thread, NULL, NULL, &promise);
 
    eina_promise_progress_cb_add(promise, &_progress_callback, NULL, NULL);
 
diff --git a/src/tests/ecore/ecore_test_timer.c b/src/tests/ecore/ecore_test_timer.c
index 2e07b5347b..d073d5d05b 100644
--- a/src/tests/ecore/ecore_test_timer.c
+++ b/src/tests/ecore/ecore_test_timer.c
@@ -179,7 +179,7 @@ static void
 _ecore_promise_quit(void *data, void *value, Eina_Promise* promise EINA_UNUSED)
 {
    Eina_Bool *bob = data;
-   double *start = *(double**)value;
+   double *start = value;
    double delta = ecore_loop_time_get() - *start;
 
    fail_if(delta - 0.2 > 0.01);
diff --git a/src/tests/eina/eina_test_promise.c b/src/tests/eina/eina_test_promise.c
index f8b355bf33..7c6d33af1b 100644
--- a/src/tests/eina/eina_test_promise.c
+++ b/src/tests/eina/eina_test_promise.c
@@ -45,7 +45,7 @@ START_TEST(eina_test_promise_normal_lifetime)
 
    eina_init();
 
-   promise_owner = eina_promise_default_add(0);
+   promise_owner = eina_promise_value_add(0);
 
    promise = eina_promise_owner_promise_get(promise_owner);
 
@@ -67,7 +67,7 @@ START_TEST(eina_test_promise_normal_lifetime_all)
 
    eina_init();
 
-   promise_owner = eina_promise_default_add(0);
+   promise_owner = eina_promise_value_add(0);
    first[0] = eina_promise_owner_promise_get(promise_owner);
    promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
 
@@ -88,7 +88,7 @@ START_TEST(eina_test_promise_immediate_set_lifetime)
 
    eina_init();
 
-   owner = eina_promise_default_add(0);
+   owner = eina_promise_value_add(0);
    promise = eina_promise_owner_promise_get(owner);
 
    eina_promise_owner_value_set(owner, NULL, NULL);
@@ -109,7 +109,7 @@ START_TEST(eina_test_promise_immediate_set_lifetime_all)
 
    eina_init();
 
-   owner = eina_promise_default_add(0);
+   owner = eina_promise_value_add(0);
    first[0] = eina_promise_owner_promise_get(owner);
    promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
 
@@ -124,14 +124,14 @@ END_TEST
 
 static void _eina_test_promise_value_all_cb(void* data, void* value, Eina_Promise* promise EINA_UNUSED)
 {
-  Eina_Iterator** iterator = value;
+  Eina_Iterator* iterator = value;
   int *i, *j;
   Eina_Bool b;
 
-  b = eina_iterator_next(*iterator, (void**)&i);
+  b = eina_iterator_next(iterator, (void**)&i);
   ck_assert(!!b);
 
-  b = eina_iterator_next(*iterator, (void**)&j);
+  b = eina_iterator_next(iterator, (void**)&j);
   ck_assert(!!b);
 
   ck_assert(i != NULL);
@@ -153,8 +153,8 @@ START_TEST(eina_test_promise_values_all)
 
    int i = 10, j = 15;
 
-   owners[0] = eina_promise_default_add(sizeof(int));
-   owners[1] = eina_promise_default_add(sizeof(int));
+   owners[0] = eina_promise_value_add(sizeof(int));
+   owners[1] = eina_promise_value_add(sizeof(int));
    
    promises[0] = eina_promise_owner_promise_get(owners[0]);
    promises[1] = eina_promise_owner_promise_get(owners[1]);
@@ -191,7 +191,7 @@ START_TEST(eina_test_promise_cancel_promise)
 
    eina_init();
 
-   owner = eina_promise_default_add(0);
+   owner = eina_promise_value_add(0);
    eina_promise_owner_default_cancel_cb_add(owner, &cancel_callback, &cancel_ran, NULL);
 
    promise = eina_promise_owner_promise_get(owner);
@@ -222,7 +222,7 @@ START_TEST(eina_test_promise_progress)
 
    eina_init();
 
-   owner = eina_promise_default_add(0);
+   owner = eina_promise_value_add(0);
 
    promise = eina_promise_owner_promise_get(owner);
    eina_promise_progress_cb_add(promise, &progress_callback, &progress_ran, NULL);
@@ -249,7 +249,7 @@ START_TEST(eina_test_promise_progress_notify1)
 
    eina_init();
 
-   owner = eina_promise_default_add(0);
+   owner = eina_promise_value_add(0);
    eina_promise_owner_progress_notify(owner, &progress_notify, &progress_notify_ran, NULL);
 
    promise = eina_promise_owner_promise_get(owner);
@@ -270,7 +270,7 @@ START_TEST(eina_test_promise_progress_notify2)
 
    eina_init();
 
-   owner = eina_promise_default_add(0);
+   owner = eina_promise_value_add(0);
    eina_promise_owner_progress_notify(owner, &progress_notify, &progress_notify_ran, NULL);
 
    promise = eina_promise_owner_promise_get(owner);
@@ -304,7 +304,7 @@ START_TEST(eina_test_promise_progress_notify3)
 
    eina_init();
 
-   owner = eina_promise_default_add(0);
+   owner = eina_promise_value_add(0);
    promise_progress = eina_promise_progress_notification(owner);
    eina_promise_then(promise_progress, &_eina_promise_progress_notify_fulfilled,
                      &_eina_promise_progress_notify_error, &progress_notify_ran);
@@ -326,7 +326,7 @@ START_TEST(eina_test_promise_ignored)
 
    eina_init();
 
-   owner = eina_promise_default_add(0);
+   owner = eina_promise_value_add(0);
    promise = eina_promise_owner_promise_get(owner);
    eina_promise_unref(promise);
    eina_promise_owner_value_set(owner, NULL, NULL);
@@ -344,7 +344,275 @@ START_TEST(eina_test_promise_race)
 
    eina_init();
 
-   promise_owner = eina_promise_default_add(0);
+   promise_owner = eina_promise_value_add(0);
+   first[0] = eina_promise_owner_promise_get(promise_owner);
+   promise = eina_promise_race(eina_carray_iterator_new((void**)&first[0]));
+
+   eina_promise_then(promise, &_eina_test_promise_cb, NULL, &ran);
+   eina_promise_owner_value_set(promise_owner, NULL, NULL);
+
+   ck_assert(ran == EINA_TRUE);
+
+   eina_shutdown();
+}
+END_TEST
+
+// pointers
+START_TEST(eina_test_pointer_promise_normal_lifetime)
+{
+   Eina_Promise_Owner* promise_owner;
+   Eina_Promise* promise;
+   Eina_Bool ran = EINA_FALSE;
+
+   eina_init();
+
+   promise_owner = eina_promise_add();
+
+   promise = eina_promise_owner_promise_get(promise_owner);
+
+   eina_promise_then(promise, &_eina_test_promise_cb, NULL, &ran);
+   eina_promise_owner_value_set(promise_owner, NULL, NULL);
+
+   ck_assert(ran == EINA_TRUE);
+
+   eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_normal_lifetime_all)
+{
+   Eina_Promise_Owner* promise_owner;
+   Eina_Promise* first[2] = {NULL, NULL};
+   Eina_Promise* promise;
+   Eina_Bool ran = EINA_FALSE;
+
+   eina_init();
+
+   promise_owner = eina_promise_add();
+   first[0] = eina_promise_owner_promise_get(promise_owner);
+   promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
+
+   eina_promise_then(promise, &_eina_test_promise_cb, NULL, &ran);
+   eina_promise_owner_value_set(promise_owner, NULL, NULL);
+
+   ck_assert(ran == EINA_TRUE);
+
+   eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_immediate_set_lifetime)
+{
+   Eina_Promise_Owner* owner;
+   Eina_Promise* promise;
+   Eina_Bool ran = EINA_FALSE;
+
+   eina_init();
+
+   owner = eina_promise_add();
+   promise = eina_promise_owner_promise_get(owner);
+
+   eina_promise_owner_value_set(owner, NULL, NULL);
+   eina_promise_then(promise, &_eina_test_promise_cb, NULL, &ran);
+
+   ck_assert(ran == EINA_TRUE);
+
+   eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_immediate_set_lifetime_all)
+{
+   Eina_Promise_Owner* owner;
+   Eina_Promise* first[2] = {NULL, NULL};
+   Eina_Promise* promise;
+   Eina_Bool ran = EINA_FALSE;
+
+   eina_init();
+
+   owner = eina_promise_add();
+   first[0] = eina_promise_owner_promise_get(owner);
+   promise = eina_promise_all(eina_carray_iterator_new((void**)&first[0]));
+
+   eina_promise_owner_value_set(owner, NULL, NULL);
+   eina_promise_then(promise, &_eina_test_promise_cb, NULL, &ran);
+
+   ck_assert(ran == EINA_TRUE);
+
+   eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_values_all)
+{
+   Eina_Promise_Owner* owners[2];
+   Eina_Promise* promises[3] = {NULL, NULL, NULL};
+   Eina_Promise* promise_all;
+   Eina_Bool ran = EINA_FALSE;
+
+   eina_init();
+
+   int* i = malloc(sizeof(int)), *j = malloc(sizeof(int));
+   *i = 10;
+   *j = 15;
+
+   owners[0] = eina_promise_add();
+   owners[1] = eina_promise_add();
+   
+   promises[0] = eina_promise_owner_promise_get(owners[0]);
+   promises[1] = eina_promise_owner_promise_get(owners[1]);
+
+   
+   promise_all = eina_promise_all(eina_carray_iterator_new((void**)&promises[0]));
+
+   eina_promise_owner_value_set(owners[0], i, free);
+   eina_promise_owner_value_set(owners[1], j, free);
+
+   eina_promise_then(promise_all, &_eina_test_promise_value_all_cb, NULL, &ran);
+
+   ck_assert(ran == EINA_TRUE);
+
+   eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_cancel_promise)
+{
+   Eina_Bool ran = EINA_FALSE, cancel_ran = EINA_FALSE;
+   Eina_Promise_Owner* owner;
+   Eina_Promise* promise;
+
+   eina_init();
+
+   owner = eina_promise_add();
+   eina_promise_owner_default_cancel_cb_add(owner, &cancel_callback, &cancel_ran, NULL);
+
+   promise = eina_promise_owner_promise_get(owner);
+
+   eina_promise_then(promise, NULL, &_cancel_promise_callback, &ran);
+
+   eina_promise_cancel(promise);
+
+   ck_assert(cancel_ran && ran);
+
+   eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_progress)
+{
+   Eina_Bool progress_ran = EINA_FALSE;
+   Eina_Promise_Owner* owner;
+   Eina_Promise* promise;
+   int i = 1;
+
+   eina_init();
+
+   owner = eina_promise_add();
+
+   promise = eina_promise_owner_promise_get(owner);
+   eina_promise_progress_cb_add(promise, &progress_callback, &progress_ran, NULL);
+
+   eina_promise_owner_progress(owner, &i);
+
+   ck_assert(progress_ran);
+
+   eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_progress_notify1)
+{
+   Eina_Bool progress_notify_ran = EINA_FALSE;
+   Eina_Promise_Owner* owner;
+   Eina_Promise* promise;
+
+   eina_init();
+
+   owner = eina_promise_add();
+   eina_promise_owner_progress_notify(owner, &progress_notify, &progress_notify_ran, NULL);
+
+   promise = eina_promise_owner_promise_get(owner);
+   eina_promise_progress_cb_add(promise, &progress_callback, NULL, NULL); // never run
+   eina_promise_progress_cb_add(promise, &progress_callback, NULL, NULL); // never run
+
+   ck_assert(progress_notify_ran);
+
+   eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_progress_notify2)
+{
+   Eina_Bool progress_notify_ran = EINA_FALSE;
+   Eina_Promise_Owner* owner;
+   Eina_Promise* promise;
+
+   eina_init();
+
+   owner = eina_promise_add();
+   eina_promise_owner_progress_notify(owner, &progress_notify, &progress_notify_ran, NULL);
+
+   promise = eina_promise_owner_promise_get(owner);
+   eina_promise_then(promise, NULL, &_cancel_promise_callback, NULL); // never run
+   eina_promise_then(promise, NULL, &_cancel_promise_callback, NULL); // never run
+
+   ck_assert(progress_notify_ran);
+
+   eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_progress_notify3)
+{
+   Eina_Bool progress_notify_ran = EINA_FALSE;
+   Eina_Promise_Owner* owner;
+   Eina_Promise* promise;
+   Eina_Promise* promise_progress;
+
+   eina_init();
+
+   owner = eina_promise_add();
+   promise_progress = eina_promise_progress_notification(owner);
+   eina_promise_then(promise_progress, &_eina_promise_progress_notify_fulfilled,
+                     &_eina_promise_progress_notify_error, &progress_notify_ran);
+
+   promise = eina_promise_owner_promise_get(owner);
+   eina_promise_progress_cb_add(promise, &progress_callback, NULL, NULL); // never run
+   eina_promise_progress_cb_add(promise, &progress_callback, NULL, NULL); // never run
+
+   ck_assert(progress_notify_ran);
+
+   eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_ignored)
+{
+   Eina_Promise_Owner* owner;
+   Eina_Promise* promise;
+
+   eina_init();
+
+   owner = eina_promise_add();
+   promise = eina_promise_owner_promise_get(owner);
+   eina_promise_unref(promise);
+   eina_promise_owner_value_set(owner, NULL, NULL);
+
+   eina_shutdown();
+}
+END_TEST
+
+START_TEST(eina_test_pointer_promise_race)
+{
+   Eina_Promise_Owner* promise_owner;
+   Eina_Promise* first[2] = {NULL, NULL};
+   Eina_Promise* promise;
+   Eina_Bool ran = EINA_FALSE;
+
+   eina_init();
+
+   promise_owner = eina_promise_add();
    first[0] = eina_promise_owner_promise_get(promise_owner);
    promise = eina_promise_race(eina_carray_iterator_new((void**)&first[0]));
 
@@ -372,4 +640,17 @@ eina_test_promise(TCase *tc)
    tcase_add_test(tc, eina_test_promise_progress_notify3);
    tcase_add_test(tc, eina_test_promise_ignored);
    tcase_add_test(tc, eina_test_promise_race);
+   // pointer
+   tcase_add_test(tc, eina_test_pointer_promise_normal_lifetime);
+   tcase_add_test(tc, eina_test_pointer_promise_normal_lifetime_all);
+   tcase_add_test(tc, eina_test_pointer_promise_immediate_set_lifetime);
+   tcase_add_test(tc, eina_test_pointer_promise_immediate_set_lifetime_all);
+   tcase_add_test(tc, eina_test_pointer_promise_values_all);
+   tcase_add_test(tc, eina_test_pointer_promise_cancel_promise);
+   tcase_add_test(tc, eina_test_pointer_promise_progress);
+   tcase_add_test(tc, eina_test_pointer_promise_progress_notify1);
+   tcase_add_test(tc, eina_test_pointer_promise_progress_notify2);
+   tcase_add_test(tc, eina_test_pointer_promise_progress_notify3);
+   tcase_add_test(tc, eina_test_pointer_promise_ignored);
+   tcase_add_test(tc, eina_test_pointer_promise_race);
 }
diff --git a/src/tests/eio/eio_test_job.c b/src/tests/eio/eio_test_job.c
index 9ef8ced03c..7c9a007216 100644
--- a/src/tests/eio/eio_test_job.c
+++ b/src/tests/eio/eio_test_job.c
@@ -62,7 +62,7 @@ _main_cb(void *data, const char *file, Eina_Promise* promise EINA_UNUSED)
 }
 
 static void
-_done_cb(void *data, Eio_File *handler EINA_UNUSED, Eina_Promise* promise EINA_UNUSED)
+_done_cb(void *data, void* value EINA_UNUSED, Eina_Promise* promise EINA_UNUSED)
 {
    int *number_of_listed_files = (int *)data;
    fail_if((*number_of_listed_files) != test_count);
@@ -79,19 +79,20 @@ _error_cb(void *data EINA_UNUSED, Eina_Error error, Eina_Promise* promise EINA_U
 }
 
 static void
-_open_done_cb(void *data, Eina_File **file, Eina_Promise* promise)
+_open_done_cb(void *data, void *file_value, Eina_Promise* promise EINA_UNUSED)
 {
    Eina_Bool *opened = (Eina_Bool *)data;
    *opened = EINA_TRUE;
-   eina_promise_release_value_ownership(promise);
-   eina_file_close(*file);
+   Eina_File* file = eina_file_dup(file_value);
+   eina_file_close(file);
    ecore_main_loop_quit();
 }
 
 static void
-_stat_done_cb(void *data, const Eina_Stat *stat, Eina_Promise* promise EINA_UNUSED)
+_stat_done_cb(void *data, void *value, Eina_Promise* promise EINA_UNUSED)
 {
-   Eina_Bool *is_dir = (Eina_Bool *)data;
+   Eina_Stat const* stat = value;
+   Eina_Bool *is_dir = data;
    unsigned int rights;
    fail_if(eio_file_is_dir(stat) != *is_dir);
    fail_if(eio_file_is_lnk(stat));
@@ -119,10 +120,7 @@ _do_ls_test(Eio_Job_Test_Stat_Ls_Func ls_func,
    promise = ls_func(job, test_dirname);
    test_count = expected_test_count;
    eina_promise_progress_cb_add(promise, progress_cb, &main_files, NULL);
-   eina_promise_then(promise,
-         (Eina_Promise_Cb)&_done_cb,
-         (Eina_Promise_Error_Cb)&_error_cb,
-         &main_files);
+   eina_promise_then(promise, &_done_cb, &_error_cb, &main_files);
 
    ecore_main_loop_begin();
 
@@ -137,11 +135,11 @@ _do_direct_ls_test(Eio_Job_Test_Stat_Ls_Func ls_func,
       const char *test_dirname)
 {
    _do_ls_test(ls_func,
-         EIO_JOB_EVENT_FILTER_DIRECT,
-                  (Eo_Event_Cb)&_filter_direct_cb,
-         (Eina_Promise_Progress_Cb)&_main_direct_cb,
-         expected_test_count,
-         test_dirname);
+               EIO_JOB_EVENT_FILTER_DIRECT,
+               (Eo_Event_Cb)&_filter_direct_cb,
+               (Eina_Promise_Progress_Cb)&_main_direct_cb,
+               expected_test_count,
+               test_dirname);
 }
 
 START_TEST(eio_job_test_file_direct_stat)
@@ -168,12 +166,12 @@ START_TEST(eio_job_test_file_direct_stat)
    is_dir = EINA_TRUE;
 
    promise = eio_job_file_direct_stat(job, nested_dirname);
-   eina_promise_then(promise, (Eina_Promise_Cb)&_stat_done_cb, (Eina_Promise_Error_Cb)&_error_cb, &is_dir);
+   eina_promise_then(promise, &_stat_done_cb, &_error_cb, &is_dir);
    ecore_main_loop_begin();
 
    is_dir = EINA_FALSE;
    promise = eio_job_file_direct_stat(job, nested_filename);
-   eina_promise_then(promise, (Eina_Promise_Cb)&_stat_done_cb, (Eina_Promise_Error_Cb)&_error_cb, &is_dir);
+   eina_promise_then(promise, &_stat_done_cb, &_error_cb, &is_dir);
    ecore_main_loop_begin();
    eo_unref(job);
 
@@ -209,14 +207,12 @@ START_TEST(eio_job_test_ls_funcs)
 
    // Start testing
 
-   fprintf(stderr, __FILE__ ":%d %s\n", __LINE__, __func__); fflush(stderr);
    _do_ls_test(&eio_job_file_ls,
          EIO_JOB_EVENT_FILTER_NAME,
          (Eo_Event_Cb)&_filter_cb,
          (Eina_Promise_Progress_Cb)&_main_cb,
          5,
          test_dirname);
-   fprintf(stderr, __FILE__ ":%d %s\n", __LINE__, __func__); fflush(stderr);
 
    _do_direct_ls_test(&eio_job_file_stat_ls, 5, test_dirname);
 
@@ -246,12 +242,12 @@ START_TEST(eio_job_test_open)
 
    ret = ecore_init();
    fail_if(ret < 1);
-   ret = eio_init();
-   fail_if(ret < 1);
    ret = eina_init();
    fail_if(ret < 1);
    ret = ecore_file_init();
    fail_if(ret < 1);
+   ret = eio_init();
+   fail_if(ret < 1);
 
    Eina_Tmpstr *test_dirname = get_eio_test_file_tmp_dir();
    Eina_Tmpstr *nested_dirname = create_test_dirs(test_dirname);
@@ -262,7 +258,7 @@ START_TEST(eio_job_test_open)
    Eina_Promise *promise = NULL;
 
    promise = eio_job_file_open(job, nested_filename, EINA_FALSE);
-   eina_promise_then(promise, (Eina_Promise_Cb)&_open_done_cb, (Eina_Promise_Error_Cb)&_error_cb, &opened_file);
+   eina_promise_then(promise, &_open_done_cb, &_error_cb, &opened_file);
    ecore_main_loop_begin();
    eo_unref(job);
    fail_if(!opened_file);
@@ -272,10 +268,11 @@ START_TEST(eio_job_test_open)
 
    eina_tmpstr_del(nested_dirname);
    eina_tmpstr_del(test_dirname);
+   
+   eio_shutdown();
    eina_tmpstr_del(nested_filename);
    ecore_file_shutdown();
    eina_shutdown();
-   eio_shutdown();
    ecore_shutdown();
 }
 END_TEST
diff --git a/src/tests/eldbus/eldbus_test_eldbus_model.c b/src/tests/eldbus/eldbus_test_eldbus_model.c
index 68398ca11f..8dd1c07aa2 100644
--- a/src/tests/eldbus/eldbus_test_eldbus_model.c
+++ b/src/tests/eldbus/eldbus_test_eldbus_model.c
@@ -15,21 +15,23 @@
 #include "eldbus_suite.h"
 
 static void
-_promise_then_quit_cb(void **data , void **value, Eina_Promise* promise EINA_UNUSED)
+_promise_then_quit_cb(void *data , void *value, Eina_Promise* promise EINA_UNUSED)
 {
-   *data = *value;
+   *(void**)data = value;
    ecore_main_loop_quit();
 }
 
 static void
-_promise_then_quit_u_cb(unsigned *data , unsigned *value, Eina_Promise* promise EINA_UNUSED)
+_promise_then_quit_u_cb(void *data , void *value, Eina_Promise* promise EINA_UNUSED)
 {
-   *data = *value;
+   unsigned *lhs = data;
+   unsigned *rhs = value;
+   *lhs = *rhs;
    ecore_main_loop_quit();
 }
 
 static void
-_promise_then_cp(Eina_Value *data , void *value, Eina_Promise* promise EINA_UNUSED)
+_promise_then_cp(void *data , void *value, Eina_Promise* promise EINA_UNUSED)
 {
    eina_value_copy(value, data);
    ecore_main_loop_quit();
@@ -73,7 +75,7 @@ void *
 efl_model_promise_then(Eina_Promise *promise)
 {
    void *data = NULL;
-   eina_promise_then(promise, (Eina_Promise_Cb)&_promise_then_quit_cb, &_error_then_cb, &data);
+   eina_promise_then(promise, &_promise_then_quit_cb, &_error_then_cb, &data);
    ecore_main_loop_begin();
    return data;
 }
@@ -89,7 +91,7 @@ int
 efl_model_promise_then_u(Eina_Promise *promise)
 {
    unsigned i = 0;
-   eina_promise_then(promise, (Eina_Promise_Cb)&_promise_then_quit_u_cb, &_error_then_cb, &i);
+   eina_promise_then(promise, &_promise_then_quit_u_cb, &_error_then_cb, &i);
    ecore_main_loop_begin();
    return i;
 }
@@ -407,7 +409,7 @@ check_efl_model_property_int_eq(Efl_Model *efl_model, const char *property, int
    efl_model_property_get(efl_model, property, &promise);
    ck_assert_ptr_ne(NULL, promise);
 
-   eina_promise_then(promise, (Eina_Promise_Cb)&_promise_then_cp, &_error_then_cb, &property_value);
+   eina_promise_then(promise, &_promise_then_cp, &_error_then_cb, &property_value);
    ecore_main_loop_begin();
 
    const Eina_Value_Type *property_type = eina_value_type_get(&property_value);
@@ -429,7 +431,7 @@ check_efl_model_property_int_set(Efl_Model *efl_model, const char *property, int
    eina_value_set(&eina_value, value);
    efl_model_property_set(efl_model, property, &eina_value, &promise);
 
-   eina_promise_then(promise, (Eina_Promise_Cb)&_promise_then_cp, &_error_then_cb, &value_ret);
+   eina_promise_then(promise, &_promise_then_cp, &_error_then_cb, &value_ret);
    ecore_main_loop_begin();
 
    const Eina_Value_Type *property_type = eina_value_type_get(&value_ret);