efl_net: Use the new Eina_Future API.

diff --git a/src/lib/ecore_con/ecore_con_legacy.c b/src/lib/ecore_con/ecore_con_legacy.c
index 1cb007f..ade01e2 100644 (file)
--- a/src/lib/ecore_con/ecore_con_legacy.c
+++ b/src/lib/ecore_con/ecore_con_legacy.c
@@ -31,7 +31,7 @@ struct _Ecore_Con_Server
    Eo *dialer;
    Eo *server;
    struct {
-      Efl_Future *job;
+      Eina_Future *job;
       Eina_Binbuf *pending_send; /* until job is fulfilled, no dialer exists,
                                   * this binbuf allows immediate
                                   * ecore_con_server_send() in that situation */
@@ -71,7 +71,7 @@ struct _Ecore_Con_Client
    const void *data;
    Eina_Stringshare *ip;
    struct {
-      Efl_Future *job;
+      Eina_Future *job;
       Eo *ctx;
       Eina_Bool upgrading;
    } ssl;
@@ -289,7 +289,7 @@ _ecore_con_client_free(Ecore_Con_Client *cl)
         cl->socket = NULL;
      }
 
-   if (cl->ssl.job) efl_future_cancel(cl->ssl.job);
+   if (cl->ssl.job) eina_future_cancel(cl->ssl.job);
 
    if (cl->ssl.ctx)
      {
@@ -813,8 +813,9 @@ EFL_CALLBACKS_ARRAY_DEFINE(_ecore_con_client_socket_ssl_cbs,
                            { EFL_NET_SOCKET_SSL_EVENT_SSL_READY, _ecore_con_client_socket_ssl_ready },
                            { EFL_NET_SOCKET_SSL_EVENT_SSL_ERROR, _ecore_con_client_socket_ssl_error });
 
-static void
-_ecore_con_client_ssl_upgrade_job(void *data, const Efl_Event *event EINA_UNUSED)
+static Eina_Value
+_ecore_con_client_ssl_upgrade_job(void *data, const Eina_Value v,
+                                  const Eina_Future *dead EINA_UNUSED)
 {
    Ecore_Con_Client *cl = data;
    Eo *loop = ecore_main_loop_get();
@@ -822,6 +823,9 @@ _ecore_con_client_ssl_upgrade_job(void *data, const Efl_Event *event EINA_UNUSED
    Eo *socket;
    Eo *tcp_socket;
 
+   //Canceled
+   if (v.type == EINA_VALUE_TYPE_ERROR) return v;
+
    tcp_socket = cl->socket;
    cl->socket = NULL; /* take it, will be wrapped */
 
@@ -852,7 +856,7 @@ _ecore_con_client_ssl_upgrade_job(void *data, const Efl_Event *event EINA_UNUSED
        efl_io_buffered_stream_inner_io_get(cl->socket),
        cl->ssl.ctx,
        tcp_socket);
-   return;
+   return v;
 
  error_socket:
    efl_del(inner_socket);
@@ -860,10 +864,18 @@ _ecore_con_client_ssl_upgrade_job(void *data, const Efl_Event *event EINA_UNUSED
    cl->socket = tcp_socket; /* put it back */
    if (_ecore_con_post_event_client_error(cl, "Couldn't finish SSL setup"))
      _ecore_con_post_event_client_del(cl);
+   return v;
 }
 
 static Eo * _ecore_con_server_ssl_ctx_create(const Ecore_Con_Server *svr);
 
+static void
+_ecore_con_server_job_schedule(Ecore_Con_Server *svr, Eo *loop,
+                               Eina_Future_Cb cb)
+{
+   eina_future_then(efl_loop_Eina_FutureXXX_job(loop), cb, svr, &svr->ssl.job);
+}
+
 EAPI Eina_Bool
 ecore_con_ssl_client_upgrade(Ecore_Con_Client *cl, Ecore_Con_Type compl_type)
 {
@@ -905,8 +917,9 @@ ecore_con_ssl_client_upgrade(Ecore_Con_Client *cl, Ecore_Con_Type compl_type)
 
    cl->ssl.upgrading = EINA_TRUE;
    cl->ssl.ctx = ssl_ctx;
-   efl_future_use(&cl->ssl.job, efl_loop_job(efl_loop_get(cl->socket), cl));
-   efl_future_then(cl->ssl.job, _ecore_con_client_ssl_upgrade_job, NULL, NULL, cl);
+
+   eina_future_then(efl_loop_Eina_FutureXXX_job(efl_loop_get(cl->socket)),
+                    _ecore_con_client_ssl_upgrade_job, cl, &cl->ssl.job);
 
    DBG("cl=%p SSL upgrading from %#x to type=%#x", cl, svr->type, compl_type);
 
@@ -981,7 +994,7 @@ _ecore_con_server_free(Ecore_Con_Server *svr)
         svr->ssl.clients_ctx = NULL;
      }
 
-   if (svr->ssl.job) efl_future_cancel(svr->ssl.job);
+   if (svr->ssl.job) eina_future_cancel(svr->ssl.job);
 
    if (svr->ssl.pending_send)
      {
@@ -1591,8 +1604,9 @@ _ecore_con_server_ssl_ctx_create(const Ecore_Con_Server *svr)
                   efl_net_ssl_context_setup(efl_added, cipher, EINA_FALSE));
 }
 
-static void
-_ecore_con_server_server_ssl_job(void *data, const Efl_Event *event EINA_UNUSED)
+static Eina_Value
+_ecore_con_server_server_ssl_job(void *data, const Eina_Value v,
+                                 const Eina_Future *dead EINA_UNUSED)
 {
    Ecore_Con_Server *svr = data;
    Eo *loop = ecore_main_loop_get();
@@ -1600,6 +1614,8 @@ _ecore_con_server_server_ssl_job(void *data, const Efl_Event *event EINA_UNUSED)
    Eo *inner_server;
    Eo *server;
 
+   if (v.type == EINA_VALUE_TYPE_ERROR) return v;
+
    ssl_ctx = _ecore_con_server_ssl_ctx_create(svr);
    EINA_SAFETY_ON_NULL_GOTO(ssl_ctx, error_ssl_ctx);
 
@@ -1624,12 +1640,12 @@ _ecore_con_server_server_ssl_job(void *data, const Efl_Event *event EINA_UNUSED)
        efl_net_server_simple_inner_server_get(svr->server),
        efl_net_server_ssl_context_get(efl_net_server_simple_inner_server_get(svr->server)));
 
-   return;
+   return v;
 
  error_serve:
    if (_ecore_con_post_event_server_error(svr, "Couldn't serve using SSL"))
      _ecore_con_post_event_server_del(svr);
-   return;
+   return v;
 
  error_server:
    efl_del(inner_server);
@@ -1638,6 +1654,7 @@ _ecore_con_server_server_ssl_job(void *data, const Efl_Event *event EINA_UNUSED)
  error_ssl_ctx:
    if (_ecore_con_post_event_server_error(svr, "Couldn't finish SSL setup"))
      _ecore_con_post_event_server_del(svr);
+   return v;
 }
 
 /**
@@ -1725,8 +1742,7 @@ ecore_con_server_add(Ecore_Con_Type compl_type,
          * > against loaded certificates.
          */
         svr->ssl.upgrade_type = compl_type;
-        efl_future_use(&svr->ssl.job, efl_loop_job(loop, svr));
-        efl_future_then(svr->ssl.job, _ecore_con_server_server_ssl_job, NULL, NULL, svr);
+        _ecore_con_server_job_schedule(svr, loop, _ecore_con_server_server_ssl_job);
         return svr;
      }
 
