win: move uv__process_reqs to core.c (#4821)

Refs: https://github.com/libuv/libuv/issues/4819

2 files changed, 106 insertions, 108 deletions

diff --git a/src/win/core.c b/src/win/core.c
index 5f41c87a..ec50ec47 100644
--- a/src/win/core.c
+++ b/src/win/core.c
@@ -428,6 +428,7 @@ static void uv__poll(uv_loop_t* loop, DWORD timeout) {
   BOOL success;
   uv_req_t* req;
   OVERLAPPED_ENTRY overlappeds[128];
+  OVERLAPPED* overlapped;
   ULONG count;
   ULONG i;
   int repeat;
@@ -491,7 +492,8 @@ static void uv__poll(uv_loop_t* loop, DWORD timeout) {
           if (actual_timeout == 0)
             uv__metrics_inc_events_waiting(loop, 1);
 
-          req = uv__overlapped_to_req(overlappeds[i].lpOverlapped);
+          overlapped = overlappeds[i].lpOverlapped;
+          req = container_of(overlapped, uv_req_t, u.io.overlapped);
           uv__insert_pending_req(loop, req);
         }
       }
@@ -525,6 +527,109 @@ static void uv__poll(uv_loop_t* loop, DWORD timeout) {
 }
 
 
+#define DELEGATE_STREAM_REQ(loop, req, method, handle_at)                     \
+  do {                                                                        \
+    switch (((uv_handle_t*) (req)->handle_at)->type) {                        \
+      case UV_TCP:                                                            \
+        uv__process_tcp_##method##_req(loop,                                  \
+                                      (uv_tcp_t*) ((req)->handle_at),         \
+                                      req);                                   \
+        break;                                                                \
+                                                                              \
+      case UV_NAMED_PIPE:                                                     \
+        uv__process_pipe_##method##_req(loop,                                 \
+                                       (uv_pipe_t*) ((req)->handle_at),       \
+                                       req);                                  \
+        break;                                                                \
+                                                                              \
+      case UV_TTY:                                                            \
+        uv__process_tty_##method##_req(loop,                                  \
+                                      (uv_tty_t*) ((req)->handle_at),         \
+                                      req);                                   \
+        break;                                                                \
+                                                                              \
+      default:                                                                \
+        assert(0);                                                            \
+    }                                                                         \
+  } while (0)
+
+
+static void uv__process_reqs(uv_loop_t* loop) {
+  uv_req_t* req;
+  uv_req_t* first;
+  uv_req_t* next;
+
+  if (loop->pending_reqs_tail == NULL)
+    return;
+
+  first = loop->pending_reqs_tail->next_req;
+  next = first;
+  loop->pending_reqs_tail = NULL;
+
+  while (next != NULL) {
+    req = next;
+    next = req->next_req != first ? req->next_req : NULL;
+
+    switch (req->type) {
+      case UV_READ:
+        DELEGATE_STREAM_REQ(loop, req, read, data);
+        break;
+
+      case UV_WRITE:
+        DELEGATE_STREAM_REQ(loop, (uv_write_t*) req, write, handle);
+        break;
+
+      case UV_ACCEPT:
+        DELEGATE_STREAM_REQ(loop, req, accept, data);
+        break;
+
+      case UV_CONNECT:
+        DELEGATE_STREAM_REQ(loop, (uv_connect_t*) req, connect, handle);
+        break;
+
+      case UV_SHUTDOWN:
+        DELEGATE_STREAM_REQ(loop, (uv_shutdown_t*) req, shutdown, handle);
+        break;
+
+      case UV_UDP_RECV:
+        uv__process_udp_recv_req(loop, (uv_udp_t*) req->data, req);
+        break;
+
+      case UV_UDP_SEND:
+        uv__process_udp_send_req(loop,
+                                 ((uv_udp_send_t*) req)->handle,
+                                 (uv_udp_send_t*) req);
+        break;
+
+      case UV_WAKEUP:
+        uv__process_async_wakeup_req(loop, (uv_async_t*) req->data, req);
+        break;
+
+      case UV_SIGNAL_REQ:
+        uv__process_signal_req(loop, (uv_signal_t*) req->data, req);
+        break;
+
+      case UV_POLL_REQ:
+        uv__process_poll_req(loop, (uv_poll_t*) req->data, req);
+        break;
+
+      case UV_PROCESS_EXIT:
+        uv__process_proc_exit(loop, (uv_process_t*) req->data);
+        break;
+
+      case UV_FS_EVENT_REQ:
+        uv__process_fs_event_req(loop, req, (uv_fs_event_t*) req->data);
+        break;
+
+      default:
+        assert(0);
+    }
+  }
+}
+
+#undef DELEGATE_STREAM_REQ
+
+
 int uv_run(uv_loop_t *loop, uv_run_mode mode) {
   DWORD timeout;
   int r;
diff --git a/src/win/req-inl.h b/src/win/req-inl.h
index cf16e8ba..c1ca8ea4 100644
--- a/src/win/req-inl.h
+++ b/src/win/req-inl.h
@@ -81,12 +81,6 @@
     uv_fatal_error(GetLastError(), "PostQueuedCompletionStatus");       \
   }
 
