1 files changed, 113 insertions, 17 deletions

diff --git a/packages/main/src/infrastructure/electron/impl/ElectronServiceView.ts b/packages/main/src/infrastructure/electron/impl/ElectronServiceView.ts
index c4f7e4d..91247c8 100644
--- a/packages/main/src/infrastructure/electron/impl/ElectronServiceView.ts
+++ b/packages/main/src/infrastructure/electron/impl/ElectronServiceView.ts
@@ -18,15 +18,17 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 
-import type { BrowserViewBounds } from '@sophie/shared';
 import { BrowserView } from 'electron';
 
-import type Service from '../../../stores/Service';
-import type Resources from '../../resources/Resources';
-import type { ServiceView } from '../types';
+import type Service from '../../../stores/Service.js';
+import getLogger from '../../../utils/getLogger.js';
+import type Resources from '../../resources/Resources.js';
+import type { ServiceView } from '../types.js';
 
-import ElectronPartition from './ElectronPartition';
-import type ElectronViewFactory from './ElectronViewFactory';
+import ElectronPartition from './ElectronPartition.js';
+import type ElectronViewFactory from './ElectronViewFactory.js';
+
+const log = getLogger('ElectronServiceView');
 
 export default class ElectronServiceView implements ServiceView {
   readonly id: string;
@@ -36,7 +38,7 @@ export default class ElectronServiceView implements ServiceView {
   readonly browserView: BrowserView;
 
   constructor(
-    service: Service,
+    private readonly service: Service,
     resources: Resources,
     partition: ElectronPartition,
     private readonly parent: ElectronViewFactory,
@@ -52,6 +54,15 @@ export default class ElectronServiceView implements ServiceView {
       },
     });
 
+    this.browserView.setBackgroundColor('#fff');
+    this.browserView.setAutoResize({
+      width: true,
+      height: true,
+    });
+    // Util we first attach `browserView` to a `BrowserWindow`,
+    // `setBounds` calls will be ignored, so there's no point in callind `updateBounds` here.
+    // It will be called by `ElectronMainWindow` when we first attach this service to it.
+
     const { webContents } = this.browserView;
 
     function setLocation(url: string) {
@@ -72,20 +83,83 @@ export default class ElectronServiceView implements ServiceView {
       }
     });
 
+    webContents.on(
+      'did-fail-load',
+      (_event, errorCode, errorDesc, url, isMainFrame) => {
+        if (errorCode === -3) {
+          // Do not signal error on ABORTED, since that corresponds to an action requested by the user.
+          // Other events (`did-start-loading` or `did-stop-loading`) will cause service state changes
+          // that are appropriate for the user action.
+          log.debug('Loading', url, 'in service', this.id, 'aborted by user');
+          return;
+        }
+        if (isMainFrame) {
+          setLocation(url);
+          service.setFailed(errorCode, errorDesc);
+          log.warn(
+            'Failed to load',
+            url,
+            'in service',
+            this.id,
+            errorCode,
+            errorDesc,
+          );
+        }
+      },
+    );
+
+    /**
+     * We use the `'certificate-error'` event instead of `session.setCertificateVerifyProc`
+     * because:
+     *
+     * 1. `'certificate-error'` is bound to the `webContents`, so we can display the certificate
+     *    in the place of the correct service. Note that chromium still manages certificate trust
+     *    per session, so we can't have different trusted certificates for each service of a
+     *    profile.
+     * 2. The results of `'certificate-error'` are _not_ cached, so we can initially reject
+     *    the certificate but we can still accept it once the user trusts it temporarily.
+     */
+    webContents.on(
+      'certificate-error',
+      (event, url, error, certificate, callback, isMainFrame) => {
+        if (service.isCertificateTemporarilyTrusted(certificate)) {
+          event.preventDefault();
+          callback(true);
+          return;
+        }
+        if (isMainFrame) {
+          setLocation(url);
+          service.setCertificateError(error, certificate);
+        }
+        callback(false);
+      },
+    );
+
     webContents.on('page-title-updated', (_event, title) => {
       service.setTitle(title);
     });
 
     webContents.on('did-start-loading', () => {
-      service.startedLoading();
+      service.startLoading();
+    });
+
+    webContents.on('did-stop-loading', () => {
+      service.finishLoading();
     });
 
-    webContents.on('did-finish-load', () => {
-      service.finishedLoading();
+    webContents.on('render-process-gone', (_event, details) => {
+      const { reason, exitCode } = details;
+      service.setCrashed(reason, exitCode);
     });
 
-    webContents.on('render-process-gone', () => {
-      service.crashed();
+    webContents.setWindowOpenHandler(({ url }) => {
+      // TODO Add filtering (allowlist) by URL.
+      // TODO Handle `new-window` disposition where the service wants an object returned by
+      // `window.open`.
+      // TODO Handle downloads with `save-to-disk` disposition.
+      // TODO Handle POST bodies where the window must be allowed to open or the data is lost.
+      service.addBlockedPopup(url);
+      return { action: 'deny' };
     });
   }
 
@@ -93,8 +167,10 @@ export default class ElectronServiceView implements ServiceView {
     return this.browserView.webContents.id;
   }
 
-  loadURL(url: string): Promise<void> {
-    return this.browserView.webContents.loadURL(url);
+  loadURL(url: string): void {
+    this.browserView.webContents.loadURL(url).catch((error) => {
+      log.warn('Error while loading', url, 'in service', this.id, error);
+    });
   }
 
   goBack(): void {
@@ -105,13 +181,33 @@ export default class ElectronServiceView implements ServiceView {
     this.browserView.webContents.goForward();
   }
 
-  setBounds(bounds: BrowserViewBounds): void {
-    this.browserView.setBounds(bounds);
+  reload(ignoreCache: boolean): void {
+    if (ignoreCache) {
+      this.browserView.webContents.reloadIgnoringCache();
+    } else {
+      this.browserView.webContents.reload();
+    }
+  }
+
+  stop(): void {
+    this.browserView.webContents.stop();
+  }
+
+  toggleDeveloperTools(): void {
+    this.browserView.webContents.toggleDevTools();
+  }
+
+  updateBounds(): void {
+    const { x, y, width, height, hasBounds } = this.service;
+    if (!hasBounds) {
+      return;
+    }
+    this.browserView.setBounds({ x, y, width, height });
   }
 
   dispose(): void {
-    this.parent.unregisterServiceView(this.webContentsId);
     setImmediate(() => {
+      this.parent.unregisterServiceView(this.webContentsId);
       // Undocumented electron API, see e.g., https://github.com/electron/electron/issues/29626
       (
         this.browserView.webContents as unknown as { destroy(): void }