feat: add net module to utility process (#40017)

* chore: initial prototype of net api from utility process

* chore: update url loader to work on both browser and utility processes

* chore: add net files to utility process bundle

* chore: re-add app ready check but only on main process

* chore: replace browser thread dcheck's with sequence checker

* refactor: move url loader from browser to common

* refactor: move net-client-request.ts from browser to common

* docs: add utility process to net api docs

* refactor: move net module app ready check to browser only

* refactor: switch import from main to common after moving to common

* test: add basic net module test for utility process

* refactor: switch browser pid with utility pid

* refactor: move electron_api_net from browser to common

* chore: add fetch to utility net module

* chore: add isOnline and online to utility net module

* refactor: move net spec helpers into helper file

* refactor: break apart net module tests

Adds two additional net module test files: `api-net-session-spec.ts` for
tests that depend on a session being available (aka depend on running on
the main process) and `api-net-custom-protocols-spec.ts` for custom
protocol tests. This enables running `api-net-spec.ts` in the utility
process.

* test: add utility process mocha runner to run net module tests

* docs: add utility process to net module classes

* refactor: update imports in lib/utility to use electron/utility

* chore: check browser context before using in main process

Since the browser context supplied to the SimpleURLLoaderWrapper can now
be null for use in the UtilityProcess, adding a null check for the main
process before use to get a more sensible error if something goes wrong.

Co-authored-by: Cheng Zhao <github@zcbenz.com>

* chore: remove test debugging

* chore: remove unnecessary header include

* docs: add utility process net module limitations

* test: run net module tests in utility process individually

* refactor: clean up prior utility process net tests

* chore: add resolveHost to utility process net module

* chore: replace resolve host dcheck with sequence checker

* test: add net module tests for net.resolveHost

* docs: remove utility process limitation for resolveHost

---------

Co-authored-by: deepak1556 <hop2deep@gmail.com>
Co-authored-by: Cheng Zhao <github@zcbenz.com>

spec/api-net-custom-protocols-spec.ts

@@ -0,0 +1,85 @@
+import { expect } from 'chai';
+import { net, protocol } from 'electron/main';
+import * as url from 'node:url';
+import * as path from 'node:path';
+import { defer } from './lib/spec-helpers';
+
+describe('net module custom protocols', () => {
+  it('can request file:// URLs', async () => {
+    const resp = await net.fetch(url.pathToFileURL(path.join(__dirname, 'fixtures', 'hello.txt')).toString());
+    expect(resp.ok).to.be.true();
+    // trimRight instead of asserting the whole string to avoid line ending shenanigans on WOA
+    expect((await resp.text()).trimRight()).to.equal('hello world');
+  });
+
+  it('can make requests to custom protocols', async () => {
+    protocol.registerStringProtocol('electron-test', (req, cb) => { cb('hello ' + req.url); });
+    defer(() => {
+      protocol.unregisterProtocol('electron-test');
+    });
+    const body = await net.fetch('electron-test://foo').then(r => r.text());
+    expect(body).to.equal('hello electron-test://foo');
+  });
+
+  it('runs through intercept handlers', async () => {
+    protocol.interceptStringProtocol('http', (req, cb) => { cb('hello ' + req.url); });
+    defer(() => {
+      protocol.uninterceptProtocol('http');
+    });
+    const body = await net.fetch('http://foo').then(r => r.text());
+    expect(body).to.equal('hello http://foo/');
+  });
+
+  it('file: runs through intercept handlers', async () => {
+    protocol.interceptStringProtocol('file', (req, cb) => { cb('hello ' + req.url); });
+    defer(() => {
+      protocol.uninterceptProtocol('file');
+    });
+    const body = await net.fetch('file://foo').then(r => r.text());
+    expect(body).to.equal('hello file://foo/');
+  });
+
+  it('can be redirected', async () => {
+    protocol.interceptStringProtocol('file', (req, cb) => { cb({ statusCode: 302, headers: { location: 'electron-test://bar' } }); });
+    defer(() => {
+      protocol.uninterceptProtocol('file');
+    });
+    protocol.registerStringProtocol('electron-test', (req, cb) => { cb('hello ' + req.url); });
+    defer(() => {
+      protocol.unregisterProtocol('electron-test');
+    });
+    const body = await net.fetch('file://foo').then(r => r.text());
+    expect(body).to.equal('hello electron-test://bar');
+  });
+
+  it('should not follow redirect when redirect: error', async () => {
+    protocol.registerStringProtocol('electron-test', (req, cb) => {
+      if (/redirect/.test(req.url)) return cb({ statusCode: 302, headers: { location: 'electron-test://bar' } });
+      cb('hello ' + req.url);
+    });
+    defer(() => {
+      protocol.unregisterProtocol('electron-test');
+    });
+    await expect(net.fetch('electron-test://redirect', { redirect: 'error' })).to.eventually.be.rejectedWith('Attempted to redirect, but redirect policy was \'error\'');
+  });
+
+  it('a 307 redirected POST request preserves the body', async () => {
+    const bodyData = 'Hello World!';
+    let postedBodyData: any;
+    protocol.registerStringProtocol('electron-test', async (req, cb) => {
+      if (/redirect/.test(req.url)) return cb({ statusCode: 307, headers: { location: 'electron-test://bar' } });
+      postedBodyData = req.uploadData![0].bytes.toString();
+      cb('hello ' + req.url);
+    });
+    defer(() => {
+      protocol.unregisterProtocol('electron-test');
+    });
+    const response = await net.fetch('electron-test://redirect', {
+      method: 'POST',
+      body: bodyData
+    });
+    expect(response.status).to.equal(200);
+    await response.text();
+    expect(postedBodyData).to.equal(bodyData);
+  });
+});