@@ -1921,8 +1937,9 @@ _ecore_con_server_dialer_set(Ecore_Con_Server *svr, Eo *dialer)
    return EINA_TRUE;
 }
 
-static void
-_ecore_con_server_dialer_ssl_job(void *data, const Efl_Event *event EINA_UNUSED)
+static Eina_Value
+_ecore_con_server_dialer_ssl_job(void *data, const Eina_Value v,
+                                 const Eina_Future *dead EINA_UNUSED)
 {
    Ecore_Con_Server *svr = data;
    Eo *loop = ecore_main_loop_get();
@@ -1993,12 +2010,12 @@ _ecore_con_server_dialer_ssl_job(void *data, const Efl_Event *event EINA_UNUSED)
         svr->ssl.pending_send = NULL;
      }
 
-   return;
+   return v;
 
  error_dial:
    if (_ecore_con_post_event_server_error(svr, "Couldn't dial using SSL"))
      _ecore_con_post_event_server_del(svr);
-   return;
+   return v;
 
  error_dialer:
    efl_del(inner_dialer);
@@ -2007,10 +2024,12 @@ _ecore_con_server_dialer_ssl_job(void *data, const Efl_Event *event EINA_UNUSED)
  error_ssl_ctx:
    if (_ecore_con_post_event_server_error(svr, "Couldn't finish SSL setup"))
      _ecore_con_post_event_server_del(svr);
+   return v;
 }
 