-
-INLINE static uv_req_t* uv__overlapped_to_req(OVERLAPPED* overlapped) {
-  return container_of(overlapped, uv_req_t, u.io.overlapped);
-}
-
-
 INLINE static void uv__insert_pending_req(uv_loop_t* loop, uv_req_t* req) {
   req->next_req = NULL;
   if (loop->pending_reqs_tail) {
@@ -110,105 +104,4 @@ INLINE static void uv__insert_pending_req(uv_loop_t* loop, uv_req_t* req) {
   }
 }
 
-
-#define DELEGATE_STREAM_REQ(loop, req, method, handle_at)                     \
-  do {                                                                        \
-    switch (((uv_handle_t*) (req)->handle_at)->type) {                        \
-      case UV_TCP:                                                            \
-        uv__process_tcp_##method##_req(loop,                                  \
-                                      (uv_tcp_t*) ((req)->handle_at),         \
-                                      req);                                   \
-        break;                                                                \
-                                                                              \
-      case UV_NAMED_PIPE:                                                     \
-        uv__process_pipe_##method##_req(loop,                                 \
-                                       (uv_pipe_t*) ((req)->handle_at),       \
-                                       req);                                  \
-        break;                                                                \
-                                                                              \
-      case UV_TTY:                                                            \
-        uv__process_tty_##method##_req(loop,                                  \
-                                      (uv_tty_t*) ((req)->handle_at),         \
-                                      req);                                   \
-        break;                                                                \
-                                                                              \
-      default:                                                                \
-        assert(0);                                                            \
-    }                                                                         \
-  } while (0)
-
-
-INLINE static void uv__process_reqs(uv_loop_t* loop) {
-  uv_req_t* req;
-  uv_req_t* first;
-  uv_req_t* next;
-
-  if (loop->pending_reqs_tail == NULL)
-    return;
-
-  first = loop->pending_reqs_tail->next_req;
-  next = first;
-  loop->pending_reqs_tail = NULL;
-
-  while (next != NULL) {
-    req = next;
-    next = req->next_req != first ? req->next_req : NULL;
-
-    switch (req->type) {
-      case UV_READ:
-        DELEGATE_STREAM_REQ(loop, req, read, data);
-        break;
-
-      case UV_WRITE:
-        DELEGATE_STREAM_REQ(loop, (uv_write_t*) req, write, handle);
-        break;
-
-      case UV_ACCEPT:
-        DELEGATE_STREAM_REQ(loop, req, accept, data);
-        break;
-
-      case UV_CONNECT:
-        DELEGATE_STREAM_REQ(loop, (uv_connect_t*) req, connect, handle);
-        break;
-
-      case UV_SHUTDOWN:
-        DELEGATE_STREAM_REQ(loop, (uv_shutdown_t*) req, shutdown, handle);
-        break;
-
-      case UV_UDP_RECV:
-        uv__process_udp_recv_req(loop, (uv_udp_t*) req->data, req);
-        break;
-
-      case UV_UDP_SEND:
-        uv__process_udp_send_req(loop,
-                                 ((uv_udp_send_t*) req)->handle,
-                                 (uv_udp_send_t*) req);
-        break;
-
-      case UV_WAKEUP:
-        uv__process_async_wakeup_req(loop, (uv_async_t*) req->data, req);
-        break;
-
-      case UV_SIGNAL_REQ:
-        uv__process_signal_req(loop, (uv_signal_t*) req->data, req);
-        break;
-
-      case UV_POLL_REQ:
-        uv__process_poll_req(loop, (uv_poll_t*) req->data, req);
-        break;
-
-      case UV_PROCESS_EXIT:
-        uv__process_proc_exit(loop, (uv_process_t*) req->data);
-        break;
-
-      case UV_FS_EVENT_REQ:
-        uv__process_fs_event_req(loop, req, (uv_fs_event_t*) req->data);
-        break;
-
-      default:
-        assert(0);
-    }
-  }
-}
-
 #endif /* UV_WIN_REQ_INL_H_ */