refactor(ext/http): Expose internal serveHttpOnListener API for HTTP2 (#19331)

For the first implementation of node:http2, we'll use the internal
version of `Deno.serve` which allows us to listen on a raw TCP
connection rather than a listener.

This is mostly a refactoring, and hooking up of `op_http_serve_on` that
was never previously exposed (but designed for this purpose).

1 files changed, 94 insertions, 0 deletions

diff --git a/cli/tests/unit/serve_test.ts b/cli/tests/unit/serve_test.ts
index b137ef4ff..24ae7f666 100644
--- a/cli/tests/unit/serve_test.ts
+++ b/cli/tests/unit/serve_test.ts
@@ -20,6 +20,8 @@ const servePort = 4502;
 const {
   upgradeHttpRaw,
   addTrailers,
+  serveHttpOnListener,
+  serveHttpOnConnection,
   // @ts-expect-error TypeScript (as of 3.7) does not support indexing namespaces by symbol
 } = Deno[Deno.internal];
 
@@ -165,6 +167,98 @@ Deno.test({ permissions: { net: true } }, async function httpServerBasic() {
   await server;
 });
 
+// Test serving of HTTP on an arbitrary listener.
+Deno.test(
+  { permissions: { net: true } },
+  async function httpServerOnListener() {
+    const ac = new AbortController();
+    const promise = deferred();
+    const listeningPromise = deferred();
+    const listener = Deno.listen({ port: servePort });
+    const server = serveHttpOnListener(
+      listener,
+      ac.signal,
+      async (
+        request: Request,
+        { remoteAddr }: { remoteAddr: { hostname: string } },
+      ) => {
+        assertEquals(
+          new URL(request.url).href,
+          `http://127.0.0.1:${servePort}/`,
+        );
+        assertEquals(await request.text(), "");
+        assertEquals(remoteAddr.hostname, "127.0.0.1");
+        promise.resolve();
+        return new Response("Hello World", { headers: { "foo": "bar" } });
+      },
+      createOnErrorCb(ac),
+      onListen(listeningPromise),
+    );
+
+    await listeningPromise;
+    const resp = await fetch(`http://127.0.0.1:${servePort}/`, {
+      headers: { "connection": "close" },
+    });
+    await promise;
+    const clone = resp.clone();
+    const text = await resp.text();
+    assertEquals(text, "Hello World");
+    assertEquals(resp.headers.get("foo"), "bar");
+    const cloneText = await clone.text();
+    assertEquals(cloneText, "Hello World");
+    ac.abort();
+    await server;
+  },
+);
+
+// Test serving of HTTP on an arbitrary connection.
+Deno.test(
+  { permissions: { net: true } },
+  async function httpServerOnConnection() {
+    const ac = new AbortController();
+    const promise = deferred();
+    const listeningPromise = deferred();
+    const listener = Deno.listen({ port: servePort });
+    const acceptPromise = listener.accept();
+    const fetchPromise = fetch(`http://127.0.0.1:${servePort}/`, {
+      headers: { "connection": "close" },
+    });
+
+    const server = serveHttpOnConnection(
+      await acceptPromise,
+      ac.signal,
+      async (
+        request: Request,
+        { remoteAddr }: { remoteAddr: { hostname: string } },
+      ) => {
+        assertEquals(
+          new URL(request.url).href,
+          `http://127.0.0.1:${servePort}/`,
+        );
+        assertEquals(await request.text(), "");
+        assertEquals(remoteAddr.hostname, "127.0.0.1");
+        promise.resolve();
+        return new Response("Hello World", { headers: { "foo": "bar" } });
+      },
+      createOnErrorCb(ac),
+      onListen(listeningPromise),
+    );
+
+    const resp = await fetchPromise;
+    await promise;
+    const clone = resp.clone();
+    const text = await resp.text();
+    assertEquals(text, "Hello World");
+    assertEquals(resp.headers.get("foo"), "bar");
+    const cloneText = await clone.text();
+    assertEquals(cloneText, "Hello World");
+    // Note that we don't need to abort this server -- it closes when the connection does
+    // ac.abort();
+    await server;
+    listener.close();
+  },
+);
+
 Deno.test({ permissions: { net: true } }, async function httpServerOnError() {
   const ac = new AbortController();
   const listeningPromise = deferred();