-static void
-_ecore_con_server_dialer_ssl_upgrade_job(void *data, const Efl_Event *event EINA_UNUSED)
+static Eina_Value
+_ecore_con_server_dialer_ssl_upgrade_job(void *data, const Eina_Value v,
+                                         const Eina_Future *dead EINA_UNUSED)
 {
    Ecore_Con_Server *svr = data;
    Eo *loop = ecore_main_loop_get();
@@ -2022,6 +2041,9 @@ _ecore_con_server_dialer_ssl_upgrade_job(void *data, const Efl_Event *event EINA
    Efl_Net_Ssl_Verify_Mode verify_mode = EFL_NET_SSL_VERIFY_MODE_NONE; /* was the default */
    Ecore_Con_Type ssl_type = svr->ssl.upgrade_type & ECORE_CON_SSL;
 
+   //Canceled
+   if (v.type == EINA_VALUE_TYPE_ERROR) return v;
+
    if (ssl_type & ECORE_CON_USE_MIXED)
      cipher = EFL_NET_SSL_CIPHER_AUTO;
    else if (ssl_type & ECORE_CON_USE_TLS)
@@ -2078,7 +2100,7 @@ _ecore_con_server_dialer_ssl_upgrade_job(void *data, const Efl_Event *event EINA
        efl_io_buffered_stream_inner_io_get(svr->dialer),
        efl_net_dialer_ssl_context_get(efl_io_buffered_stream_inner_io_get(svr->dialer)),
        tcp_dialer);
-   return;
+   return v;
 
  error_dialer:
    efl_del(inner_dialer);
@@ -2088,6 +2110,7 @@ _ecore_con_server_dialer_ssl_upgrade_job(void *data, const Efl_Event *event EINA
  error_ssl_ctx:
    if (_ecore_con_post_event_server_error(svr, "Couldn't finish SSL setup"))
      _ecore_con_post_event_server_del(svr);
+   return v;
 }
 
 /**
@@ -2174,8 +2197,7 @@ ecore_con_server_connect(Ecore_Con_Type compl_type,
          * > has started to enable verification of certificates
          * > against loaded certificates.
          */
-        efl_future_use(&svr->ssl.job, efl_loop_job(loop, svr));
-        efl_future_then(svr->ssl.job, _ecore_con_server_dialer_ssl_job, NULL, NULL, svr);
+        _ecore_con_server_job_schedule(svr, loop, _ecore_con_server_dialer_ssl_job);
         return svr;
      }
 
@@ -2535,8 +2557,9 @@ ecore_con_ssl_server_upgrade(Ecore_Con_Server *svr, Ecore_Con_Type compl_type)
 
    svr->ssl.upgrading = EINA_TRUE;
    svr->ssl.upgrade_type = compl_type;
-   efl_future_use(&svr->ssl.job, efl_loop_job(efl_loop_get(svr->dialer), svr));
-   efl_future_then(svr->ssl.job, _ecore_con_server_dialer_ssl_upgrade_job, NULL, NULL, svr);
+
+   _ecore_con_server_job_schedule(svr, efl_loop_get(svr->dialer),
+                                  _ecore_con_server_dialer_ssl_upgrade_job);
 
    DBG("svr=%p SSL upgrading from %#x to type=%#x", svr, svr->type, compl_type);
 

diff --git a/src/lib/ecore_con/efl_net_dialer_http.c b/src/lib/ecore_con/efl_net_dialer_http.c
index 064c000..4d64a20 100644 (file)
--- a/src/lib/ecore_con/efl_net_dialer_http.c
+++ b/src/lib/ecore_con/efl_net_dialer_http.c
@@ -207,7 +207,7 @@ typedef struct
       Eina_Bool verify_peer;
       Eina_Bool verify_hostname;
    } ssl;
-   Efl_Future *pending_close;
+   Eina_Future *pending_close;
    unsigned int in_curl_callback;
    SOCKET fd;
    Eina_Error error;
@@ -796,27 +796,28 @@ _efl_net_dialer_http_curl_safe_begin(Eo *o, Efl_Net_Dialer_Http_Data *pd)
    return pd->easy;
 }
 
-static void
-_efl_net_dialer_http_curl_cleanup(void *data, const Efl_Event *ev EINA_UNUSED)
+static Eina_Value
+_efl_net_dialer_http_curl_cleanup(void *data, const Eina_Value v)
 {
    CURL *easy = data;
    DBG("cleanup curl=%p", easy);
    curl_easy_cleanup(easy);
+   return v;
 }
 
