[system] Don't throw ObjectDisposedException on cancelled async WebConnection. Fixes...

[mono.git] / mono / metadata / threadpool.c

diff --git a/mono/metadata/threadpool.c b/mono/metadata/threadpool.c
index dadaa5088722ddb1d253e3505a7e969d94b83bc3..c901d401acad6bd05f00ea1c750fab9114803b57 100644 (file)
--- a/mono/metadata/threadpool.c
+++ b/mono/metadata/threadpool.c
@@ -343,14 +343,6 @@ get_events_from_list (MonoMList *list)
        return events;
 }
 
-#define ICALL_RECV(x)  ves_icall_System_Net_Sockets_Socket_Receive_internal (\
-                               (SOCKET)(gssize)x->handle, x->buffer, x->offset, x->size,\
-                                x->socket_flags, &x->error);
-
-#define ICALL_SEND(x)  ves_icall_System_Net_Sockets_Socket_Send_internal (\
-                               (SOCKET)(gssize)x->handle, x->buffer, x->offset, x->size,\
-                                x->socket_flags, &x->error);
-
 #endif /* !DISABLE_SOCKETS */
 
 static void
@@ -1011,48 +1003,49 @@ icall_append_io_job (MonoObject *target, MonoSocketAsyncResult *state)
 }
 
 MonoAsyncResult *
-mono_thread_pool_add (MonoObject *target, MonoMethodMessage *msg, MonoDelegate *async_callback,
-                     MonoObject *state)
+mono_thread_pool_begin_invoke (MonoDomain *domain, MonoObject *target, MonoMethod *method, gpointer *params)
 {
-       MonoDomain *domain;
-       MonoAsyncResult *ares;
-       MonoAsyncCall *ac;
+       MonoMethodMessage *message;
+       MonoAsyncResult *async_result;
+       MonoAsyncCall *async_call;
+       MonoDelegate *async_callback = NULL;
+       MonoObject *state = NULL;
 
        if (use_ms_threadpool ())
-               return mono_threadpool_ms_add (target, msg, async_callback, state);
+               return mono_threadpool_ms_begin_invoke (domain, target, method, params);
 
-       domain = mono_domain_get ();
+       message = mono_method_call_message_new (method, params, mono_get_delegate_invoke (method->klass), (params != NULL) ? (&async_callback) : NULL, (params != NULL) ? (&state) : NULL);
 
-       ac = (MonoAsyncCall*)mono_object_new (domain, async_call_klass);
-       MONO_OBJECT_SETREF (ac, msg, msg);
-       MONO_OBJECT_SETREF (ac, state, state);
+       async_call = (MonoAsyncCall*)mono_object_new (domain, async_call_klass);
+       MONO_OBJECT_SETREF (async_call, msg, message);
+       MONO_OBJECT_SETREF (async_call, state, state);
 
        if (async_callback) {
-               ac->cb_method = mono_get_delegate_invoke (((MonoObject *)async_callback)->vtable->klass);
-               MONO_OBJECT_SETREF (ac, cb_target, async_callback);
+               async_call->cb_method = mono_get_delegate_invoke (((MonoObject*) async_callback)->vtable->klass);
+               MONO_OBJECT_SETREF (async_call, cb_target, async_callback);
        }
 
-       ares = mono_async_result_new (domain, NULL, ac->state, NULL, (MonoObject*)ac);
-       MONO_OBJECT_SETREF (ares, async_delegate, target);
+       async_result = mono_async_result_new (domain, NULL, async_call->state, NULL, (MonoObject*) async_call);
+       MONO_OBJECT_SETREF (async_result, async_delegate, target);
 
 #ifndef DISABLE_SOCKETS
        if (socket_io_filter (target, state)) {
-               socket_io_add (ares, (MonoSocketAsyncResult *) state);
-               return ares;
+               socket_io_add (async_result, (MonoSocketAsyncResult *) state);
+               return async_result;
        }
 #endif
-       threadpool_append_job (&async_tp, (MonoObject *) ares);
-       return ares;
+       threadpool_append_job (&async_tp, (MonoObject *) async_result);
+       return async_result;
 }
 
 MonoObject *
-mono_thread_pool_finish (MonoAsyncResult *ares, MonoArray **out_args, MonoObject **exc)
+mono_thread_pool_end_invoke (MonoAsyncResult *ares, MonoArray **out_args, MonoObject **exc)
 {
        MonoAsyncCall *ac;
        HANDLE wait_event;
 
        if (use_ms_threadpool ()) {
-               return mono_threadpool_ms_finish (ares, out_args, exc);
+               return mono_threadpool_ms_end_invoke (ares, out_args, exc);
        }
 
        *exc = NULL;
@@ -1579,14 +1572,6 @@ async_invoke_thread (gpointer data)
                                MonoSocketAsyncResult *state = (MonoSocketAsyncResult *) data;
                                is_socket = is_socketasyncresult (domain, klass);
                                ar = state->ares;
-                               switch (state->operation) {
-                               case AIO_OP_RECEIVE:
-                                       state->total = ICALL_RECV (state);
-                                       break;
-                               case AIO_OP_SEND:
-                                       state->total = ICALL_SEND (state);
-                                       break;
-                               }
                        }
 #endif
                        /* worker threads invokes methods in different domains,