efl: Update Efl.Model to use new Efl_Promise and Efl_Future

Replaced all Eina_Promise_Owner and Eina_Promise with Efl_Promise and
Efl_Future.

15 files changed, 386 insertions, 349 deletions

diff --git a/src/lib/efl/interfaces/efl_model.eo b/src/lib/efl/interfaces/efl_model.eo
index 2799728548..688e92761d 100644
--- a/src/lib/efl/interfaces/efl_model.eo
+++ b/src/lib/efl/interfaces/efl_model.eo
@@ -46,8 +46,8 @@ interface Efl.Model ()
            params {
                @in property: string; [[Property name]]
                @in value: const(generic_value)*; [[New value]]
-               @inout promise: promise<generic_value>; [[Promise returning the recorded value or error]]
            }
+           return: future<generic_value>; [[Future returning the recorded value or error]]
         }
         property_get {
            [[Retrieve the value of a given property name.
@@ -63,7 +63,7 @@ interface Efl.Model ()
            params {
                @in property: string; [[Property name]]
            }
-           return: promise<generic_value>; [[Promise of the value that was got]]
+           return: future<generic_value>; [[Future of the value that was got]]
         }
         children_slice_get {
                [[Get children slice OR full range.
@@ -97,7 +97,7 @@ interface Efl.Model ()
                 @in count: uint; [[Range size. If count and start are 0 slice is
                                ignored.]]
             }
-            return: promise<accessor<Efl.Object> >; [[Promise of the children]]
+            return: future<accessor<Efl.Object> >; [[Future of the children]]
          }
          children_count_get {
                 [[Get children count.
@@ -112,7 +112,7 @@ interface Efl.Model ()
 
                   @since 1.14
                 ]]
-            return: promise<uint>;
+            return: future<uint>;
          }
          child_add {
             [[Add a new child.
diff --git a/src/lib/eio/efl_io_manager.c b/src/lib/eio/efl_io_manager.c
index 1d6d3fbdb2..0740f35896 100644
--- a/src/lib/eio/efl_io_manager.c
+++ b/src/lib/eio/efl_io_manager.c
@@ -43,7 +43,7 @@ struct _Job_Closure
 {
    Eo *object;
    Efl_Io_Manager_Data *pdata;
-   Eina_Promise_Owner *promise;
+   Efl_Promise *promise;
    Eio_File *file;
    Eina_Bool delete_me;
    void *delayed_arg;
@@ -260,7 +260,8 @@ _efl_io_manager_direct_ls(Eo *obj,
    Efl_Promise *p;
    Eio_File *h;
 
-   p = efl_add(EFL_PROMISE_CLASS, obj);
+   Eo *loop = efl_loop_user_loop_get(obj);
+   p = efl_add(EFL_PROMISE_CLASS, loop);
    if (!p) return NULL;
 
    if (!recursive)
@@ -299,7 +300,8 @@ _efl_io_manager_stat_ls(Eo *obj,
    Efl_Promise *p;
    Eio_File *h;
 
-   p = efl_add(EFL_PROMISE_CLASS, obj);
+   Eo *loop = efl_loop_user_loop_get(obj);
+   p = efl_add(EFL_PROMISE_CLASS, loop);
    if (!p) return NULL;
 
    if (!recursive)
@@ -337,7 +339,8 @@ _efl_io_manager_ls(Eo *obj,
    Efl_Promise *p;
    Eio_File *h;
 
-   p = efl_add(EFL_PROMISE_CLASS, obj);
+   Eo *loop = efl_loop_user_loop_get(obj);
+   p = efl_add(EFL_PROMISE_CLASS, loop);
    if (!p) return NULL;
 
    h = _eio_file_ls(path,
@@ -384,7 +387,8 @@ _efl_io_manager_stat(Eo *obj,
    Efl_Promise *p;
    Eio_File *h;
 
-   p = efl_add(EFL_PROMISE_CLASS, obj);
+   Eo *loop = efl_loop_user_loop_get(obj);
+   p = efl_add(EFL_PROMISE_CLASS, loop);
    if (!p) return NULL;
 
    h = eio_file_direct_stat(path,
@@ -411,7 +415,8 @@ _efl_io_manager_xattr_ls(Eo *obj,
    Efl_Promise *p;
    Eio_File *h;
 
-   p = efl_add(EFL_PROMISE_CLASS, obj);
+   Eo *loop = efl_loop_user_loop_get(obj);
+   p = efl_add(EFL_PROMISE_CLASS, loop);
    if (!p) return NULL;
 
    h = _eio_file_xattr(path,
@@ -440,7 +445,8 @@ _efl_io_manager_xattr_set(Eo *obj,
    Efl_Promise *p;
    Eio_File *h;
 
-   p = efl_add(EFL_PROMISE_CLASS, obj);
+   Eo *loop = efl_loop_user_loop_get(obj);
+   p = efl_add(EFL_PROMISE_CLASS, loop);
    if (!p) return NULL;
 
    h = eio_file_xattr_set(path, attribute,
@@ -469,7 +475,8 @@ _efl_io_manager_xattr_get(Eo *obj,
    Efl_Promise *p;
    Eio_File *h;
 
-   p = efl_add(EFL_PROMISE_CLASS, obj);
+   Eo *loop = efl_loop_user_loop_get(obj);
+   p = efl_add(EFL_PROMISE_CLASS, loop);
    if (!p) return NULL;
 
    h = eio_file_xattr_get(path, attribute,
@@ -507,7 +514,8 @@ _efl_io_manager_open(Eo *obj,
    Efl_Promise *p;
    Eio_File *h;
 
-   p = efl_add(EFL_PROMISE_CLASS, obj);
+   Eo *loop = efl_loop_user_loop_get(obj);
+   p = efl_add(EFL_PROMISE_CLASS, loop);
    if (!p) return NULL;
 
    h = eio_file_open(path, shared,
@@ -533,7 +541,8 @@ _efl_io_manager_close(Eo *obj,
    Efl_Promise *p;
    Eio_File *h;
 
-   p = efl_add(EFL_PROMISE_CLASS, obj);
+   Eo *loop = efl_loop_user_loop_get(obj);
+   p = efl_add(EFL_PROMISE_CLASS, loop);
    if (!p) return NULL;
 
    h = eio_file_close(file,
diff --git a/src/lib/eio/eio_model.c b/src/lib/eio/eio_model.c
index 300000be88..56395b7cec 100644
--- a/src/lib/eio/eio_model.c
+++ b/src/lib/eio/eio_model.c
@@ -64,7 +64,7 @@ _eio_stat_done_cb(void *data, Eio_File *handler EINA_UNUSED, const Eina_Stat *st
             break;
           };
 
-        eina_promise_owner_value_set(p->promise, v, (Eina_Promise_Free_Cb)&eina_value_free);
+        efl_promise_value_set(p->promise, v, (Eina_Free_Cb)&eina_value_free);
         free(p);
      }
    eina_list_free(priv->property_promises);
@@ -111,7 +111,7 @@ _eio_error_cb(void *data EINA_UNUSED, Eio_File *handler EINA_UNUSED, int error)
 
         EINA_LIST_FOREACH(priv->property_promises, l, p)
           {
-              eina_promise_owner_error_set(p->promise, EFL_MODEL_ERROR_UNKNOWN);
+              efl_promise_failed_set(p->promise, EFL_MODEL_ERROR_UNKNOWN);
           }
         eina_list_free(priv->property_promises);
         priv->property_promises = NULL;
@@ -289,20 +289,24 @@ _eio_model_efl_model_properties_get(Eo *obj EINA_UNUSED, Eio_Model_Data *_pd)
 /**
  * Property Get
  */
-static Eina_Promise*
+static Efl_Future*
 _eio_model_efl_model_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, const char *property)
 {
    _Eio_Property_Name property_name;
    const char* value = NULL;
-   Eina_Promise_Owner *promise = eina_promise_add();
-   Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
+   Efl_Promise *promise;
+   Efl_Future *future;
+
+   Eo *loop = efl_provider_find(obj, EFL_LOOP_CLASS);
+   promise = efl_add(EFL_PROMISE_CLASS, loop);
+   future = efl_promise_future_get(promise);
    
-   EINA_SAFETY_ON_NULL_RETURN_VAL(priv, rpromise);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(priv, future);
 
    if (property == NULL)
      {
-        eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
-        return rpromise;
+        efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
+        return future;
      }
 
    if(strcmp(_eio_model_prop_names[EIO_MODEL_PROP_FILENAME], property) == 0)
@@ -338,8 +342,8 @@ _eio_model_efl_model_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, con
      property_name = EIO_MODEL_PROP_SIZE;
    else
      {
-        eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
-        return rpromise;
+        efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
+        return future;
      }
 
    switch(property_name)
@@ -350,7 +354,7 @@ _eio_model_efl_model_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, con
        {
           Eina_Value* v = eina_value_new(EINA_VALUE_TYPE_STRING);
           eina_value_set(v, value);
-          eina_promise_owner_value_set(promise, v, (Eina_Promise_Free_Cb)&eina_value_free);
+          efl_promise_value_set(promise, v, (Eina_Free_Cb)&eina_value_free);
        }
        break;
      default:
@@ -365,27 +369,30 @@ _eio_model_efl_model_property_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, con
        }
        break;
      }
-   return rpromise;
+   return future;
 }
 
 /**
  * Property Set
  */
-static void
+static Efl_Future*
 _eio_model_efl_model_property_set(Eo *obj EINA_UNUSED,
                                                 Eio_Model_Data *priv,
                                                 const char * property,
-                                                const Eina_Value *value,
-                                                Eina_Promise_Owner *promise)
+                                  const Eina_Value *value)
 {
    char *dest;
 
-   EINA_SAFETY_ON_NULL_RETURN(property);
+   Eo *loop = efl_provider_find(obj, EFL_LOOP_CLASS);
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, loop);
+   Efl_Future* future = efl_promise_future_get(promise);
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(property, future);
 
    if (strcmp(property, "path") != 0)
      {
-        eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_SUPPORTED);
-        return;
+        efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_SUPPORTED);
+        return future;
      }
 
    eina_value_get(value, &dest);
@@ -395,8 +402,8 @@ _eio_model_efl_model_property_set(Eo *obj EINA_UNUSED,
 
         if (!ecore_file_exists(priv->path))
           {
-             eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
-             return;
+             efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_FOUND);
+             return future;
           }
 
         char* tmp = strdup(priv->path);
@@ -415,21 +422,23 @@ _eio_model_efl_model_property_set(Eo *obj EINA_UNUSED,
         eina_stringshare_replace(&priv->path, dest);
      }
 
-     eina_promise_owner_value_set(promise, &value, NULL);
+   efl_promise_value_set(promise, &value, NULL);
+   return future;
 }
 
 /**
  * Children Count Get
  */
-static Eina_Promise*
+static Efl_Future*
 _eio_model_efl_model_children_count_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv)
 {
-   Eina_Promise_Owner *promise = eina_promise_add();
-   Eina_Promise* rpromise = eina_promise_owner_promise_get(promise);
+   Eo *loop = efl_provider_find(obj, EFL_LOOP_CLASS);
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, loop);
+   Efl_Future* future = efl_promise_future_get(promise);
    unsigned int *c = calloc(sizeof(unsigned int), 1);
    *c = eina_list_count(priv->children_list);
-   eina_promise_owner_value_set(promise, c, free);
-   return rpromise;
+   efl_promise_value_set(promise, c, free);
+   return future;
 }
 
 static void
@@ -524,7 +533,7 @@ _eio_done_children_load_cb(void *data, Eio_File *handler EINA_UNUSED)
    EINA_LIST_FOREACH(priv->children_promises, i, p)
      {
        Eina_Accessor* accessor = efl_model_list_slice(priv->children_list, p->start, p->count);
-       eina_promise_owner_value_set(p->promise, accessor, (Eina_Promise_Free_Cb)&eina_accessor_free);
+       efl_promise_value_set(p->promise, accessor, (Eina_Free_Cb)&eina_accessor_free);
        free(p);
      }
 
@@ -603,20 +612,21 @@ _eio_model_efl_model_child_del(Eo *obj EINA_UNUSED, Eio_Model_Data *priv, Eo *ch
 /**
  * Children Slice Get
  */
-static Eina_Promise*
+static Efl_Future*
 _eio_model_efl_model_children_slice_get(Eo *obj EINA_UNUSED, Eio_Model_Data *priv,
                                              unsigned int start, unsigned int count)
 {
-   Eina_Promise_Owner *promise = eina_promise_add();
-   Eina_Promise* rpromise = eina_promise_owner_promise_get(promise);
+   Eo *loop = efl_provider_find(obj, EFL_LOOP_CLASS);
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, loop);
+   Efl_Future* future = efl_promise_future_get(promise);
    /**
     * children must be already loaded otherwise we do nothing
     * and parameter is set to NULL.
     */
    if (!priv->path)
      {
-        eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_INIT_FAILED);
-        return rpromise;
+        efl_promise_failed_set(promise, EFL_MODEL_ERROR_INIT_FAILED);
+        return future;
      }
 
    if (!(priv->is_listed))
@@ -636,12 +646,12 @@ _eio_model_efl_model_children_slice_get(Eo *obj EINA_UNUSED, Eio_Model_Data *pri
                              _eio_main_children_load_cb, _eio_done_children_load_cb,
                              _eio_error_children_load_cb, priv);
          }
-       return rpromise;
+       return future;
      }
 
    Eina_Accessor* accessor = efl_model_list_slice(priv->children_list, start, count);
-   eina_promise_owner_value_set(promise, accessor, (Eina_Promise_Free_Cb)&eina_accessor_free);
-   return rpromise;
+   efl_promise_value_set(promise, accessor, (Eina_Free_Cb)&eina_accessor_free);
+   return future;
 }
 
 
diff --git a/src/lib/eio/eio_model_private.h b/src/lib/eio/eio_model_private.h
index 0fb40888d0..79442742c3 100644
--- a/src/lib/eio/eio_model_private.h
+++ b/src/lib/eio/eio_model_private.h
@@ -40,7 +40,7 @@ typedef struct _Eio_Property_Promise _Eio_Property_Promise;
 struct _Eio_Property_Promise
 {
   _Eio_Property_Name property;
-  Eina_Promise_Owner* promise;
+  Efl_Promise* promise;
 };
 
 typedef struct _Eio_Children_Slice_Promise _Eio_Children_Slice_Promise;
@@ -48,7 +48,7 @@ struct _Eio_Children_Slice_Promise
 {
   unsigned start;
   unsigned count;
-  Eina_Promise_Owner* promise;
+  Efl_Promise* promise;
 };
 
 typedef struct _Eio_Model_Data _Eio_Model_Data;
diff --git a/src/lib/eldbus/eldbus_model_arguments.c b/src/lib/eldbus/eldbus_model_arguments.c
index f9f7f51c47..6e89db1096 100644
--- a/src/lib/eldbus/eldbus_model_arguments.c
+++ b/src/lib/eldbus/eldbus_model_arguments.c
@@ -113,60 +113,62 @@ _eldbus_model_arguments_properties_load(Eldbus_Model_Arguments_Data *pd)
      }
 }
 
-static void
+static Efl_Future*
 _eldbus_model_arguments_efl_model_property_set(Eo *obj EINA_UNUSED,
                                                     Eldbus_Model_Arguments_Data *pd,
                                                     const char *property,
-                                                    Eina_Value const* value,
-                                                    Eina_Promise_Owner *promise)
+                                               Eina_Value const* value)
 {
    Eina_Value *prop_value;
    Eina_Value *promise_value;
+   Efl_Promise* promise = efl_add(EFL_PROMISE_CLASS, obj);
+   Efl_Future* future = efl_promise_future_get(promise);
 
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, );
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(value, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, );
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, future);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(value, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, future);
    DBG("(%p): property=%s", obj, property);
 
    _eldbus_model_arguments_properties_load(pd);
 
    Eina_Bool ret = _eldbus_model_arguments_is_input_argument(pd, property);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_READ_ONLY, );
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_READ_ONLY, future);
 
    prop_value = eina_hash_find(pd->properties_hash, property);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(prop_value, promise, EFL_MODEL_ERROR_NOT_FOUND, );
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(prop_value, promise, EFL_MODEL_ERROR_NOT_FOUND, future);
 
    eina_value_flush(prop_value);
    eina_value_copy(value, prop_value);
 
    promise_value = eina_value_new(eina_value_type_get(value));
    eina_value_copy(value, promise_value);
-   eina_promise_owner_value_set(promise, promise_value, (Eina_Promise_Free_Cb)&eina_value_free);
+   efl_promise_value_set(promise, promise_value, (Eina_Free_Cb)&eina_value_free);
+   return future;
 }
 
-static Eina_Promise*
+static Efl_Future*
 _eldbus_model_arguments_efl_model_property_get(Eo *obj EINA_UNUSED,
                                                     Eldbus_Model_Arguments_Data *pd,
                                                     const char *property)
 {
-   Eina_Promise_Owner *promise = eina_promise_add();
-   Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, obj);
+   Efl_Future *future = efl_promise_future_get(promise);
    Eina_Value *promise_value;
 
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, rpromise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, future);
    DBG("(%p): property=%s", obj, property);
 
    _eldbus_model_arguments_properties_load(pd);
 
    Eina_Value* value = eina_hash_find(pd->properties_hash, property);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(value, promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(value, promise, EFL_MODEL_ERROR_NOT_FOUND, future);
 
    Eina_Bool ret = _eldbus_model_arguments_is_output_argument(pd, property);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_PERMISSION_DENIED, rpromise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_PERMISSION_DENIED, future);
 
    promise_value = eina_value_new(eina_value_type_get(value));
    eina_value_copy(value, promise_value);
-   eina_promise_owner_value_set(promise, promise_value, (Eina_Promise_Free_Cb)&eina_value_free);
-   return rpromise;
+   efl_promise_value_set(promise, promise_value, (Eina_Free_Cb)&eina_value_free);
+   return future;
 }
 
 static Eo *
@@ -182,26 +184,27 @@ _eldbus_model_arguments_efl_model_child_del(Eo *obj EINA_UNUSED,
 {
 }
 
-static Eina_Promise*
+static Efl_Future*
 _eldbus_model_arguments_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
                                                           Eldbus_Model_Arguments_Data *pd EINA_UNUSED,
                                                           unsigned start EINA_UNUSED,
                                                           unsigned count EINA_UNUSED)
 {
-   Eina_Promise_Owner *promise = eina_promise_add();
-   eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_NOT_SUPPORTED);
-   return eina_promise_owner_promise_get(promise);
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, obj);
+   efl_promise_failed_set(promise, EFL_MODEL_ERROR_NOT_SUPPORTED);
+   return efl_promise_future_get(promise);
 }
 