-static void
-_efl_net_dialer_http_curl_cleanup_error(void *data, const Efl_Event *ev)
+static Eina_Value
+_efl_net_dialer_http_curl_cleanup_error(void *data, const Eina_Error err)
 {
-   Efl_Future_Event_Failure *failure = ev->info;
    CURL *easy = data;
-   DBG("cleanup curl=%p, promise error=%d '%s'", easy, failure->error, eina_error_msg_get(failure->error));
+   DBG("cleanup curl=%p, promise error=%d '%s'", easy, err, eina_error_msg_get(err));
    curl_easy_cleanup(easy);
+   return EINA_VALUE_EMPTY;
 }
 
 static void
 _efl_net_dialer_http_curl_safe_end(Eo *o, Efl_Net_Dialer_Http_Data *pd, CURL *easy)
 {
-   Efl_Future *f;
+   Eina_Future *f;
    int refs;
 
    refs = efl_ref_get(o);
@@ -828,7 +829,7 @@ _efl_net_dialer_http_curl_safe_end(Eo *o, Efl_Net_Dialer_Http_Data *pd, CURL *ea
      }
 
    if (pd->pending_close)
-     efl_future_cancel(pd->pending_close);
+     eina_future_cancel(pd->pending_close);
 
    if (!pd->easy)
      {
@@ -861,12 +862,10 @@ _efl_net_dialer_http_curl_safe_end(Eo *o, Efl_Net_Dialer_Http_Data *pd, CURL *ea
    /* object deleted from CURL callback, CURL* easy was
     * dissociated and we must delete it ourselves.
     */
-   f = efl_loop_job(ecore_main_loop_get(), easy);
-   efl_future_then(f,
-                   _efl_net_dialer_http_curl_cleanup,
-                   _efl_net_dialer_http_curl_cleanup_error,
-                   NULL,
-                   easy);
+   f = efl_loop_Eina_FutureXXX_job(ecore_main_loop_get());
+   eina_future_then_from_desc(f, eina_future_cb_easy(.success = _efl_net_dialer_http_curl_cleanup,
+                                                     .error = _efl_net_dialer_http_curl_cleanup_error,
+                                                     .data = easy));
    DBG("dialer=%p deleted from CURL callback, cleanup curl from job=%p.", o, f);
 }
 
@@ -1144,7 +1143,7 @@ _efl_net_dialer_http_efl_object_destructor(Eo *o, Efl_Net_Dialer_Http_Data *pd)
      }
    else if (pd->pending_close)
      {
-        efl_future_cancel(pd->pending_close);
+        eina_future_cancel(pd->pending_close);
         efl_event_freeze(o);
         efl_io_closer_close(o);
         efl_event_thaw(o);
@@ -1704,7 +1703,7 @@ _efl_net_dialer_http_efl_io_writer_can_write_set(Eo *o, Efl_Net_Dialer_Http_Data
    efl_event_callback_call(o, EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, NULL);
 }
 
-static void _efl_net_dialer_http_pending_close(void *data, const Efl_Event *ev);
+static Eina_Value _efl_net_dialer_http_pending_close(Eo *o, Eina_Value value);
 
 EOLIAN static Eina_Error
 _efl_net_dialer_http_efl_io_closer_close(Eo *o, Efl_Net_Dialer_Http_Data *pd)
@@ -1719,8 +1718,9 @@ _efl_net_dialer_http_efl_io_closer_close(Eo *o, Efl_Net_Dialer_Http_Data *pd)
      {
         if ((!pd->pending_close) && (pd->easy))
           {
-             efl_future_use(&pd->pending_close, efl_loop_job(efl_loop_get(o), o));
-             efl_future_then(pd->pending_close, _efl_net_dialer_http_pending_close, NULL, NULL, o);
+             efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_job(efl_loop_get(o)),
+                                            .success = _efl_net_dialer_http_pending_close,
+                                            .storage = &pd->pending_close);
              DBG("dialer=%p closed from CURL callback, schedule close job=%p", o, pd->pending_close);
           }
         return 0;
@@ -1751,14 +1751,13 @@ _efl_net_dialer_http_efl_io_closer_close(Eo *o, Efl_Net_Dialer_Http_Data *pd)
    return err;
 }
 
-static void
-_efl_net_dialer_http_pending_close(void *data, const Efl_Event *ev EINA_UNUSED)
+static Eina_Value
+_efl_net_dialer_http_pending_close(Eo *o, const Eina_Value value EINA_UNUSED)
 {
-   Eo *o = data;
    Efl_Net_Dialer_Http_Data *pd = efl_data_scope_get(o, MY_CLASS);
 
-   pd->pending_close = NULL; /* XXX TODO this should be NULL-ified by efl_promise before calling this function */
    _efl_net_dialer_http_efl_io_closer_close(o, pd);
+   return value;
 }
 
 EOLIAN static Eina_Bool

diff --git a/src/lib/ecore_con/efl_net_dialer_ssl.c b/src/lib/ecore_con/efl_net_dialer_ssl.c
index d873434..6bdae46 100644 (file)
--- a/src/lib/ecore_con/efl_net_dialer_ssl.c
+++ b/src/lib/ecore_con/efl_net_dialer_ssl.c
@@ -34,7 +34,7 @@ typedef struct _Efl_Net_Dialer_Ssl_Data
 {
    Eo *sock;
    Eo *ssl_ctx;
-   Efl_Future *connect_timeout;
+   Eina_Future *connect_timeout;
    Eina_Bool connected;
 } Efl_Net_Dialer_Ssl_Data;
 
@@ -136,16 +136,24 @@ _efl_net_dialer_ssl_ssl_context_get(Eo *o EINA_UNUSED, Efl_Net_Dialer_Ssl_Data *
    return pd->ssl_ctx;
 }
 
-static void
-_efl_net_dialer_ssl_connect_timeout(void *data, const Efl_Event *ev EINA_UNUSED)
+static Eina_Value
+_efl_net_dialer_ssl_connect_timeout(Eo *o, const Eina_Value v)
 {
-   Eo *o = data;
    Eina_Error err = ETIMEDOUT;
 
    efl_ref(o);
    efl_io_reader_eos_set(o, EINA_TRUE);
    efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
    efl_unref(o);
+   return v;
+}
+
+static void
+_timeout_schedule(Eo *o, Efl_Net_Dialer_Ssl_Data *pd, double timeout)
+{
+   efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_timeout(efl_loop_get(o), timeout),
+                                  .success = _efl_net_dialer_ssl_connect_timeout,
+                                  .storage = &pd->connect_timeout);
 }
 
 EOLIAN static Eina_Error
@@ -157,16 +165,10 @@ _efl_net_dialer_ssl_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Ssl_Data *pd, cons
    EINA_SAFETY_ON_TRUE_RETURN_VAL(efl_net_dialer_connected_get(o), EISCONN);
    EINA_SAFETY_ON_TRUE_RETURN_VAL(efl_io_closer_closed_get(o), EBADF);
 
-   if (pd->connect_timeout)
-     efl_future_cancel(pd->connect_timeout);
+   if (pd->connect_timeout) eina_future_cancel(pd->connect_timeout);
 
    timeout = efl_net_dialer_timeout_dial_get(pd->sock);
-   if (timeout > 0.0)
-     {
-        efl_future_use(&pd->connect_timeout, efl_loop_timeout(efl_loop_get(o), timeout, o));
-        efl_future_then(pd->connect_timeout, _efl_net_dialer_ssl_connect_timeout, NULL, NULL, o);
-        efl_future_link(o, pd->connect_timeout);
-     }
+   if (timeout > 0.0) _timeout_schedule(o, pd, timeout);
 
    return efl_net_dialer_dial(pd->sock, address);
 }
@@ -190,18 +192,13 @@ _efl_net_dialer_ssl_efl_net_dialer_proxy_get(Eo *o EINA_UNUSED, Efl_Net_Dialer_S
 }
 
 EOLIAN static void
-_efl_net_dialer_ssl_efl_net_dialer_timeout_dial_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Ssl_Data *pd, double seconds)
+_efl_net_dialer_ssl_efl_net_dialer_timeout_dial_set(Eo *o, Efl_Net_Dialer_Ssl_Data *pd, double seconds)
 {
    efl_net_dialer_timeout_dial_set(pd->sock, seconds);
 
-   if (pd->connect_timeout)
-     efl_future_cancel(pd->connect_timeout);
+   if (pd->connect_timeout) eina_future_cancel(pd->connect_timeout);
 
-   if ((seconds > 0.0) && (!pd->connected))
-     {
-        efl_future_use(&pd->connect_timeout, efl_loop_timeout(efl_loop_get(o), seconds, o));
-        efl_future_then(pd->connect_timeout, _efl_net_dialer_ssl_connect_timeout, NULL, NULL, o);
-     }
+   if ((seconds > 0.0) && (!pd->connected)) _timeout_schedule(o, pd, seconds);
 }
 
 EOLIAN static double
@@ -214,7 +211,7 @@ EOLIAN static void
 _efl_net_dialer_ssl_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Ssl_Data *pd, Eina_Bool connected)
 {
    if (pd->connect_timeout)
-     efl_future_cancel(pd->connect_timeout);
+     eina_future_cancel(pd->connect_timeout);
    if (pd->connected == connected) return;
    pd->connected = connected;
    if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);

diff --git a/src/lib/ecore_con/efl_net_dialer_tcp.c b/src/lib/ecore_con/efl_net_dialer_tcp.c
index 8806cc3..a9d87cf 100644 (file)
--- a/src/lib/ecore_con/efl_net_dialer_tcp.c
+++ b/src/lib/ecore_con/efl_net_dialer_tcp.c
@@ -34,7 +34,7 @@ typedef struct _Efl_Net_Dialer_Tcp_Data
 {
    struct {
       Ecore_Thread *thread;
-      Efl_Future *timeout;
+      Eina_Future *timeout;
    } connect;
    Eina_Stringshare *address_dial;
    Eina_Stringshare *proxy;
@@ -75,10 +75,9 @@ _efl_net_dialer_tcp_efl_object_destructor(Eo *o, Efl_Net_Dialer_Tcp_Data *pd)
    eina_stringshare_replace(&pd->proxy, NULL);
 }
 
-static void
-_efl_net_dialer_tcp_connect_timeout(void *data, const Efl_Event *ev EINA_UNUSED)
+static Eina_Value
+_efl_net_dialer_tcp_connect_timeout(Eo *o, const Eina_Value v)
 {
-   Eo *o = data;
    Efl_Net_Dialer_Tcp_Data *pd = efl_data_scope_get(o, MY_CLASS);
    Eina_Error err = ETIMEDOUT;
 
@@ -92,6 +91,15 @@ _efl_net_dialer_tcp_connect_timeout(void *data, const Efl_Event *ev EINA_UNUSED)
    efl_io_reader_eos_set(o, EINA_TRUE);
    efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
    efl_unref(o);
+   return v;
+}
+
+static void
+_timeout_schedule(Eo *o, Efl_Net_Dialer_Tcp_Data *pd)
+{
+   efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_timeout(efl_loop_get(o), pd->timeout_dial),
+                                  .success = _efl_net_dialer_tcp_connect_timeout,
+                                  .storage = &pd->connect.timeout);
 }
 
 static void
@@ -179,14 +187,8 @@ _efl_net_dialer_tcp_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Tcp_Data *pd EINA_
 
    efl_net_dialer_address_dial_set(o, address);
 
-   if (pd->connect.timeout)
-     efl_future_cancel(pd->connect.timeout);
-   if (pd->timeout_dial > 0.0)
-     {
-        efl_future_use(&pd->connect.timeout, efl_loop_timeout(efl_loop_get(o), pd->timeout_dial, o));
-        efl_future_then(pd->connect.timeout, _efl_net_dialer_tcp_connect_timeout, NULL, NULL, o);
-        efl_future_link(o, pd->connect.timeout);
-     }
+   if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout);
+   if (pd->timeout_dial > 0.0) _timeout_schedule(o, pd);
 
    return 0;
 }
@@ -219,14 +221,8 @@ EOLIAN static void
 _efl_net_dialer_tcp_efl_net_dialer_timeout_dial_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Tcp_Data *pd, double seconds)
 {
    pd->timeout_dial = seconds;
-   if (pd->connect.timeout)
-     efl_future_cancel(pd->connect.timeout);
-
-   if ((pd->timeout_dial > 0.0) && (pd->connect.thread))
-     {
-        efl_future_use(&pd->connect.timeout, efl_loop_timeout(efl_loop_get(o), pd->timeout_dial, o));
-        efl_future_then(pd->connect.timeout, _efl_net_dialer_tcp_connect_timeout, NULL, NULL, o);
-     }
+   if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout);
+   if ((pd->timeout_dial > 0.0) && (pd->connect.thread)) _timeout_schedule(o, pd);
 }
 
 EOLIAN static double
@@ -238,8 +234,7 @@ _efl_net_dialer_tcp_efl_net_dialer_timeout_dial_get(Eo *o EINA_UNUSED, Efl_Net_D
 EOLIAN static void
 _efl_net_dialer_tcp_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Tcp_Data *pd, Eina_Bool connected)
 {
-   if (pd->connect.timeout)
-     efl_future_cancel(pd->connect.timeout);
+   if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout);
    if (pd->connected == connected) return;
    pd->connected = connected;
    if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);