-static Eina_Promise*
+static Efl_Future*
 _eldbus_model_arguments_efl_model_children_count_get(Eo *obj EINA_UNUSED,
                                                          Eldbus_Model_Arguments_Data *pd EINA_UNUSED)
 {
-   Eina_Promise_Owner *promise = eina_promise_add();
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, obj);
+   Efl_Future* future = efl_promise_future_get(promise);
    unsigned *count = malloc(sizeof(unsigned));
    *count = 0;
-   eina_promise_owner_value_set(promise, count, free);
-   return eina_promise_owner_promise_get(promise);
+   efl_promise_value_set(promise, count, free);
+   return future;
 }
 
 static const char *
diff --git a/src/lib/eldbus/eldbus_model_connection.c b/src/lib/eldbus/eldbus_model_connection.c
index aee061e6af..27ace02e99 100644
--- a/src/lib/eldbus/eldbus_model_connection.c
+++ b/src/lib/eldbus/eldbus_model_connection.c
@@ -80,45 +80,49 @@ _eldbus_model_connection_efl_model_properties_get(Eo *obj EINA_UNUSED,
 }
 
 
-static void
+static Efl_Future*
 _eldbus_model_connection_efl_model_property_set(Eo *obj EINA_UNUSED,
                                              Eldbus_Model_Connection_Data *pd EINA_UNUSED,
                                              const char *property,
-                                             Eina_Value const* value EINA_UNUSED,
-                                             Eina_Promise_Owner *promise)
+                                             Eina_Value const* value EINA_UNUSED)
 {
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise, EFL_MODEL_ERROR_NOT_FOUND, );
-   eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_READ_ONLY);
+   Efl_Promise* promise =  efl_add(EFL_PROMISE_CLASS, obj);
+   Efl_Future* future = efl_promise_future_get(promise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise,
+                                          EFL_MODEL_ERROR_NOT_FOUND, future);
+   efl_promise_failed_set(promise, EFL_MODEL_ERROR_READ_ONLY);
+   return future;
 }
 
-static Eina_Promise*
+static Efl_Future*
 _eldbus_model_connection_efl_model_property_get(Eo *obj EINA_UNUSED,
                                              Eldbus_Model_Connection_Data *pd,
                                              const char *property)
 {
-   Eina_Promise_Owner *promise = eina_promise_add();
-   Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, obj);
+   Efl_Future *future = efl_promise_future_get(promise);
 
    DBG("(%p): property=%s", obj, property);
 
    if (!pd->connection)
      _eldbus_model_connection_connect(pd);
 
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise,
+                                          EFL_MODEL_ERROR_NOT_FOUND, future);
 
    if (pd->unique_name == NULL)
      {
         const char *unique_name;
 
         unique_name = eldbus_connection_unique_name_get(pd->connection);
-        ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(unique_name, promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
+        ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(unique_name, promise, EFL_MODEL_ERROR_NOT_FOUND, future);
         pd->unique_name = strdup(unique_name);
      }
 
    Eina_Value* v = eina_value_new(EINA_VALUE_TYPE_STRING);
    eina_value_set(v, pd->unique_name);
-   eina_promise_owner_value_set(promise, v, (Eina_Promise_Free_Cb)&eina_value_free);
-   return rpromise;
+   efl_promise_value_set(promise, v, (Eina_Free_Cb)&eina_value_free);
+   return future;
 }
 
 static Eo *
@@ -134,19 +138,19 @@ _eldbus_model_connection_efl_model_child_del(Eo *obj EINA_UNUSED,
 {
 }
 
-static Eina_Promise*
+static Efl_Promise*
 _eldbus_model_connection_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
                                                    Eldbus_Model_Connection_Data *pd,
                                                    unsigned int start,
                                                    unsigned int count)
 {
-   Eina_Promise_Owner *promise;
-   Eina_Promise *rpromise;
+   Efl_Promise *promise;
+   Efl_Future *future;
    _Eldbus_Children_Slice_Promise* data;
    Eldbus_Pending *pending;
 
-   promise = eina_promise_add();
-   rpromise = eina_promise_owner_promise_get(promise);
+   promise = efl_add(EFL_PROMISE_CLASS, obj);
+   future = efl_promise_future_get(promise);
 
    if (!pd->connection)
      _eldbus_model_connection_connect(pd);
@@ -154,12 +158,12 @@ _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)&eina_accessor_free);
-        return eina_promise_owner_promise_get(promise);
+        efl_promise_value_set(promise, ac, (Eina_Free_Cb)&eina_accessor_free);
+        return future;
      }
 
    data = calloc(1, sizeof(struct _Eldbus_Children_Slice_Promise));