diff --git a/src/lib/ecore_con/efl_net_dialer_udp.c b/src/lib/ecore_con/efl_net_dialer_udp.c
index c85c770..bd2bf7e 100644 (file)
--- a/src/lib/ecore_con/efl_net_dialer_udp.c
+++ b/src/lib/ecore_con/efl_net_dialer_udp.c
@@ -35,7 +35,7 @@ typedef struct _Efl_Net_Dialer_Udp_Data
 {
    struct {
       Ecore_Thread *thread;
-      Efl_Future *timeout;
+      Eina_Future *timeout;
    } resolver;
    Eina_Stringshare *address_dial;
    Eina_Bool connected;
@@ -75,10 +75,9 @@ _efl_net_dialer_udp_efl_object_destructor(Eo *o, Efl_Net_Dialer_Udp_Data *pd)
    eina_stringshare_replace(&pd->address_dial, NULL);
 }
 
-static void
-_efl_net_dialer_udp_resolver_timeout(void *data, const Efl_Event *ev EINA_UNUSED)
+static Eina_Value
+_efl_net_dialer_udp_resolver_timeout(Eo *o, const Eina_Value v)
 {
-   Eo *o = data;
    Efl_Net_Dialer_Udp_Data *pd = efl_data_scope_get(o, MY_CLASS);
    Eina_Error err = ETIMEDOUT;
 
@@ -92,6 +91,15 @@ _efl_net_dialer_udp_resolver_timeout(void *data, const Efl_Event *ev EINA_UNUSED
    efl_io_reader_eos_set(o, EINA_TRUE);
    efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
    efl_unref(o);
+   return v;
+}
+
+static void
+_timeout_schedule(Eo *o, Efl_Net_Dialer_Udp_Data *pd)
+{
+   efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_timeout(efl_loop_get(o), pd->timeout_dial),
+                                  .success = _efl_net_dialer_udp_resolver_timeout,
+                                  .storage = &pd->resolver.timeout);
 }
 
 static Eina_Error
@@ -267,14 +275,8 @@ _efl_net_dialer_udp_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Udp_Data *pd EINA_
 
    efl_net_dialer_address_dial_set(o, address);
 
-   if (pd->resolver.timeout)
-     efl_future_cancel(pd->resolver.timeout);
-   if (pd->timeout_dial > 0.0)
-     {
-        efl_future_use(&pd->resolver.timeout, efl_loop_timeout(efl_loop_get(o), pd->timeout_dial, o));
-        efl_future_then(pd->resolver.timeout, _efl_net_dialer_udp_resolver_timeout, NULL, NULL, o);
-        efl_future_link(o, pd->resolver.timeout);
-     }
+   if (pd->resolver.timeout) eina_future_cancel(pd->resolver.timeout);
+   if (pd->timeout_dial > 0.0) _timeout_schedule(o, pd);
 
    return 0;
 }
@@ -295,14 +297,8 @@ EOLIAN static void
 _efl_net_dialer_udp_efl_net_dialer_timeout_dial_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Udp_Data *pd, double seconds)
 {
    pd->timeout_dial = seconds;
-   if (pd->resolver.timeout)
-     efl_future_cancel(pd->resolver.timeout);
-
-   if ((pd->timeout_dial > 0.0) && (pd->resolver.thread))
-     {
-        efl_future_use(&pd->resolver.timeout, efl_loop_timeout(efl_loop_get(o), pd->timeout_dial, o));
-        efl_future_then(pd->resolver.timeout, _efl_net_dialer_udp_resolver_timeout, NULL, NULL, o);
-     }
+   if (pd->resolver.timeout) eina_future_cancel(pd->resolver.timeout);
+   if ((pd->timeout_dial > 0.0) && (pd->resolver.thread)) _timeout_schedule(o, pd);
 }
 
 EOLIAN static double
@@ -314,8 +310,7 @@ _efl_net_dialer_udp_efl_net_dialer_timeout_dial_get(Eo *o EINA_UNUSED, Efl_Net_D
 EOLIAN static void
 _efl_net_dialer_udp_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Udp_Data *pd, Eina_Bool connected)
 {
-   if (pd->resolver.timeout)
-     efl_future_cancel(pd->resolver.timeout);
+   if (pd->resolver.timeout) eina_future_cancel(pd->resolver.timeout);
    if (pd->connected == connected) return;
    pd->connected = connected;
    if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);

diff --git a/src/lib/ecore_con/efl_net_dialer_unix.c b/src/lib/ecore_con/efl_net_dialer_unix.c
index 0493ff2..8a1db4b 100644 (file)
--- a/src/lib/ecore_con/efl_net_dialer_unix.c
+++ b/src/lib/ecore_con/efl_net_dialer_unix.c
@@ -25,9 +25,8 @@ typedef struct _Efl_Net_Dialer_Unix_Data
 {
    struct {
       Ecore_Thread *thread;
-      Efl_Future *timeout;
+      Eina_Future *timeout;
    } connect;
-   Efl_Future *connect_job;
    Eina_Stringshare *address_dial;
    Eina_Bool connected;
    double timeout_dial;
@@ -65,10 +64,9 @@ _efl_net_dialer_unix_efl_object_destructor(Eo *o, Efl_Net_Dialer_Unix_Data *pd)
    eina_stringshare_replace(&pd->address_dial, NULL);
 }
 
-static void
-_efl_net_dialer_unix_connect_timeout(void *data, const Efl_Event *ev EINA_UNUSED)
+static Eina_Value
+_efl_net_dialer_unix_connect_timeout(Eo *o, const Eina_Value v)
 {
-   Eo *o = data;
    Efl_Net_Dialer_Unix_Data *pd = efl_data_scope_get(o, MY_CLASS);
    Eina_Error err = ETIMEDOUT;
 
@@ -82,6 +80,7 @@ _efl_net_dialer_unix_connect_timeout(void *data, const Efl_Event *ev EINA_UNUSED
    efl_io_reader_eos_set(o, EINA_TRUE);
    efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
    efl_unref(o);
+   return v;
 }
 
 static void
@@ -121,8 +120,16 @@ _efl_net_dialer_unix_connected(void *data, const struct sockaddr *addr, socklen_
    efl_unref(o);
 }
 
+static void
+_timeout_schedule(Eo *o, Efl_Net_Dialer_Unix_Data *pd)
+{
+   efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_timeout(efl_loop_get(o), pd->timeout_dial),
+                                  .success = _efl_net_dialer_unix_connect_timeout,
+                                  .storage = &pd->connect.timeout);
+}
+
 EOLIAN static Eina_Error
-_efl_net_dialer_unix_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Unix_Data *pd EINA_UNUSED, const char *address)
+_efl_net_dialer_unix_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Unix_Data *pd, const char *address)
 {
    struct sockaddr_un addr = { .sun_family = AF_UNIX };
    socklen_t addrlen;
@@ -170,14 +177,8 @@ _efl_net_dialer_unix_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Unix_Data *pd EIN
 
    efl_net_dialer_address_dial_set(o, address);
 
-   if (pd->connect.timeout)
-     efl_future_cancel(pd->connect.timeout);
-   if (pd->timeout_dial > 0.0)
-     {
-        efl_future_use(&pd->connect.timeout, efl_loop_timeout(efl_loop_get(o), pd->timeout_dial, o));
-        efl_future_then(pd->connect.timeout, _efl_net_dialer_unix_connect_timeout, NULL, NULL, o);
-        efl_future_link(o, pd->connect.timeout);
-     }
+   if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout);
+   if (pd->timeout_dial > 0.0) _timeout_schedule(o, pd);
 
    return 0;
 }
@@ -195,17 +196,12 @@ _efl_net_dialer_unix_efl_net_dialer_address_dial_get(Eo *o EINA_UNUSED, Efl_Net_
 }
 
 EOLIAN static void
-_efl_net_dialer_unix_efl_net_dialer_timeout_dial_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Unix_Data *pd, double seconds)
+_efl_net_dialer_unix_efl_net_dialer_timeout_dial_set(Eo *o, Efl_Net_Dialer_Unix_Data *pd, double seconds)
 {
    pd->timeout_dial = seconds;
-   if (pd->connect.timeout)
-     efl_future_cancel(pd->connect.timeout);
 
-   if ((pd->timeout_dial > 0.0) && (pd->connect.thread))
-     {
-        efl_future_use(&pd->connect.timeout, efl_loop_timeout(efl_loop_get(o), pd->timeout_dial, o));
-        efl_future_then(pd->connect.timeout, _efl_net_dialer_unix_connect_timeout, NULL, NULL, o);
-     }
+   if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout);
+   if ((pd->timeout_dial > 0.0) && (pd->connect.thread)) _timeout_schedule(o, pd);
 }
 
 EOLIAN static double
@@ -217,8 +213,7 @@ _efl_net_dialer_unix_efl_net_dialer_timeout_dial_get(Eo *o EINA_UNUSED, Efl_Net_
 EOLIAN static void
 _efl_net_dialer_unix_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Unix_Data *pd, Eina_Bool connected)
 {
-   if (pd->connect.timeout)
-     efl_future_cancel(pd->connect.timeout);
+   if (pd->connect.timeout) eina_future_cancel(pd->connect.timeout);
    if (pd->connected == connected) return;
    pd->connected = connected;
    if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, NULL);

diff --git a/src/lib/ecore_con/efl_net_dialer_websocket.c b/src/lib/ecore_con/efl_net_dialer_websocket.c
index b0a9dc4..596f5b4 100644 (file)
--- a/src/lib/ecore_con/efl_net_dialer_websocket.c
+++ b/src/lib/ecore_con/efl_net_dialer_websocket.c
@@ -159,8 +159,8 @@ typedef struct _Efl_Net_Dialer_Websocket_Pending_Read {
 
 typedef struct _Efl_Net_Dialer_Websocket_Data {
    Eo *http;
-   Efl_Future *close_timeout;
-   Efl_Future *job;
+   Eina_Future *close_timeout;
+   Eina_Future *job;
    Eina_Stringshare *address_dial; /* must rewrite ws->http, wss->https */
    Eina_Stringshare *address_remote; /* must rewrite ws->http, wss->https */
    struct {
@@ -544,7 +544,7 @@ _efl_net_dialer_websocket_job_dispatch_frame(Eo *o, Efl_Net_Dialer_Websocket_Dat
            else
              efl_event_callback_call(o, EFL_IO_CLOSER_EVENT_CLOSED, NULL);
            if (pd->close_timeout)
-             efl_future_cancel(pd->close_timeout);
+             eina_future_cancel(pd->close_timeout);
            break;
         }
 
@@ -734,10 +734,9 @@ _efl_net_dialer_websocket_job_receive(Eo *o, Efl_Net_Dialer_Websocket_Data *pd)
    efl_unref(o);
 }
 
-static void
-_efl_net_dialer_websocket_job(void *data, const Efl_Event *ev EINA_UNUSED)
+static Eina_Value
+_efl_net_dialer_websocket_job(Eo *o, const Eina_Value v)
 {
-   Eo *o = data;
    Efl_Net_Dialer_Websocket_Data *pd = efl_data_scope_get(o, MY_CLASS);
 
    efl_ref(o);
@@ -752,6 +751,7 @@ _efl_net_dialer_websocket_job(void *data, const Efl_Event *ev EINA_UNUSED)
      _efl_net_dialer_websocket_job_schedule(o, pd);
 
    efl_unref(o);
+   return v;
 }
 
 static void
@@ -763,9 +763,10 @@ _efl_net_dialer_websocket_job_schedule(Eo *o, Efl_Net_Dialer_Websocket_Data *pd)
 
    loop = efl_loop_get(o);
    if (!loop) return;
-   efl_future_use(&pd->job, efl_loop_job(loop, o));
-   efl_future_then(pd->job, _efl_net_dialer_websocket_job, NULL, NULL, o);
-   efl_future_link(o, pd->job);
+
+   efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_job(loop),
+                                  .success = _efl_net_dialer_websocket_job,
+                                  .storage = &pd->job);
 }
 
 static void