-   EINA_SAFETY_ON_NULL_RETURN_VAL(data, rpromise);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(data, future);
    data->promise = promise;
    data->start = start;
    data->count = count;
@@ -171,17 +175,17 @@ _eldbus_model_connection_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
         pending = eldbus_names_list(pd->connection, &_eldbus_model_connection_names_list_cb, pd);
         pd->pending_list = eina_list_append(pd->pending_list, pending);
      }
-   return rpromise;
+   return future;
 }
 
-static Eina_Promise*
+static Efl_Future*
 _eldbus_model_connection_efl_model_children_count_get(Eo *obj EINA_UNUSED,
                                                    Eldbus_Model_Connection_Data *pd)
 {
-   Eina_Promise_Owner *promise;
+   Efl_Promise *promise;
    Eldbus_Pending *pending;
 
-   promise = eina_promise_add();
+   promise = efl_add(EFL_PROMISE_CLASS, obj);
    if (!pd->connection)
      _eldbus_model_connection_connect(pd);
 
@@ -189,8 +193,8 @@ _eldbus_model_connection_efl_model_children_count_get(Eo *obj EINA_UNUSED,
      {
         unsigned int *c = calloc(sizeof(unsigned int), 1);
         *c = eina_list_count(pd->children_list);
-        eina_promise_owner_value_set(promise, c, free);
-        return eina_promise_owner_promise_get(promise);
+        efl_promise_value_set(promise, c, free);
+        return efl_promise_future_get(promise);
      }
 
    pd->count_promises = eina_list_prepend(pd->count_promises, promise);
@@ -199,7 +203,7 @@ _eldbus_model_connection_efl_model_children_count_get(Eo *obj EINA_UNUSED,
         pending = eldbus_names_list(pd->connection, &_eldbus_model_connection_names_list_cb, pd);
         pd->pending_list = eina_list_append(pd->pending_list, pending);
      }
-   return eina_promise_owner_promise_get(promise);
+   return efl_promise_future_get(promise);
 }
 
 static const char *
@@ -333,7 +337,7 @@ _eldbus_model_connection_names_list_cb(void *data,
      {
         DBG("(%p): bus = %s", pd->obj, bus);
 
-        Eo *child = efl_add(ELDBUS_MODEL_OBJECT_CLASS, NULL, eldbus_model_object_connection_constructor(efl_added, pd->connection, bus, "/"));
+        Eo *child = efl_add(ELDBUS_MODEL_OBJECT_CLASS, pd->obj, eldbus_model_object_connection_constructor(efl_added, pd->connection, bus, "/"));
 
         pd->children_list = eina_list_append(pd->children_list, child);
      }
@@ -348,17 +352,17 @@ _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)&eina_accessor_free);
+        efl_promise_value_set(p->promise, ac, (Eina_Free_Cb)&eina_accessor_free);
         free(p);
      }
    eina_list_free(pd->children_promises);
 
-   Eina_Promise_Owner *ep;
+   Efl_Promise *ep;
    EINA_LIST_FOREACH(pd->count_promises, i, ep)
      {
        unsigned *c = calloc(sizeof(unsigned), 1);
        *c = eina_list_count(pd->children_list);
-       eina_promise_owner_value_set(ep, c, free);
+       efl_promise_value_set(ep, c, free);
      }
    eina_list_free(pd->count_promises);
 }
diff --git a/src/lib/eldbus/eldbus_model_object.c b/src/lib/eldbus/eldbus_model_object.c
index 2baf940923..a03030b6a5 100644
--- a/src/lib/eldbus/eldbus_model_object.c
+++ b/src/lib/eldbus/eldbus_model_object.c
@@ -113,46 +113,49 @@ _eldbus_model_object_efl_model_properties_get(Eo *obj EINA_UNUSED,
    return pd->properties_array;
 }
 
-static void
+static Efl_Future*
 _eldbus_model_object_efl_model_property_set(Eo *obj EINA_UNUSED,
                                          Eldbus_Model_Object_Data *pd EINA_UNUSED,
                                          const char *property,
-                                         const Eina_Value *value EINA_UNUSED,
-                                         Eina_Promise_Owner *promise)
+                                         const Eina_Value *value EINA_UNUSED)
 {
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise, EFL_MODEL_ERROR_NOT_FOUND, );
-   eina_promise_owner_error_set(promise, EFL_MODEL_ERROR_READ_ONLY);
+   Efl_Promise* promise = efl_add(EFL_PROMISE_CLASS, obj);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise,
+                                          EFL_MODEL_ERROR_NOT_FOUND, efl_promise_future_get(promise));
+   efl_promise_failed_set(promise, EFL_MODEL_ERROR_READ_ONLY);
+   return efl_promise_future_get(promise);
 }
 
-static Eina_Promise*
+static Efl_Future*
 _eldbus_model_object_efl_model_property_get(Eo *obj EINA_UNUSED,
                                          Eldbus_Model_Object_Data *pd,
                                          const char *property)
 {
-   Eina_Promise_Owner *promise = eina_promise_add();
-   Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, obj);
+   Efl_Future *future = efl_promise_future_get(promise);
 
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, rpromise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, future);
    DBG("(%p): property=%s", obj, property);
 
    if (!pd->connection)
      _eldbus_model_object_connect(pd);
 
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET((strcmp(property, UNIQUE_NAME_PROPERTY) == 0), promise,
+                                          EFL_MODEL_ERROR_NOT_FOUND, future);
 
    if (pd->unique_name == NULL)
      {
         const char *unique_name;
 
         unique_name = eldbus_connection_unique_name_get(pd->connection);
-        ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(unique_name, promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
+        ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(unique_name, promise, EFL_MODEL_ERROR_NOT_FOUND, future);
         pd->unique_name = strdup(unique_name);
      }
 
    Eina_Value* v = eina_value_new(EINA_VALUE_TYPE_STRING);
    eina_value_set(v, pd->unique_name);
-   eina_promise_owner_value_set(promise, v, (Eina_Promise_Free_Cb)&eina_value_free);
-   return eina_promise_owner_promise_get(promise);
+   efl_promise_value_set(promise, v, (Eina_Free_Cb)&eina_value_free);
+   return future;
 }
 
 static Eo *
@@ -168,15 +171,15 @@ _eldbus_model_object_efl_model_child_del(Eo *obj EINA_UNUSED,
 {
 }
 
-static Eina_Promise*
+static Efl_Future*
 _eldbus_model_object_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
                                                        Eldbus_Model_Object_Data *pd,
                                                        unsigned start,
                                                        unsigned count)
 {
    _Eldbus_Children_Slice_Promise* p;
-   Eina_Promise_Owner *promise = eina_promise_add();
-   Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, obj);
+   Efl_Future *future = efl_promise_future_get(promise);
 
    if (!pd->connection)
      _eldbus_model_object_connect(pd);
@@ -184,12 +187,12 @@ _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, (Eina_Promise_Free_Cb)&eina_accessor_free);
-        return eina_promise_owner_promise_get(promise);
+        efl_promise_value_set(promise, ac, (Eina_Free_Cb)&eina_accessor_free);
+        return future;
      }
 
    p = calloc(1, sizeof(struct _Eldbus_Children_Slice_Promise));
-   EINA_SAFETY_ON_NULL_RETURN_VAL(p, rpromise);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(p, future);
    p->promise = promise;
    p->start = start;
    p->count = count;
@@ -197,14 +200,14 @@ _eldbus_model_object_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
    pd->children_promises = eina_list_prepend(pd->children_promises, p);
    if (pd->pending_list == NULL)
      _eldbus_model_object_introspect(pd, pd->bus, pd->path);
-   return rpromise;
+   return future;
 }
 
-static Eina_Promise*
+static Efl_Future*
 _eldbus_model_object_efl_model_children_count_get(Eo *obj EINA_UNUSED,
                                                Eldbus_Model_Object_Data *pd)
 {
-   Eina_Promise_Owner *promise = eina_promise_add();
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, obj);
    if (!pd->connection)
      _eldbus_model_object_connect(pd);
 
@@ -212,14 +215,14 @@ _eldbus_model_object_efl_model_children_count_get(Eo *obj EINA_UNUSED,
      {
         unsigned int *c = calloc(sizeof(unsigned int), 1);
         *c = eina_list_count(pd->children_list);
-        eina_promise_owner_value_set(promise, c, free);
-        return eina_promise_owner_promise_get(promise);
+        efl_promise_value_set(promise, c, free);
+        return efl_promise_future_get(promise);
      }
 
    pd->count_promises = eina_list_prepend(pd->count_promises, promise);
    if (pd->pending_list == NULL)
      _eldbus_model_object_introspect(pd, pd->bus, pd->path);
-   return eina_promise_owner_promise_get(promise);
+   return efl_promise_future_get(promise);
 }
 
 static const char *
@@ -434,19 +437,19 @@ _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, (Eina_Promise_Free_Cb)&eina_accessor_free);
+            efl_promise_value_set(p->promise, ac, (Eina_Free_Cb)&eina_accessor_free);
             free(p);
           }
-        eina_list_free(pd->children_promises);
+        pd->children_promises = eina_list_free(pd->children_promises);
 
-        Eina_Promise_Owner *ep;
+        Efl_Promise *ep;
         EINA_LIST_FOREACH(pd->count_promises, i, ep)
           {
             unsigned *c = calloc(sizeof(unsigned), 1);
             *c = eina_list_count(pd->children_list);
-            eina_promise_owner_value_set(ep, c, free);
+            efl_promise_value_set(ep, c, free);
           }
-        eina_list_free(pd->count_promises);
+        pd->count_promises = eina_list_free(pd->count_promises);
 
      }
 }
@@ -514,10 +517,10 @@ _eldbus_model_object_create_children(Eldbus_Model_Object_Data *pd, Eldbus_Object
      {
         Eo *child;
 
-        WRN("(%p) Creating child: bus = %s, path = %s, interface = %s", pd->obj, pd->bus, current_path, interface->name);
+        DBG("(%p) Creating child: bus = %s, path = %s, interface = %s", pd->obj, pd->bus, current_path, interface->name);
 
         // TODO: increment reference to keep 'interface' in memory
-        child = efl_add_ref(ELDBUS_MODEL_PROXY_CLASS, NULL, eldbus_model_proxy_constructor(efl_added, object, interface));
+        child = efl_add_ref(ELDBUS_MODEL_PROXY_CLASS, pd->obj, eldbus_model_proxy_constructor(efl_added, object, interface));
 
         pd->children_list = eina_list_append(pd->children_list, child);
      }
diff --git a/src/lib/eldbus/eldbus_model_private.h b/src/lib/eldbus/eldbus_model_private.h
index b4fb49b5ba..0487b3e341 100644
--- a/src/lib/eldbus/eldbus_model_private.h
+++ b/src/lib/eldbus/eldbus_model_private.h
@@ -13,14 +13,14 @@ struct _Eldbus_Children_Slice_Promise
 {
   unsigned start;
   unsigned count;
-  Eina_Promise_Owner* promise;
+  Efl_Promise* promise;
 };
 
 typedef struct _Eldbus_Property_Promise _Eldbus_Property_Promise;
 struct _Eldbus_Property_Promise
 {
   char *property;
-  Eina_Promise_Owner* promise;
+  Efl_Promise* promise;
 };
 
 /* logging support */
@@ -31,7 +31,7 @@ extern int eldbus_model_log_dom;
     {                                                                   \
       if (EINA_UNLIKELY(!(exp)))                                        \
         {                                                               \
-            eina_promise_owner_error_set(promise, err);                 \
+            efl_promise_failed_set(promise, err);                       \
             return v;                                                   \
         }                                                               \
     }                                                                   \
diff --git a/src/lib/eldbus/eldbus_model_proxy.c b/src/lib/eldbus/eldbus_model_proxy.c
index bc249abb88..9b5fa888c3 100644
--- a/src/lib/eldbus/eldbus_model_proxy.c
+++ b/src/lib/eldbus/eldbus_model_proxy.c
@@ -34,10 +34,10 @@ struct _Eldbus_Model_Proxy_Property_Set_Data
    Eldbus_Model_Proxy_Data *pd;
    Eina_Stringshare *property;
    Eina_Value value;
-   Eina_Promise_Owner *promise;
+   Efl_Promise *promise;
 };
 
-static Eldbus_Model_Proxy_Property_Set_Data * _eldbus_model_proxy_property_set_data_new(Eldbus_Model_Proxy_Data *, const char *, const Eina_Value *, Eina_Promise_Owner *promise);
+static Eldbus_Model_Proxy_Property_Set_Data * _eldbus_model_proxy_property_set_data_new(Eldbus_Model_Proxy_Data *, const char *, const Eina_Value *, Efl_Promise *promise);
 static void _eldbus_model_proxy_property_set_data_free(Eldbus_Model_Proxy_Property_Set_Data *);
 
 static void
@@ -108,40 +108,41 @@ _eldbus_model_proxy_efl_model_properties_get(Eo *obj EINA_UNUSED,
    return pd->properties_array;
 }
 
-static void
+static Efl_Future*
 _eldbus_model_proxy_efl_model_property_set(Eo *obj EINA_UNUSED,
                                         Eldbus_Model_Proxy_Data *pd,
                                         const char *property,
-                                        Eina_Value const* value,
-                                        Eina_Promise_Owner *promise)
+                                           Eina_Value const* value)
 {
    Eldbus_Model_Proxy_Property_Set_Data *data;
    const char *signature;
    Eldbus_Pending *pending;
    Eina_Bool ret;
+   Efl_Promise* promise = efl_add(EFL_PROMISE_CLASS, obj);
+   Efl_Future* future = efl_promise_future_get(promise);
 
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, );
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, future);
 
    DBG("(%p): property=%s", obj, property);
    ret = _eldbus_model_proxy_load(pd);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED, );
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED, future);
 
    ret = _eldbus_model_proxy_has_property(pd, property);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_NOT_FOUND, );
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_NOT_FOUND, future);
 
    ret = _eldbus_model_proxy_is_property_writeable(pd, property);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_READ_ONLY, );
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_READ_ONLY, future);
 
    signature = _eldbus_model_proxy_property_type_get(pd, property);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(signature, promise, EFL_MODEL_ERROR_UNKNOWN, );
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(signature, promise, EFL_MODEL_ERROR_UNKNOWN, future);
 
    data = _eldbus_model_proxy_property_set_data_new(pd, property, value, promise);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(data, promise, EFL_MODEL_ERROR_UNKNOWN, );
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(data, promise, EFL_MODEL_ERROR_UNKNOWN, future);
 
    if (!pd->is_loaded)
      {
         _Eldbus_Property_Promise *p = calloc(1, sizeof(_Eldbus_Property_Promise));
-        EINA_SAFETY_ON_NULL_RETURN(p);
+        EINA_SAFETY_ON_NULL_RETURN_VAL(p, future);
 
         p->promise = promise;
         p->property = strdup(property);
@@ -152,37 +153,38 @@ _eldbus_model_proxy_efl_model_property_set(Eo *obj EINA_UNUSED,
              pending = eldbus_proxy_property_get_all(pd->proxy, _eldbus_model_proxy_property_set_load_cb, data);
              pd->pending_list = eina_list_append(pd->pending_list, pending);
           }
-        return;
+        return future;
      }
 
    pending = eldbus_proxy_property_value_set
      (pd->proxy, property, signature, (Eina_Value*)value, _eldbus_model_proxy_property_set_cb, data);
    pd->pending_list = eina_list_append(pd->pending_list, pending);
+   return future;
 }
 
-static Eina_Promise*
+static Efl_Future*
 _eldbus_model_proxy_efl_model_property_get(Eo *obj EINA_UNUSED,
                                         Eldbus_Model_Proxy_Data *pd,
                                         const char *property)
 {
    Eina_Bool ret;
    Eina_Value *promise_value;
-   Eina_Promise_Owner *promise = eina_promise_add();
-   Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, obj);
+   Efl_Future *future = efl_promise_future_get(promise);
 
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, rpromise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(property, promise, EFL_MODEL_ERROR_INCORRECT_VALUE, future);
 
    ret = _eldbus_model_proxy_load(pd);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED, rpromise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED, future);
 
    ret = _eldbus_model_proxy_has_property(pd, property);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_NOT_FOUND, future);
 
    if (!pd->is_loaded)
      {
         Eldbus_Pending *pending;
         _Eldbus_Property_Promise *p = calloc(1, sizeof(_Eldbus_Property_Promise));
-        EINA_SAFETY_ON_NULL_RETURN_VAL(p, rpromise);
+        EINA_SAFETY_ON_NULL_RETURN_VAL(p, future);
 
         p->promise = promise;
         p->property = strdup(property);
@@ -193,19 +195,19 @@ _eldbus_model_proxy_efl_model_property_get(Eo *obj EINA_UNUSED,
              pending = eldbus_proxy_property_get_all(pd->proxy, _eldbus_model_proxy_property_get_all_cb, pd);
              pd->pending_list = eina_list_append(pd->pending_list, pending);
           }
-        return rpromise;
+        return future;
      }
 
    Eina_Value* value = eina_hash_find(pd->properties_hash, property);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(value, promise, EFL_MODEL_ERROR_NOT_FOUND, rpromise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(value, promise, EFL_MODEL_ERROR_NOT_FOUND, future);
 
    ret = _eldbus_model_proxy_is_property_writeable(pd, property);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_READ_ONLY, rpromise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_READ_ONLY, future);
 
    promise_value = eina_value_new(eina_value_type_get(value));
    eina_value_copy(value, promise_value);
-   eina_promise_owner_value_set(promise, promise_value, (Eina_Promise_Free_Cb)&eina_value_free);
-   return rpromise;
+   efl_promise_value_set(promise, promise_value, (Eina_Free_Cb)&eina_value_free);
+   return future;
 }
 
 static Eo *
@@ -222,16 +224,16 @@ _eldbus_model_proxy_efl_model_child_del(Eo *obj EINA_UNUSED,
 {
 }
 
-static Eina_Promise*
+static Efl_Future*
 _eldbus_model_proxy_efl_model_children_slice_get(Eo *obj EINA_UNUSED,
                                               Eldbus_Model_Proxy_Data *pd,
                                               unsigned start,
                                               unsigned count)
 {
    Eina_Bool ret = _eldbus_model_proxy_load(pd);
-   Eina_Promise_Owner *promise = eina_promise_add();
-   Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED, rpromise);
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, obj);
+   Efl_Future *future = efl_promise_future_get(promise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED, future);
 
    if (!pd->is_listed)
      {
@@ -241,18 +243,18 @@ _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)&eina_accessor_free);
-   return rpromise;
+   efl_promise_value_set(promise, ac, (Eina_Free_Cb)&eina_accessor_free);
+   return future;
 }
 
-static Eina_Promise*
+static Efl_Future*
 _eldbus_model_proxy_efl_model_children_count_get(Eo *obj EINA_UNUSED,
                                               Eldbus_Model_Proxy_Data *pd)
 {
    Eina_Bool ret = _eldbus_model_proxy_load(pd);
-   Eina_Promise_Owner *promise = eina_promise_add();
-   Eina_Promise *rpromise = eina_promise_owner_promise_get(promise);
-   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED, rpromise);
+   Efl_Promise *promise = efl_add(EFL_PROMISE_CLASS, obj);
+   Efl_Future *future = efl_promise_future_get(promise);
+   ELDBUS_MODEL_ON_ERROR_EXIT_PROMISE_SET(ret, promise, EFL_MODEL_ERROR_INIT_FAILED, future);
 
    if (!pd->is_listed)
      {
@@ -263,8 +265,8 @@ _eldbus_model_proxy_efl_model_children_count_get(Eo *obj EINA_UNUSED,
 
    unsigned int *c = calloc(sizeof(unsigned int), 1);
    *c = eina_list_count(pd->children_list);
-   eina_promise_owner_value_set(promise, c, free);
-   return eina_promise_owner_promise_get(promise);
+   efl_promise_value_set(promise, c, free);
+   return future;
 }
 
 static void
@@ -296,7 +298,7 @@ _eldbus_model_proxy_create_methods_children(Eldbus_Model_Proxy_Data *pd)
         INF("(%p) Creating method child: bus = %s, path = %s, method = %s::%s",
                        pd->obj, bus, path, interface_name, method_name);
 
-        child = efl_add(ELDBUS_MODEL_METHOD_CLASS, NULL, eldbus_model_method_constructor(efl_added, pd->proxy, method));
+        child = efl_add(ELDBUS_MODEL_METHOD_CLASS, pd->obj, eldbus_model_method_constructor(efl_added, pd->proxy, method));
 
         pd->children_list = eina_list_append(pd->children_list, child);
      }
@@ -331,7 +333,7 @@ _eldbus_model_proxy_create_signals_children(Eldbus_Model_Proxy_Data *pd)
         DBG("(%p) Creating signal child: bus = %s, path = %s, signal = %s::%s",
                        pd->obj, bus, path, interface_name, signal_name);
 
-        child = efl_add(ELDBUS_MODEL_SIGNAL_CLASS, NULL, eldbus_model_signal_constructor(efl_added, pd->proxy, signal));
+        child = efl_add(ELDBUS_MODEL_SIGNAL_CLASS, pd->obj, eldbus_model_signal_constructor(efl_added, pd->proxy, signal));
 
         pd->children_list = eina_list_append(pd->children_list, child);
      }