@@ -1479,13 +1480,12 @@ _efl_net_dialer_websocket_binary_send(Eo *o, Efl_Net_Dialer_Websocket_Data *pd,
                                   blob.mem, blob.len);
 }
 
-static void
-_efl_net_dialer_websocket_close_request_timeout(void *data, const Efl_Event *ev EINA_UNUSED)
+static Eina_Value
+_efl_net_dialer_websocket_close_request_timeout(Eo *o, const Eina_Value v)
 {
-   Eo *o = data;
-
    DBG("server did not close the TCP socket, timeout");
    efl_event_callback_call(o, EFL_IO_CLOSER_EVENT_CLOSED, NULL);
+   return v;
 }
 
 EOLIAN static void
@@ -1497,11 +1497,11 @@ _efl_net_dialer_websocket_close_request(Eo *o, Efl_Net_Dialer_Websocket_Data *pd
    EINA_SAFETY_ON_TRUE_RETURN(pd->close_requested);
 
    if (pd->close_timeout)
-     efl_future_cancel(pd->close_timeout);
+     eina_future_cancel(pd->close_timeout);
 
-   efl_future_use(&pd->close_timeout, efl_loop_timeout(efl_loop_get(o), 2.0, o));
-   efl_future_then(pd->close_timeout, _efl_net_dialer_websocket_close_request_timeout, NULL, NULL, o);
-   efl_future_link(o, pd->close_timeout);
+   efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_timeout(efl_loop_get(o), 2.0),
+                                  .success = _efl_net_dialer_websocket_close_request_timeout,
+                                  .storage = &pd->close_timeout);
 
    efl_io_writer_can_write_set(o, EINA_FALSE);
 

diff --git a/src/lib/ecore_con/efl_net_server_windows.c b/src/lib/ecore_con/efl_net_server_windows.c
index 832782c..d588f77 100644 (file)
--- a/src/lib/ecore_con/efl_net_server_windows.c
+++ b/src/lib/ecore_con/efl_net_server_windows.c
@@ -34,7 +34,7 @@ typedef struct _Efl_Net_Server_Windows_Data
    Eina_List *pending_clients;
 
    Eina_Stringshare *address; /* includes prefix: \\.\pipe\, returned without it */
-   Efl_Future *pending_announcer_job;
+   Eina_Future *pending_announcer_job;
    unsigned int clients_count;
    unsigned int clients_limit;
    Eina_Bool clients_reject_excess;
@@ -316,22 +316,20 @@ _efl_net_server_windows_efl_net_server_address_get(Eo *o EINA_UNUSED, Efl_Net_Se
    return pd->address + strlen(PIPE_NS);
 }
 
-static void
-_efl_net_server_windows_pending_announce_job(void *data, const Efl_Event *ev EINA_UNUSED)
+static Eina_Value
+_efl_net_server_windows_pending_announce_job(Eo *o, const Eina_Value v)
 {
-   Eo *o = data;
    Efl_Net_Server_Windows_Data *pd = efl_data_scope_get(o, MY_CLASS);
    Eo *client;
 
-   pd->pending_announcer_job = NULL;
-
-   if (!pd->pending_clients) return;
-   if ((pd->clients_limit > 0) && (pd->clients_limit <= pd->clients_count)) return;
+   if (!pd->pending_clients) return v;
+   if ((pd->clients_limit > 0) && (pd->clients_limit <= pd->clients_count)) return v;
 
    client = pd->pending_clients->data;
    pd->pending_clients = eina_list_remove_list(pd->pending_clients, pd->pending_clients);
 
    efl_net_server_client_announce(o, client);
+   return v;
 }
 
 static void
@@ -345,9 +343,9 @@ _efl_net_server_windows_pending_announce_job_schedule(Eo *o, Efl_Net_Server_Wind
 
    loop = efl_loop_get(o);
    if (!loop) return;
-   efl_future_use(&pd->pending_announcer_job, efl_loop_job(loop, o));
-   efl_future_then(pd->pending_announcer_job, _efl_net_server_windows_pending_announce_job, NULL, NULL, o);
-   efl_future_link(o, pd->pending_announcer_job);
+   efl_future_Eina_FutureXXX_then(o, efl_loop_Eina_FutureXXX_job(loop),
+                                  .success = _efl_net_server_windows_pending_announce_job,
+                                  .storage = &pd->pending_announcer_job);
 }
 
 EOLIAN static void