@@ -577,7 +579,7 @@ _eldbus_model_proxy_property_get_all_cb(void *data,
          _Eldbus_Property_Promise* p;
          EINA_LIST_FOREACH(pd->promise_list, i, p)
            {
-               eina_promise_owner_error_set(p->promise, EFL_MODEL_ERROR_NOT_FOUND);
+               efl_promise_failed_set(p->promise, EFL_MODEL_ERROR_NOT_FOUND);
                free(p->property);
            }
          eina_list_free(pd->promise_list);
@@ -591,14 +593,14 @@ _eldbus_model_proxy_property_get_all_cb(void *data,
         Eina_Value* value = eina_hash_find(pd->properties_hash, p->property);
         if (!value)
           {
-             eina_promise_owner_error_set(p->promise, EFL_MODEL_ERROR_NOT_FOUND);
+             efl_promise_failed_set(p->promise, EFL_MODEL_ERROR_NOT_FOUND);
              free(p->property);
              continue;
           }
 
         if (!_eldbus_model_proxy_is_property_readable(pd, p->property))
           {
-             eina_promise_owner_error_set(p->promise, EFL_MODEL_ERROR_READ_ONLY);
+             efl_promise_failed_set(p->promise, EFL_MODEL_ERROR_READ_ONLY);
              free(p->property);
              continue;
           }
@@ -607,7 +609,7 @@ _eldbus_model_proxy_property_get_all_cb(void *data,
 
         promise_value = eina_value_new(eina_value_type_get(value));
         eina_value_copy(value, promise_value);
-        eina_promise_owner_value_set(p->promise, promise_value, (Eina_Promise_Free_Cb)&eina_value_free);
+        efl_promise_value_set(p->promise, promise_value, (Eina_Free_Cb)&eina_value_free);
      }
    eina_list_free(pd->promise_list);
 
@@ -642,7 +644,7 @@ _eldbus_model_proxy_property_set_load_cb(void *data,
    Eina_Array *changed_properties = _eldbus_model_proxy_property_get_all_load(msg, pd);
    if (signature == NULL || changed_properties == NULL)
      {
-         eina_promise_owner_error_set(set_data->promise, EFL_MODEL_ERROR_UNKNOWN);
+         efl_promise_failed_set(set_data->promise, EFL_MODEL_ERROR_UNKNOWN);
 
          eina_array_free(changed_properties);
          _eldbus_model_proxy_property_set_data_free(set_data);
@@ -672,7 +674,7 @@ _eldbus_model_proxy_property_set_cb(void *data,
    if (eldbus_message_error_get(msg, &error_name, &error_text))
      {
          ERR("%s: %s", error_name, error_text);
-         eina_promise_owner_error_set(property_set_data->promise, EFL_MODEL_ERROR_UNKNOWN);
+         efl_promise_failed_set(property_set_data->promise, EFL_MODEL_ERROR_UNKNOWN);
          _eldbus_model_proxy_property_set_data_free(property_set_data);
          return;
      }
@@ -692,11 +694,11 @@ _eldbus_model_proxy_property_set_cb(void *data,
            }
          promise_value = eina_value_new(eina_value_type_get(prop_value));
          eina_value_copy(prop_value, promise_value);
-         eina_promise_owner_value_set(property_set_data->promise, promise_value, (Eina_Promise_Free_Cb)&eina_value_free);
+         efl_promise_value_set(property_set_data->promise, promise_value, (Eina_Free_Cb)&eina_value_free);
      }
    else
      {
-         eina_promise_owner_error_set(property_set_data->promise, EFL_MODEL_ERROR_NOT_FOUND);
+         efl_promise_failed_set(property_set_data->promise, EFL_MODEL_ERROR_NOT_FOUND);
      }
 
    _eldbus_model_proxy_property_set_data_free(property_set_data);
@@ -767,7 +769,7 @@ static Eldbus_Model_Proxy_Property_Set_Data *
 _eldbus_model_proxy_property_set_data_new(Eldbus_Model_Proxy_Data *pd,
                                           const char *property,
                                           const Eina_Value *value,
-                                          Eina_Promise_Owner *promise)
+                                          Efl_Promise *promise)
 {
    Eldbus_Model_Proxy_Property_Set_Data *data = calloc(1, sizeof(Eldbus_Model_Proxy_Property_Set_Data));
    EINA_SAFETY_ON_NULL_RETURN_VAL(data, NULL);
diff --git a/src/lib/elementary/elc_fileselector.c b/src/lib/elementary/elc_fileselector.c
index d697a50e75..04c3ee3387 100644
--- a/src/lib/elementary/elc_fileselector.c
+++ b/src/lib/elementary/elc_fileselector.c
@@ -183,16 +183,19 @@ _iterator_next_value_get(Eina_Iterator *it, void *res)
    return EINA_FALSE;
 }
 
-static void
-_model_str_property_set(Efl_Model *model, const char *property_name, const char *property_value, Eina_Promise **promise)
+static Efl_Future*
+_model_str_property_set(Efl_Model *model, const char *property_name, const char *property_value)
 {
+   Efl_Future* r;
    Eina_Value v;
    eina_value_setup(&v, EINA_VALUE_TYPE_STRING);
    eina_value_set(&v, property_value);
 
-   efl_model_property_set(model, property_name, &v, promise);
+   r = efl_model_property_set(model, property_name, &v);
 
    eina_value_flush(&v);
+
+   return r;
 }
 
 EOLIAN static Elm_Theme_Apply
@@ -766,11 +769,11 @@ _process_child(Elm_Fileselector_Item_Data *it_data, Eina_Iterator *value_itt)
 }
 
 static void
-_process_child_cb(void *data, void *values)
+_process_child_cb(void *data, Efl_Event const*event)
 {
    Elm_Fileselector_Item_Data *it_data = data;
    Listing_Request *lreq = it_data->user_data;
-   Eina_Iterator *value_itt = values;
+   Eina_Iterator *value_itt = (Eina_Iterator*)((Efl_Future_Event_Success*)event->info)->value;
 
    if (!lreq->valid ||
        !_process_child(it_data, value_itt))
@@ -793,7 +796,7 @@ _process_child_cb(void *data, void *values)
 }
 
 static void
-_process_child_error_cb(void *data, Eina_Error err EINA_UNUSED)
+_process_child_error_cb(void *data, Efl_Event const* event EINA_UNUSED)
 {
    Elm_Fileselector_Item_Data *it_data = data;
    Listing_Request *lreq = it_data->user_data;
@@ -831,10 +834,10 @@ _listing_request_cleanup(Listing_Request *lreq)
 }
 
 static void
-_process_children_cb(void *data, void *values)
+_process_children_cb(void *data, Efl_Event const *event)
 {
    Listing_Request *lreq = data;
-   Eina_Iterator *value_itt = values;
+   Eina_Iterator *value_itt = (Eina_Iterator*)((Efl_Future_Event_Success*)event->info)->value;
    Eina_Accessor *children_accessor = NULL;
    Elm_Fileselector_Item_Data *it_data = NULL;
    const char *path = NULL;
@@ -878,13 +881,12 @@ _process_children_cb(void *data, void *values)
 
              EINA_LIST_FREE(children, child)
                {
-                  Eina_Promise *promises[7];
-                  Eina_Promise *promise_all = NULL;
+                  Efl_Future *futures[7];
+                  Efl_Future *future_all = NULL;
                   const char *prop[6] = {
                      "path", "filename", "is_dir", "size", "mtime", "mime_type"
                   };
                   unsigned int i;
-                  Eina_Error error;
 
                   it_data = calloc(1, sizeof(Elm_Fileselector_Item_Data));
                   if (!it_data)
@@ -896,20 +898,13 @@ _process_children_cb(void *data, void *values)
                   it_data->model = efl_ref(child);
                   it_data->user_data = lreq;
 
-                  for (i = 0; i <= 5; i++)
+                  for (i = 0; i != 6; i++)
                     {
-                       promises[i] = efl_model_property_get(child, prop[i]);
-                       error = eina_promise_error_get(promises[i]);
-                       if (error)
-                         {
-                            ERR("Error with property \"%s\": %s", prop[i],
-                                eina_error_msg_get(error));
-                         }
+                       futures[i] = efl_model_property_get(child, prop[i]);
                     }
-                  promises[6] = NULL;
 
-                  promise_all = eina_promise_all(eina_carray_iterator_new((void**)promises));
-                  eina_promise_then(promise_all, _process_child_cb, _process_child_error_cb, it_data);
+                  future_all = efl_future_all(futures[0], futures[1], futures[2], futures[3], futures[4], futures[5]);
+                  efl_future_then(future_all, _process_child_cb, _process_child_error_cb, NULL, it_data);
                }
 
              // NOTE: lreq may have been deallocated in the previous loop
@@ -930,8 +925,9 @@ _process_children_cb(void *data, void *values)
 }
 
 static void
-_process_children_error_cb(void *data, Eina_Error error)
+_process_children_error_cb(void *data, Efl_Event const* event)
 {
+   Eina_Error error = ((Efl_Future_Event_Failure*)event->info)->error;
    Listing_Request *lreq = data;
    Elm_Fileselector_Data *sd = lreq->sd;
 
@@ -996,15 +992,15 @@ _populate(Evas_Object *obj,
    if (elm_object_disabled_get(sd->name_entry))
      elm_object_text_set(sd->name_entry, "");
 
-   Eina_Promise *promises[4] = {NULL,};
-   Eina_Promise *promise_all = NULL;
-   promises[0] = efl_model_property_get(model, "path");
-   promises[1] = efl_model_children_slice_get(model, 0, 0);
+   Efl_Future *futures[4] = {NULL,};
+   Efl_Future *future_all = NULL;
+   futures[0] = efl_model_property_get(model, "path");
+   futures[1] = efl_model_children_slice_get(model, 0, 0);
    if (selected)
-     promises[2] = efl_model_property_get(selected, "path");
+     futures[2] = efl_model_property_get(selected, "path");
 
-   promise_all = eina_promise_all(eina_carray_iterator_new((void**)&promises[0]));
-   eina_promise_then(promise_all, _process_children_cb, _process_children_error_cb, lreq);
+   future_all = efl_future_all(futures[0], futures[1], futures[2]);
+   efl_future_then(future_all, _process_children_cb, _process_children_error_cb, NULL, lreq);
 }
 
 static void
@@ -1342,7 +1338,7 @@ _ok(void *data, const Efl_Event *event EINA_UNUSED)
           selection = eina_stringshare_printf("%s/%s", sd->path, name);
 
         selected_model = efl_add(efl_class_get(sd->model), NULL);
-        _model_str_property_set(selected_model, "path", selection, NULL);
+        _model_str_property_set(selected_model, "path", selection);
 
         _model_event_call
           (fs, ELM_FILESELECTOR_EVENT_DONE, selected_model, selection);
@@ -1385,7 +1381,7 @@ _text_activated_free_fs_data(Elm_Fileselector *fs)
 }
 
 static void
-_text_activated_is_dir_then(void *data, void *value)
+_text_activated_is_dir_then(void *data, Efl_Event const *event)
 {
    Evas_Object *fs = data;
    Eina_Bool is_dir = EINA_FALSE;
@@ -1394,7 +1390,7 @@ _text_activated_is_dir_then(void *data, void *value)
    Efl_Model *model = efl_key_ref_get(fs, _text_activated_model_key);
    Eina_Stringshare *str = efl_key_data_get(fs, _text_activated_path_key);
 
-   eina_value_get(value, &is_dir);
+   eina_value_get((Eina_Value*)((Efl_Future_Event_Success*)event->info)->value, &is_dir);
    if (is_dir)
      {
         // keep previous path for backspace key action
@@ -1433,28 +1429,28 @@ _text_activated_is_dir_then(void *data, void *value)
 }
 
 static void
-_text_activated_is_dir_then_error(void *data, Eina_Error err EINA_UNUSED)
+_text_activated_is_dir_then_error(void *data, Efl_Event const* event EINA_UNUSED)
 {
    ERR("could not get information from Efl.Model");
    _text_activated_free_fs_data(data);
 }
 
 static void
-_on_text_activated_set_path_then(void *data, void *value EINA_UNUSED)
+_on_text_activated_set_path_then(void *data, Efl_Event const * event EINA_UNUSED)
 {
    Evas_Object *fs = data;
-   Eina_Promise *promise = NULL;
+   Efl_Future *future = NULL;
    ELM_FILESELECTOR_DATA_GET(fs, sd);
 
    if (!sd->model) return ;
 
-   promise = efl_model_property_get(sd->model, "is_dir");
-   eina_promise_then
-     (promise, _text_activated_is_dir_then, _text_activated_is_dir_then_error, data);
+   future = efl_model_property_get(sd->model, "is_dir");
+   efl_future_then
+     (future, _text_activated_is_dir_then, _text_activated_is_dir_then_error, NULL, data);
 }
 
 static void
-_on_text_activated_set_path_then_error(void *data, Eina_Error err EINA_UNUSED)
+_on_text_activated_set_path_then_error(void *data, Efl_Event const* event EINA_UNUSED)
 {
    Evas_Object *fs = data;
    Efl_Model *model = efl_key_data_get(fs, _text_activated_model_key);
@@ -1475,7 +1471,7 @@ _on_text_activated(void *data, const Efl_Event *event)
    Evas_Object *fs = data;
    const char *path;
    Efl_Model *model;
-   Eina_Promise *promise = NULL;
+   Efl_Future *future = NULL;
 
    ELM_FILESELECTOR_DATA_GET(fs, sd);
 
@@ -1487,15 +1483,16 @@ _on_text_activated(void *data, const Efl_Event *event)
    if (!model)
      return;
 
-   _model_str_property_set(model, "path", path, &promise);
+   future = _model_str_property_set(model, "path", path);
 
    efl_key_data_set(fs, _text_activated_path_key, eina_stringshare_add(path));
    efl_key_ref_set(fs, _text_activated_model_key, model);
    efl_ref(fs);
-   eina_promise_then(promise,
-                     _on_text_activated_set_path_then,
-                     _on_text_activated_set_path_then_error,
-                     fs);
+   efl_future_then(future,
+                   _on_text_activated_set_path_then,
+                   _on_text_activated_set_path_then_error,
+                   NULL,
+                   fs);
 
    efl_unref(model);
    elm_object_focus_set(event->object, EINA_FALSE);
@@ -1545,7 +1542,7 @@ _anchor_clicked(void *data, const Efl_Event *event)
    model = efl_add(efl_class_get(sd->model), NULL);
    if (!model)
      return;
-   _model_str_property_set(model, "path", info->name, NULL);
+   _model_str_property_set(model, "path", info->name);
 
    _populate(fs, model, NULL, NULL);
    efl_unref(model);
@@ -1653,7 +1650,7 @@ _files_grid_add(Evas_Object *obj)
 }
 
 static void
-_resource_then_error(void *data, Eina_Error err EINA_UNUSED)
+_resource_then_error(void *data, Efl_Event const* event EINA_UNUSED)
 {
    Elm_Fileselector_Item_Data *it_data = data;
    WRN("could not get information from Efl.Model");
@@ -1663,11 +1660,11 @@ _resource_then_error(void *data, Eina_Error err EINA_UNUSED)
 }
 
 static void
-_resource_created_then(void *data, void *values)
+_resource_created_then(void *data, Efl_Event const*event)
 {
    Elm_Fileselector_Item_Data *it_data = data;
    Evas_Object *obj = it_data->user_data;
-   Eina_Iterator *value_itt = values;
+   Eina_Iterator *value_itt = (Eina_Iterator*)((Efl_Future_Event_Success*)event->info)->value;
    int itcn = ELM_FILE_UNKNOW;
    const char *path = NULL;
    const char *filename = NULL;
@@ -1741,8 +1738,8 @@ _resource_created(void *data, const Efl_Event *event)
    Elm_Fileselector *fs = data;
    Efl_Model_Children_Event* evt = event->info;
    Efl_Model *child = evt->child;
-   Eina_Promise *promises[7] = {NULL,};
-   Eina_Promise *promise_all = NULL;
+   Efl_Future *futures[7] = {NULL,};
+   Efl_Future *future_all = NULL;
    Elm_Fileselector_Item_Data *it_data = NULL;
 
    ELM_FILESELECTOR_DATA_GET(fs, sd);
@@ -1759,17 +1756,19 @@ _resource_created(void *data, const Efl_Event *event)
    it_data->parent_model = efl_ref(sd->model);
    it_data->parent_path = eina_stringshare_add(sd->path);
 
-   promises[0] = efl_model_property_get(child, "path");
-   promises[1] = efl_model_property_get(child, "filename");
-   promises[2] = efl_model_property_get(child, "is_dir");
-   promises[3] = efl_model_property_get(child, "size");
-   promises[4] = efl_model_property_get(child, "mtime");
-   promises[5] = efl_model_property_get(child, "mime_type");
 
 
-   promise_all = eina_promise_all(eina_carray_iterator_new((void**)promises));
+   future_all = efl_future_all
+     (
+      futures[0] = efl_model_property_get(child, "path"),
+      futures[1] = efl_model_property_get(child, "filename"),
+      futures[2] = efl_model_property_get(child, "is_dir"),
+      futures[3] = efl_model_property_get(child, "size"),
+      futures[4] = efl_model_property_get(child, "mtime"),
+      futures[5] = efl_model_property_get(child, "mime_type")
+     );
 
-   eina_promise_then(promise_all, _resource_created_then, _resource_then_error, it_data);
+   efl_future_then(future_all, _resource_created_then, _resource_then_error, NULL, it_data);
 
    return;
 }
@@ -2059,16 +2058,17 @@ _elm_fileselector_efl_object_constructor(Eo *obj, Elm_Fileselector_Data *sd)
 }
 
 static void
-_legacy_smart_callback_caller_path_then(void *data, void *value)
+_legacy_smart_callback_caller_path_then(void *data, Efl_Event const *event)
 {
    Legacy_Event_Path_Then_Data *evt_data = data;
-   _event_to_legacy_call(evt_data->eo_obj, evt_data->evt_desc, value);
+   _event_to_legacy_call(evt_data->eo_obj, evt_data->evt_desc, ((Efl_Future_Event_Success*)event->info)->value);
    free(data);
 }
 
 static void
-_legacy_smart_callback_caller_path_then_error(void *data, Eina_Error err)
+_legacy_smart_callback_caller_path_then_error(void *data, Efl_Event const* event)
 {
+   Eina_Error err = ((Efl_Future_Event_Failure*)event->info)->error;
    ERR("Efl.Model property \"path\" error: %s", eina_error_msg_get(err));
    free(data);
 }
@@ -2076,7 +2076,7 @@ _legacy_smart_callback_caller_path_then_error(void *data, Eina_Error err)
 static Eina_Bool
 _from_efl_event_call(Elm_Fileselector *fs, const Efl_Event_Description *evt_desc, Efl_Model *model)
 {
-   Eina_Promise *promise;
+   Efl_Future *future;
    Legacy_Event_Path_Then_Data *evt_data;
 
    evt_data = calloc(1, sizeof(Legacy_Event_Path_Then_Data));
@@ -2084,11 +2084,12 @@ _from_efl_event_call(Elm_Fileselector *fs, const Efl_Event_Description *evt_desc
    evt_data->evt_desc = evt_desc;
 
    // Call legacy smart callback with path
-   promise = efl_model_property_get(model, "path");
-   eina_promise_then(promise,
-                     _legacy_smart_callback_caller_path_then,
-                     _legacy_smart_callback_caller_path_then_error,
-                     evt_data);
+   future = efl_model_property_get(model, "path");
+   efl_future_then(future,
+                   _legacy_smart_callback_caller_path_then,
+                   _legacy_smart_callback_caller_path_then_error,
+                   NULL,
+                   evt_data);
 
    // Call Eo event with model
    return efl_event_callback_call(fs, evt_desc, model);
@@ -2104,7 +2105,7 @@ _from_legacy_event_call(Elm_Fileselector *fs, Elm_Fileselector_Data *sd, const E
      model_cls = efl_class_get(sd->model);
 
    Efl_Model *model = efl_add(model_cls, NULL);
-   _model_str_property_set(model, "path", path, NULL);
+   _model_str_property_set(model, "path", path);
 
    // Call Eo event with model
    efl_event_callback_call(fs, evt_desc, model);
@@ -2617,31 +2618,32 @@ _selected_model_set_free_fs_data(Elm_Fileselector *fs)
 }
 
 static void
-_selected_model_set_then_error(void *data, Eina_Error err)
+_selected_model_set_then_error(void *data, Efl_Event const* event)
 {
-   Eina_Promise_Owner *promise_owner = efl_key_data_get(data, _selected_model_set_promise_owner_key);
+   Eina_Error err = ((Efl_Future_Event_Failure*)event->info)->error;
+   Efl_Promise *promise_owner = efl_key_data_get(data, _selected_model_set_promise_owner_key);
    if (promise_owner)
-     eina_promise_owner_error_set(promise_owner, err);
+     efl_promise_failed_set(promise_owner, err);
    _selected_model_set_free_fs_data(data);
 }
 
 static void
-_selected_model_set_is_dir_then(void *data, void *value)
+_selected_model_set_is_dir_then(void *data, Efl_Event const *event)
 {
    Elm_Fileselector *fs = data;
    Eina_Bool is_dir = EINA_FALSE;
    Efl_Model *model = efl_key_ref_get(fs, _selected_model_set_model_key);
-   Eina_Promise_Owner *promise_owner = efl_key_data_get(fs, _selected_model_set_promise_owner_key);
+   Efl_Promise *promise_owner = efl_key_data_get(fs, _selected_model_set_promise_owner_key);
    ELM_FILESELECTOR_DATA_GET(fs, sd);
 
-   eina_value_get(value, &is_dir);
+   eina_value_get((Eina_Value*)((Efl_Future_Event_Success*)event->info)->value, &is_dir);
    if (is_dir)
      {
         _schedule_populate(fs, sd, model, NULL);
         if (promise_owner)
           {
              efl_ref(model);
-             eina_promise_owner_value_set(promise_owner, model, _model_free_eo_cb);
+             efl_promise_value_set(promise_owner, model, _model_free_eo_cb);
           }
      }
    else
@@ -2654,35 +2656,35 @@ _selected_model_set_is_dir_then(void *data, void *value)
              if (promise_owner)
                {
                   efl_ref(model);
-                  eina_promise_owner_value_set(promise_owner, model, _model_free_eo_cb);
+                  efl_promise_value_set(promise_owner, model, _model_free_eo_cb);
                }
           }
         else
           {
              if (promise_owner)
-               eina_promise_owner_error_set(promise_owner, ELM_FILESELECTOR_ERROR_UNKNOWN);
+               efl_promise_failed_set(promise_owner, ELM_FILESELECTOR_ERROR_UNKNOWN);
           }
      }
    _selected_model_set_free_fs_data(fs);
 }
 
-EOLIAN static void
-_elm_fileselector_elm_interface_fileselector_selected_model_set(Eo *obj, Elm_Fileselector_Data *sd EINA_UNUSED, Efl_Model *model, Eina_Promise_Owner *promise_owner)
+EOLIAN static Efl_Future*
+_elm_fileselector_elm_interface_fileselector_selected_model_set(Eo *obj, Elm_Fileselector_Data *sd EINA_UNUSED, Efl_Model *model)
 {
-   Eina_Promise *promise = NULL;
+   Efl_Future *future = NULL;
+   Efl_Promise* promise = efl_add(EFL_PROMISE_CLASS, obj);
    if (!model)
      {
-        if (promise_owner)
-          eina_promise_owner_error_set(promise_owner, ELM_FILESELECTOR_ERROR_INVALID_MODEL);
-        return;
+        efl_promise_failed_set(promise, ELM_FILESELECTOR_ERROR_INVALID_MODEL);
+        return efl_promise_future_get(promise);
      }
-   promise = efl_model_property_get(model, "is_dir");
+   future = efl_model_property_get(model, "is_dir");
 
    efl_key_ref_set(obj, _selected_model_set_model_key, model);
-   if (promise_owner)
-     efl_key_data_set(obj, _selected_model_set_promise_owner_key, promise_owner);
+   efl_key_data_set(obj, _selected_model_set_promise_owner_key, promise);
 
-   eina_promise_then(promise, _selected_model_set_is_dir_then, _selected_model_set_then_error, efl_ref(obj));
+   efl_future_then(future, _selected_model_set_is_dir_then, _selected_model_set_then_error, NULL, efl_ref(obj));
+   return efl_promise_future_get(promise);
 }
 
 EAPI const Eina_List *
diff --git a/src/lib/elementary/elc_fileselector_button.c b/src/lib/elementary/elc_fileselector_button.c
index e408e2dd96..e25f00badc 100644
--- a/src/lib/elementary/elc_fileselector_button.c
+++ b/src/lib/elementary/elc_fileselector_button.c
@@ -68,18 +68,18 @@ _elm_fileselector_button_elm_widget_theme_apply(Eo *obj, Elm_Fileselector_Button
 }
 
 static void
-_replace_path_then(void *data, void *value)
+_replace_path_then(void *data, Efl_Event const *event)
 {
    Elm_Fileselector_Button_Data *sd = data;
    const char *path = NULL;
-   eina_value_get(value, &path);
+   eina_value_get((Eina_Value*)((Efl_Future_Event_Success*)event->info), &path);
    eina_stringshare_replace(&sd->fsd.path, path);
    _event_to_legacy_call
      (sd->obj, ELM_FILESELECTOR_BUTTON_EVENT_FILE_CHOSEN, (void *)path);
 }
 
 static void
-_replace_path_then_error(void *data, Eina_Error err EINA_UNUSED)
+_replace_path_then_error(void *data, Efl_Event const* event EINA_UNUSED)
 {
    Elm_Fileselector_Button_Data *sd = data;
    ERR("could not get information from Efl.Model");
@@ -97,12 +97,12 @@ _selection_done(void *data, const Efl_Event *event)
 
    if (model)
      {
-        Eina_Promise *promise = NULL;
+        Efl_Future *future = NULL;
         if (sd->fsd.model)
           efl_unref(sd->fsd.model);
         sd->fsd.model = efl_ref(model);
-        promise = efl_model_property_get(model, "path");
-        eina_promise_then(promise, _replace_path_then, _replace_path_then_error, sd);
+        future = efl_model_property_get(model, "path");
+        efl_future_then(future, _replace_path_then, _replace_path_then_error, NULL, sd);
         efl_event_callback_call
           (sd->obj, ELM_FILESELECTOR_BUTTON_EVENT_FILE_CHOSEN, model);
      }
@@ -176,7 +176,7 @@ _activate(Elm_Fileselector_Button_Data *sd)
    elm_fileselector_expandable_set(sd->fs, sd->fsd.expandable);
    elm_fileselector_folder_only_set(sd->fs, sd->fsd.folder_only);
    elm_fileselector_is_save_set(sd->fs, sd->fsd.is_save);
-   elm_interface_fileselector_selected_model_set(sd->fs, sd->fsd.model, NULL);
+   elm_interface_fileselector_selected_model_set(sd->fs, sd->fsd.model);
    evas_object_size_hint_weight_set
      (sd->fs, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
    evas_object_size_hint_align_set(sd->fs, EVAS_HINT_FILL, EVAS_HINT_FILL);
@@ -328,7 +328,7 @@ _elm_fileselector_button_path_set_internal(Evas_Object *obj, const char *path)
 
    eina_stringshare_replace(&sd->fsd.path, path);
 
-   if (sd->fs) elm_interface_fileselector_selected_model_set(sd->fs, model, NULL);
+   if (sd->fs) elm_interface_fileselector_selected_model_set(sd->fs, model);
 }
 
 EINA_DEPRECATED EAPI void
@@ -346,10 +346,9 @@ _elm_fileselector_button_elm_interface_fileselector_model_set(Eo *obj EINA_UNUSE
 
    if (model)
      {
-        Eina_Promise *promise = NULL;
         sd->fsd.model = efl_ref(model);
-        promise = efl_model_property_get(model, "path");
-        eina_promise_then(promise, _replace_path_then, _replace_path_then_error, sd);
+        efl_future_then(efl_model_property_get(model, "path"),
+                        _replace_path_then, _replace_path_then_error, NULL, sd);
      }
    else
      {
@@ -357,7 +356,7 @@ _elm_fileselector_button_elm_interface_fileselector_model_set(Eo *obj EINA_UNUSE
         eina_stringshare_replace(&sd->fsd.path, NULL);
      }
 
-   if (sd->fs) elm_interface_fileselector_selected_model_set(sd->fs, model, NULL);
+   if (sd->fs) elm_interface_fileselector_selected_model_set(sd->fs, model);
 }
 
 const char *
@@ -575,32 +574,36 @@ _elm_fileselector_button_selected_set_internal(Evas_Object *obj, const char *_pa
 }
 
 static void
-_selected_model_then(void *data, void *v)
+_selected_model_then(void *data, Efl_Event const *event)
 {
-   Eina_Promise_Owner *owner = data;
-   eina_promise_owner_value_set(owner, efl_ref(v), _model_free_eo_cb);
+   Eo* v = (Eo*)((Efl_Future_Event_Success*)event->info)->value;
+   Efl_Promise *owner = data;
+   efl_promise_value_set(owner, efl_ref(v), _model_free_eo_cb);
 }
 
 static void
-_selected_model_then_error(void *data, Eina_Error err)
+_selected_model_then_error(void *data, Efl_Event const* event)
 {
-   Eina_Promise_Owner *owner = data;
-   eina_promise_owner_error_set(owner, err);
+   Efl_Promise *owner = data;
+   efl_promise_failed_set(owner, ((Efl_Future_Event_Failure*)event->info)->error);
 }
 
-EOLIAN static void
-_elm_fileselector_button_elm_interface_fileselector_selected_model_set(Eo *obj EINA_UNUSED, Elm_Fileselector_Button_Data *sd, Efl_Model *model, Eina_Promise_Owner *promise_owner)
+EOLIAN static Efl_Future*
+_elm_fileselector_button_elm_interface_fileselector_selected_model_set(Eo *obj EINA_UNUSED, Elm_Fileselector_Button_Data *sd, Efl_Model *model)
 {
+   Efl_Promise* promise = efl_add(EFL_PROMISE_CLASS, obj);
    if (sd->fs)
      {
-        Eina_Promise *promise = NULL;
-        elm_interface_fileselector_selected_model_set(sd->fs, model, &promise);
-        eina_promise_then(promise, _selected_model_then, _selected_model_then_error, promise_owner);
+        efl_future_then(elm_interface_fileselector_selected_model_set(sd->fs, model),
+                        _selected_model_then, _selected_model_then_error, NULL, promise);
      }
+   else
+     efl_promise_failed_set(promise, EINA_ERROR_FUTURE_CANCEL);
 
    if (sd->fsd.selection)
      efl_unref(sd->fsd.selection);
    sd->fsd.selection = model ? efl_ref(model) : NULL;
+   return efl_promise_future_get(promise);
 }
 
 EOLIAN static void
diff --git a/src/lib/elementary/elc_fileselector_entry.c b/src/lib/elementary/elc_fileselector_entry.c
index 59de0d0d75..9de1f2222e 100644
--- a/src/lib/elementary/elc_fileselector_entry.c
+++ b/src/lib/elementary/elc_fileselector_entry.c
@@ -64,7 +64,7 @@ SIG_FWD(UNPRESSED, EFL_UI_EVENT_UNPRESSED)
 #undef SIG_FWD
 
 static void
-_file_chosen_path_then(void *data, void *v)
+_file_chosen_path_then(void *data, Efl_Event const* event)
 {
    Eina_Array *args = data;
    const char *file = NULL;
@@ -74,7 +74,7 @@ _file_chosen_path_then(void *data, void *v)
 
    eina_array_free(args);
 
-   eina_value_get(v, &file);
+   eina_value_get((Eina_Value*)((Efl_Future_Event_Success*)event->info)->value, &file);
 
    if (!file) return;
    ELM_FILESELECTOR_ENTRY_DATA_GET(fs, sd);
@@ -88,8 +88,9 @@ _file_chosen_path_then(void *data, void *v)
 }
 
 static void
-_file_chosen_path_then_error(void *data, Eina_Error err)
+_file_chosen_path_then_error(void *data, Efl_Event const* event)
 {
+   Eina_Error err = ((Efl_Future_Event_Failure*)event->info)->error;
    ERR("Efl.Model property \"path\" error: %s", eina_error_msg_get(err));
    eina_array_free(data);
 }
@@ -98,7 +99,7 @@ static void
 _FILE_CHOSEN_fwd(void *data, const Efl_Event *event)
 {
    Efl_Model *model = event->info;
-   Eina_Promise *promise = NULL;
+   Efl_Future *future = NULL;
    Eina_Array *args = NULL;
 
    if (!model) return;
@@ -107,9 +108,9 @@ _FILE_CHOSEN_fwd(void *data, const Efl_Event *event)
    eina_array_push(args, data);
    eina_array_push(args, model);
 
-   promise = efl_model_property_get(model, "path");
-   eina_promise_then
-     (promise, _file_chosen_path_then, _file_chosen_path_then_error, args);
+   future = efl_model_property_get(model, "path");
+   efl_future_then
+     (future, _file_chosen_path_then, _file_chosen_path_then_error, NULL, args);
 }
 
 static void
@@ -129,7 +130,7 @@ _ACTIVATED_fwd(void *data, const Efl_Event *event)
          model = efl_add(efl_class_get(bmodel), NULL);
          eina_value_setup(&path, EINA_VALUE_TYPE_STRING);
          eina_value_set(&path, file);
-         efl_model_property_set(model, "path", &path, NULL);
+         efl_model_property_set(model, "path", &path);
          eina_value_flush(&path);
          elm_interface_fileselector_model_set(sd->button, model);
      }
@@ -410,14 +411,16 @@ _elm_fileselector_entry_selected_set_internal(Evas_Object *obj, const char *path
    return EINA_TRUE;
 }
 
-EOLIAN static void
+EOLIAN static Efl_Future*
 _elm_fileselector_entry_elm_interface_fileselector_selected_model_set(Eo *obj EINA_UNUSED,
                                                                       Elm_Fileselector_Entry_Data *sd,
-                                                                      Efl_Model *model,
-                                                                      Eina_Promise_Owner *promise_owner)
+                                                                      Efl_Model *model)
 {
+   Efl_Promise* promise = efl_add(EFL_PROMISE_CLASS, obj);
+   Efl_Future* future = efl_promise_future_get(promise);
    elm_interface_fileselector_model_set(sd->button, model);
-   eina_promise_owner_value_set(promise_owner, efl_ref(model), _model_free_eo_cb);
+   efl_promise_value_set(promise, efl_ref(model), _model_free_eo_cb);
+   return future;
 }
 
 EINA_DEPRECATED EAPI const char *
@@ -499,11 +502,12 @@ _elm_fileselector_entry_path_set_internal(Evas_Object *obj, const char *path)
 }
 
 static void
-_fs_entry_model_path_get_then(void *data, void *v)
+_fs_entry_model_path_get_then(void *data, Efl_Event const *event)
 {
    Elm_Fileselector_Entry_Data *sd = data;
    char *path = NULL;
    char *s;
+   Eina_Value* v = (Eina_Value*)((Efl_Future_Event_Success*)event->info)->value;
 
    if (!v)
      return;
@@ -520,11 +524,11 @@ _fs_entry_model_path_get_then(void *data, void *v)
 EOLIAN static void
 _elm_fileselector_entry_elm_interface_fileselector_model_set(Eo *obj EINA_UNUSED, Elm_Fileselector_Entry_Data *sd, Efl_Model *model)
 {
-   Eina_Promise *p = NULL;
+   Efl_Future *p = NULL;
    elm_interface_fileselector_model_set(sd->button, model);
 
    p = efl_model_property_get(model, "path");
-   eina_promise_then(p, _fs_entry_model_path_get_then, NULL, sd);
+   efl_future_then(p, _fs_entry_model_path_get_then, NULL, NULL, sd);
 }
 
 EINA_DEPRECATED EAPI const char *
@@ -560,7 +564,7 @@ _elm_fileselector_entry_elm_interface_fileselector_model_get(Eo *obj EINA_UNUSED
    sd->path = elm_entry_markup_to_utf8(elm_object_text_get(sd->entry));
    eina_value_setup(&path, EINA_VALUE_TYPE_STRING);
    eina_value_set(&path, sd->path);
-   efl_model_property_set(ret, "path", &path, NULL);
+   efl_model_property_set(ret, "path", &path);
    eina_value_flush(&path);
 
    return ret;
diff --git a/src/lib/elementary/elm_interface_fileselector.eo b/src/lib/elementary/elm_interface_fileselector.eo
index 82dc00f2dd..b88858627f 100644
--- a/src/lib/elementary/elm_interface_fileselector.eo
+++ b/src/lib/elementary/elm_interface_fileselector.eo
@@ -151,8 +151,8 @@ interface Elm.Interface.Fileselector ()
          [[Set, programmatically, the currently selected file/directory in the given file selector widget]]
          params {
             @in model: Efl.Model; [[Model to be set]]
-            @inout promise: promise<Efl.Model>; [[Promise returning the recorded selected model or error]]
          }
+         return: future<Efl.Model>; [[Promise returning the recorded selected model or error]]
       }
       selected_model_get {
          [[Get the currently selected item's model, in the given file the given file selector widget]]
diff --git a/src/lib/elementary/elm_view_form.c b/src/lib/elementary/elm_view_form.c
index 06d3d63041..6c9230e29e 100644
--- a/src/lib/elementary/elm_view_form.c
+++ b/src/lib/elementary/elm_view_form.c
@@ -46,23 +46,24 @@ struct _Elm_View_Form_Promise
 
 
 static void
-_efl_promise_then_widget(void* data, void* v)
+_efl_promise_then_widget(void* data, Efl_Event const* event)
 {
     Elm_View_Form_Widget *w = data;
-    Eina_Value *value = v;
+    Efl_Future_Event_Success* info = event->info;
+    Eina_Value *value = info->value;
     w->widget_obj_set_cb(w->widget_obj, value, w->widget_propname);
 }
 
 static void
-_efl_promise_error_widget(void *data EINA_UNUSED, Eina_Error err EINA_UNUSED)
+_efl_promise_error_widget(void *data EINA_UNUSED, Efl_Event const* event EINA_UNUSED)
 {
 }
 
 static void
-_efl_model_promise_then_cb(void* data, void* v)
+_efl_model_promise_then_cb(void* data, Efl_Event const* event)
 {
    Elm_View_Form_Promise *p = data;
-   Eina_Value *value = v;
+   Eina_Value *value = ((Efl_Future_Event_Success*)event->info)->value;
    Elm_View_Form_Data *priv = p->priv;
    Elm_View_Form_Widget *w = NULL;
    Eina_List *l = NULL;
@@ -82,7 +83,7 @@ _efl_model_promise_then_cb(void* data, void* v)
 }
 
 static void
-_efl_model_promise_error_cb(void* data, Eina_Error error EINA_UNUSED)
+_efl_model_promise_error_cb(void* data, Efl_Event const* event EINA_UNUSED)
 {
    Elm_View_Form_Promise *p = data;
    EINA_SAFETY_ON_NULL_RETURN(p);
@@ -95,7 +96,6 @@ static void
 _efl_model_properties_change_cb(void *data, const Efl_Event *event)
 {
    const Efl_Model_Property_Event *evt = event->info;
-   Eina_Promise *promise;
    const char *prop;
    unsigned int i;
    Elm_View_Form_Data *priv = data;
@@ -114,9 +114,9 @@ _efl_model_properties_change_cb(void *data, const Efl_Event *event)
         p = calloc(1, sizeof(Elm_View_Form_Promise));
         p->property_name = eina_stringshare_add(prop);
         p->priv = priv;
-        promise = efl_model_property_get(priv->model_obj, prop);
-        eina_promise_then(promise, &_efl_model_promise_then_cb,
-                          &_efl_model_promise_error_cb, p);
+        efl_future_then(efl_model_property_get(priv->model_obj, prop),
+                        &_efl_model_promise_then_cb,
+                        &_efl_model_promise_error_cb, NULL, p);
      }
 }
 
@@ -125,15 +125,14 @@ _update_model_properties(Elm_View_Form_Data *priv)
 {
    Eina_List *l;
    Elm_View_Form_Widget *w;
-   Eina_Promise *promise;
    //update all widgets property
    if (priv->model_obj == NULL)
      return;
 
    EINA_LIST_FOREACH(priv->widgets, l, w)
      {
-        promise = efl_model_property_get(priv->model_obj, w->widget_propname);
-        eina_promise_then(promise, &_efl_promise_then_widget, &_efl_promise_error_widget, w);
+        efl_future_then(efl_model_property_get(priv->model_obj, w->widget_propname),
+                        &_efl_promise_then_widget, &_efl_promise_error_widget, NULL, w);
      }
 }
 
@@ -201,7 +200,7 @@ _elm_evas_object_text_changed_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *o
    EINA_SAFETY_ON_NULL_RETURN(w);
    eina_value_setup(&value, EINA_VALUE_TYPE_STRING);
    eina_value_set(&value, elm_object_text_get(obj));
-   efl_model_property_set(priv->model_obj, w->widget_propname, &value, NULL);
+   efl_model_property_set(priv->model_obj, w->widget_propname, &value);
    eina_value_flush(&value);
 }
 /**
@@ -212,7 +211,7 @@ _elm_evas_object_text_changed_cb(void *data, Evas *e EINA_UNUSED, Evas_Object *o
 static Eina_Bool
 _elm_view_widget_add(Elm_View_Form_Data *priv, const char *propname, Evas_Object *widget_obj)
 {
-   Eina_Promise *promise = NULL;
+   Efl_Future *future = NULL;
    Elm_View_Form_Widget *w = calloc(1, sizeof(Elm_View_Form_Widget));
    EINA_SAFETY_ON_NULL_RETURN_VAL(w, EINA_FALSE);
 
@@ -241,9 +240,9 @@ _elm_view_widget_add(Elm_View_Form_Data *priv, const char *propname, Evas_Object
 
    if (priv->model_obj != NULL)
      {
-         promise = efl_model_property_get(priv->model_obj, w->widget_propname);
-         eina_promise_then(promise, &_efl_promise_then_widget,
-                           &_efl_promise_error_widget, priv);
+         future = efl_model_property_get(priv->model_obj, w->widget_propname);
+         efl_future_then(future, &_efl_promise_then_widget,
+                         &_efl_promise_error_widget, NULL, priv);
      }
    return EINA_TRUE;
 }
diff --git a/src/lib/elementary/elm_view_list.c b/src/lib/elementary/elm_view_list.c
index 31407c3692..0c1ae56d9d 100644
--- a/src/lib/elementary/elm_view_list.c
+++ b/src/lib/elementary/elm_view_list.c
@@ -93,10 +93,10 @@ _item_del(void *data, Evas_Object *obj EINA_UNUSED)
 }
 
 static void
-_property_get_cb(void* data, void* v)
+_property_get_cb(void* data, Efl_Event const* event)
 {
     View_List_ValueItem *vitem = data;
-    Eina_Value *value = v;
+    Eina_Value *value = (Eina_Value*)((Efl_Future_Event_Success*)event->info)->value;
     vitem->value = eina_value_new(eina_value_type_get(value));
     eina_value_copy(value, vitem->value);
 
@@ -105,7 +105,7 @@ _property_get_cb(void* data, void* v)
 }
 
 static void
-_property_get_error_cb(void* data, Eina_Error err EINA_UNUSED)
+_property_get_error_cb(void* data, Efl_Event const* event EINA_UNUSED)
 {
     View_List_ValueItem *vitem = data;
     eina_stringshare_del(vitem->part);
@@ -144,7 +144,7 @@ _item_get_value(View_List_ItemData *idata, const char *part)
 
    if (value == NULL)
      {
-         Eina_Promise *promise;
+         Efl_Future *future;
          vitem = calloc(1, sizeof(View_List_ValueItem));
          const char *prop = eina_hash_find(idata->priv->prop_con, part);
 
@@ -153,9 +153,9 @@ _item_get_value(View_List_ItemData *idata, const char *part)
          vitem->part = eina_stringshare_add(part);
          vitem->item = idata->item;
          idata->values = eina_list_append(idata->values, vitem);
-         promise = efl_model_property_get(idata->model, prop);
-         eina_promise_then(promise, &_property_get_cb,
-                           &_property_get_error_cb, vitem);
+         future = efl_model_property_get(idata->model, prop);
+         efl_future_then(future, &_property_get_cb,
+                         &_property_get_error_cb, NULL, vitem);
      }
    else
      {
@@ -300,10 +300,10 @@ _efl_model_properties_change_cb(void *data, const Efl_Event *event)
 }
 
 static void
-_efl_model_load_children_then(void * data, void* value)
+_efl_model_load_children_then(void * data, Efl_Event const* event)
 {
    View_List_ItemData *pdata = data;
-   Eina_Accessor *accessor = value;
+   Eina_Accessor *accessor = (Eina_Accessor*)((Efl_Future_Event_Success*)event->info)->value;
    Eo *child;
    unsigned i = 0;
    EINA_SAFETY_ON_NULL_RETURN(pdata);
@@ -332,10 +332,8 @@ _efl_model_load_children_then(void * data, void* value)
 static void
 _efl_model_load_children(View_List_ItemData *pdata)
 {
-   Eina_Promise *promise;
-
-   promise = efl_model_children_slice_get(pdata->model, 0, 0);
-   eina_promise_then(promise, &_efl_model_load_children_then, NULL, pdata);
+   efl_future_then(efl_model_children_slice_get(pdata->model, 0, 0),
+                   &_efl_model_load_children_then, NULL, NULL, pdata);
 }
 
 static void