@cesium/engine 26.2.0 → 26.3.1-wasm.0

package/Source/Core/TaskProcessor.js

@@ -6,8 +6,9 @@ import DeveloperError from "./DeveloperError.js";
 import Event from "./Event.js";
 import FeatureDetection from "./FeatureDetection.js";
 import isCrossOriginUrl from "./isCrossOriginUrl.js";
-import Resource from "./Resource.js";
 import RuntimeError from "./RuntimeError.js";
+import TrustedServers from "./TrustedServers.js";
+import WebAssemblyWorkerInitializer from "./WebAssemblyWorkerInitializer.js";
 
 function canTransferArrayBuffer() {
   if (!defined(TaskProcessor._canTransferArrayBuffer)) {
@@ -17,6 +18,42 @@ function canTransferArrayBuffer() {
     const value = 99;
     const array = new Int8Array([value]);
 
+    let settled = false;
+    let settle;
+    const promise = new Promise((resolve) => {
+      const cleanup = () => {
+        worker.removeEventListener("message", onMessage);
+        worker.removeEventListener("error", onFailure);
+        worker.removeEventListener("messageerror", onFailure);
+        worker.terminate();
+      };
+
+      settle = (result) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        TaskProcessor._canTransferArrayBuffer = result;
+        resolve(result);
+      };
+
+      const onMessage = (event) => {
+        const array = event.data?.array;
+
+        // Verify that typed arrays round-trip correctly when transferred.
+        settle(defined(array) && array[0] === value);
+      };
+
+      const onFailure = () => settle(false);
+
+      worker.addEventListener("message", onMessage);
+      worker.addEventListener("error", onFailure);
+      worker.addEventListener("messageerror", onFailure);
+    });
+
+    TaskProcessor._canTransferArrayBuffer = promise;
+
     try {
       // postMessage might fail with a DataCloneError
       // if transferring array buffers is not supported.
@@ -27,25 +64,9 @@ function canTransferArrayBuffer() {
         [array.buffer],
       );
     } catch (e) {
-      TaskProcessor._canTransferArrayBuffer = false;
+      settle(false);
       return TaskProcessor._canTransferArrayBuffer;
     }
-
-    TaskProcessor._canTransferArrayBuffer = new Promise((resolve) => {
-      worker.onmessage = function (event) {
-        const array = event.data.array;
-
-        // some versions of Firefox silently fail to transfer typed arrays.
-        // https://bugzilla.mozilla.org/show_bug.cgi?id=841904
-        // Check to make sure the value round-trips successfully.
-        const result = defined(array) && array[0] === value;
-        resolve(result);
-
-        worker.terminate();
-
-        TaskProcessor._canTransferArrayBuffer = result;
-      };
-    });
   }
 
   return TaskProcessor._canTransferArrayBuffer;
@@ -76,7 +97,7 @@ function urlFromScript(script) {
 
 function createWorker(url) {
   const uri = new Uri(url);
-  const isUri = uri.scheme().length !== 0 && uri.fragment().length === 0;
+  const isUri = uri.scheme().length !== 0;
   const moduleID = url.replace(/\.js$/, "");
 
   const options = {};
@@ -135,35 +156,6 @@ function createWorker(url) {
   return new Worker(workerPath, options);
 }
 
-async function getWebAssemblyLoaderConfig(processor, wasmOptions) {
-  const config = {
-    modulePath: undefined,
-    wasmBinaryFile: undefined,
-    wasmBinary: undefined,
-  };
-
-  // Web assembly not supported, use fallback js module if provided
-  if (!FeatureDetection.supportsWebAssembly()) {
-    if (!defined(wasmOptions.fallbackModulePath)) {
-      throw new RuntimeError(
-        `This browser does not support Web Assembly, and no backup module was provided for ${processor._workerPath}`,
-      );
-    }
-
-    config.modulePath = buildModuleUrl(wasmOptions.fallbackModulePath);
-    return config;
-  }
-
-  config.wasmBinaryFile = buildModuleUrl(wasmOptions.wasmBinaryFile);
-
-  const arrayBuffer = await Resource.fetchArrayBuffer({
-    url: config.wasmBinaryFile,
-  });
-
-  config.wasmBinary = arrayBuffer;
-  return config;
-}
-
 /**
  * A wrapper around a web worker that allows scheduling tasks for a given worker,
  * returning results asynchronously via a promise.
@@ -183,66 +175,202 @@ function TaskProcessor(workerPath, maximumActiveTasks) {
   this._maximumActiveTasks = maximumActiveTasks ?? Number.POSITIVE_INFINITY;
   this._activeTasks = 0;
   this._nextID = 0;
-  this._webAssemblyPromise = undefined;
+  this._webAssemblyInitializer = undefined;
+  this._pendingTasks = new Map();
+  this._workerFailureHandlers = new Map();
 }
 
-const createOnmessageHandler = (worker, id, resolve, reject) => {
-  const listener = ({ data }) => {
-    if (data.id !== id) {
-      return;
+function deserializeWorkerError(serializedError) {
+  let error = serializedError;
+  if (error.name === "RuntimeError") {
+    error = new RuntimeError(serializedError.message);
+    error.stack = serializedError.stack;
+  } else if (error.name === "DeveloperError") {
+    error = new DeveloperError(serializedError.message);
+    error.stack = serializedError.stack;
+  } else if (error.name === "Error") {
+    error = new Error(serializedError.message);
+    error.stack = serializedError.stack;
+  } else if (defined(error.name) && defined(error.message)) {
+    // Any other error class the worker threw, such as the EvalError a
+    // Content-Security-Policy produces. Rebuilding it as an Error keeps the
+    // name and message legible instead of surfacing an opaque object.
+    error = new Error(`${serializedError.name}: ${serializedError.message}`);
+    error.stack = serializedError.stack;
+  }
+  return error;
+}
+
+function workerFailureToError(event) {
+  if (defined(event.error)) {
+    if (event.error instanceof Error) {
+      return event.error;
     }
 
-    if (defined(data.error)) {
-      let error = data.error;
-      if (error.name === "RuntimeError") {
-        error = new RuntimeError(data.error.message);
-        error.stack = data.error.stack;
-      } else if (error.name === "DeveloperError") {
-        error = new DeveloperError(data.error.message);
-        error.stack = data.error.stack;
-      } else if (error.name === "Error") {
-        error = new Error(data.error.message);
-        error.stack = data.error.stack;
+    if (defined(event.error.message)) {
+      const error = new Error(event.error.message);
+      if (defined(event.error.name)) {
+        error.name = event.error.name;
+      }
+      if (defined(event.error.stack)) {
+        error.stack = event.error.stack;
       }
-      taskCompletedEvent.raiseEvent(error);
-      reject(error);
-    } else {
-      taskCompletedEvent.raiseEvent();
-      resolve(data.result);
+      return error;
     }
 
-    worker.removeEventListener("message", listener);
-  };
+    return new Error(String(event.error));
+  }
 
-  return listener;
-};
+  return new Error(event.message ?? "Worker failed");
+}
+
+function removeWorkerFailureHandler(processor, worker) {
+  const handlers = processor._workerFailureHandlers;
+  if (!defined(handlers)) {
+    return;
+  }
+
+  const handler = handlers.get(worker);
+  if (!defined(handler)) {
+    return;
+  }
+
+  worker.removeEventListener("error", handler);
+  worker.removeEventListener("messageerror", handler);
+  handlers.delete(worker);
+}
+
+function settleTask(processor, id, error, result) {
+  if (!defined(processor._pendingTasks)) {
+    return;
+  }
+
+  const pendingTask = processor._pendingTasks.get(id);
+  if (!defined(pendingTask)) {
+    return;
+  }
+
+  processor._pendingTasks.delete(id);
+  pendingTask.worker.removeEventListener("message", pendingTask.listener);
+
+  if (defined(error)) {
+    taskCompletedEvent.raiseEvent(error);
+    pendingTask.reject(error);
+  } else {
+    taskCompletedEvent.raiseEvent();
+    pendingTask.resolve(result);
+  }
+}
+
+function cleanupWorker(processor, worker, error) {
+  processor._webAssemblyInitializer?.reset(worker, error);
+  removeWorkerFailureHandler(processor, worker);
+
+  if (defined(error) && defined(processor._pendingTasks)) {
+    for (const [id, pendingTask] of Array.from(
+      processor._pendingTasks.entries(),
+    )) {
+      if (pendingTask.worker === worker) {
+        settleTask(processor, id, error);
+      }
+    }
+  }
+
+  worker.terminate();
+
+  if (processor._worker === worker) {
+    processor._worker = undefined;
+  }
+}
+
+function handleWorkerFailure(processor, worker, event) {
+  const error = workerFailureToError(event);
+  cleanupWorker(processor, worker, error);
+}
+
+function createProcessorWorker(processor) {
+  const worker = createWorker(processor._workerPath);
+  const failureHandler = (event) =>
+    handleWorkerFailure(processor, worker, event);
+
+  worker.addEventListener("error", failureHandler);
+  worker.addEventListener("messageerror", failureHandler);
+  processor._workerFailureHandlers.set(worker, failureHandler);
+  return worker;
+}
+
+async function getWorker(processor) {
+  if (!defined(processor._webAssemblyInitializer)) {
+    if (!defined(processor._worker)) {
+      processor._worker = createProcessorWorker(processor);
+    }
+
+    return processor._worker;
+  }
+
+  await processor.initWebAssemblyModule();
+
+  return processor._worker;
+}
 
 const emptyTransferableObjectArray = [];
 async function runTask(processor, parameters, transferableObjects) {
-  const canTransfer = await Promise.resolve(canTransferArrayBuffer());
-  if (!defined(transferableObjects)) {
-    transferableObjects = emptyTransferableObjectArray;
-  } else if (!canTransfer) {
-    transferableObjects.length = 0;
+  const id = processor._nextID++;
+  const worker = defined(processor._webAssemblyInitializer)
+    ? await getWorker(processor)
+    : processor._worker;
+
+  if (processor.isDestroyed()) {
+    throw new RuntimeError("TaskProcessor was destroyed.");
   }
 
-  const id = processor._nextID++;
   const promise = new Promise((resolve, reject) => {
-    processor._worker.addEventListener(
-      "message",
-      createOnmessageHandler(processor._worker, id, resolve, reject),
-    );
+    const listener = ({ data }) => {
+      if (!defined(data) || data.id !== id) {
+        return;
+      }
+
+      if (defined(data.error)) {
+        settleTask(processor, id, deserializeWorkerError(data.error));
+      } else {
+        settleTask(processor, id, undefined, data.result);
+      }
+    };
+
+    processor._pendingTasks.set(id, {
+      worker: worker,
+      listener: listener,
+      resolve: resolve,
+      reject: reject,
+    });
+    worker.addEventListener("message", listener);
   });
 
-  processor._worker.postMessage(
-    {
-      id: id,
-      baseUrl: buildModuleUrl.getCesiumBaseUrl().url,
-      parameters: parameters,
-      canTransferArrayBuffer: canTransfer,
-    },
-    transferableObjects,
-  );
+  try {
+    const canTransfer = await Promise.resolve(canTransferArrayBuffer());
+    if (!processor._pendingTasks.has(id)) {
+      return promise;
+    }
+
+    if (!defined(transferableObjects)) {
+      transferableObjects = emptyTransferableObjectArray;
+    } else if (!canTransfer) {
+      transferableObjects.length = 0;
+    }
+
+    worker.postMessage(
+      {
+        id: id,
+        baseUrl: buildModuleUrl.getCesiumBaseUrl().url,
+        trustedServers: TrustedServers.pack(),
+        parameters: parameters,
+        canTransferArrayBuffer: canTransfer,
+      },
+      transferableObjects,
+    );
+  } catch (error) {
+    settleTask(processor, id, error);
+  }
 
   return promise;
 }
@@ -291,7 +419,9 @@ TaskProcessor.prototype.scheduleTask = function (
   transferableObjects,
 ) {
   if (!defined(this._worker)) {
-    this._worker = createWorker(this._workerPath);
+    if (!defined(this._webAssemblyInitializer)) {
+      this._worker = createProcessorWorker(this);
+    }
   }
 
   if (this._activeTasks >= this._maximumActiveTasks) {
@@ -306,6 +436,9 @@ TaskProcessor.prototype.scheduleTask = function (
  * and compiling a web assembly module asynchronously, as well as an optional
  * fallback JavaScript module to use if Web Assembly is not supported.
  *
+ * Only the resolved url of the binary is posted. The worker requests and compiles
+ * the bytes itself, so WebAssembly is never fetched or compiled by the document.
+ *
  * @param {object} [webAssemblyOptions] An object with the following properties:
  * @param {string} [webAssemblyOptions.modulePath] The path of the web assembly JavaScript wrapper module.
  * @param {string} [webAssemblyOptions.wasmBinaryFile] The path of the web assembly binary file.
@@ -317,46 +450,32 @@ TaskProcessor.prototype.scheduleTask = function (
 TaskProcessor.prototype.initWebAssemblyModule = async function (
   webAssemblyOptions,
 ) {
-  if (defined(this._webAssemblyPromise)) {
-    return this._webAssemblyPromise;
+  let initializer = this._webAssemblyInitializer;
+  if (defined(initializer?.promise)) {
+    return initializer.promise;
   }
 
-  const init = async () => {
-    const worker = (this._worker = createWorker(this._workerPath));
-    const wasmConfig = await getWebAssemblyLoaderConfig(
-      this,
+  if (defined(webAssemblyOptions) || !defined(initializer)) {
+    initializer = new WebAssemblyWorkerInitializer(
+      this._workerPath,
       webAssemblyOptions,
     );
-    const canTransfer = await Promise.resolve(canTransferArrayBuffer());
-    let transferableObjects;
-    const binary = wasmConfig.wasmBinary;
-    if (defined(binary) && canTransfer) {
-      transferableObjects = [binary];
-    }
-
-    const promise = new Promise((resolve, reject) => {
-      worker.onmessage = function ({ data }) {
-        if (defined(data)) {
-          resolve(data.result);
-        } else {
-          reject(new RuntimeError("Could not configure wasm module"));
-        }
-      };
-    });
+    this._webAssemblyInitializer = initializer;
+  }
 
-    worker.postMessage(
-      {
-        canTransferArrayBuffer: canTransfer,
-        parameters: { webAssemblyConfig: wasmConfig },
-      },
-      transferableObjects,
+  const worker = (this._worker = createProcessorWorker(this));
+  try {
+    return await initializer.initialize(
+      worker,
+      canTransferArrayBuffer,
+      deserializeWorkerError,
     );
-
-    return promise;
-  };
-
-  this._webAssemblyPromise = init();
-  return this._webAssemblyPromise;
+  } catch (error) {
+    if (this._workerFailureHandlers.has(worker)) {
+      cleanupWorker(this, worker, error);
+    }
+    throw error;
+  }
 };
 
 /**
@@ -380,8 +499,9 @@ TaskProcessor.prototype.isDestroyed = function () {
  * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
  */
 TaskProcessor.prototype.destroy = function () {
-  if (defined(this._worker)) {
-    this._worker.terminate();
+  const error = new RuntimeError("TaskProcessor was destroyed.");
+  for (const worker of this._workerFailureHandlers.keys()) {
+    cleanupWorker(this, worker, error);
   }
   return destroyObject(this);
 };

package/Source/Core/TrustedServers.js

@@ -85,7 +85,8 @@ function getAuthority(url) {
   if (authority.indexOf(":") === -1) {
     let scheme = uri.scheme();
     if (scheme.length === 0) {
-      scheme = window.location.protocol;
+      // `self` resolves in both a document and a Web Worker, unlike `window`.
+      scheme = self.location.protocol;
       scheme = scheme.substring(0, scheme.length - 1);
     }
     if (scheme === "http") {
@@ -133,6 +134,38 @@ TrustedServers.contains = function (url) {
   return false;
 };
 
+/**
+ * Packs the registry into an array of trusted `host:port` authorities, so it
+ * can be sent across a realm boundary (e.g. to a Web Worker) and restored
+ * with {@link TrustedServers.unpack}. `TrustedServers` is module state, so a
+ * worker's copy of this module starts with an empty registry even though the
+ * document already called {@link TrustedServers.add}.
+ *
+ * @returns {string[]} The packed array of trusted `host:port` authorities.
+ *
+ * @example
+ * // Send the registry to a worker, then restore it there
+ * worker.postMessage({ trustedServers: TrustedServers.pack() });
+ * // In the worker:
+ * TrustedServers.unpack(data.trustedServers);
+ */
+TrustedServers.pack = function () {
+  return Object.keys(_servers);
+};
+
+/**
+ * Replaces the registry with the authorities from an array packed by
+ * {@link TrustedServers.pack}.
+ *
+ * @param {string[]} packedAuthorities The packed array of trusted `host:port` authorities.
+ */
+TrustedServers.unpack = function (packedAuthorities) {
+  _servers = {};
+  for (const authority of packedAuthorities) {
+    _servers[authority] = true;
+  }
+};
+
 /**
  * Clears the registry
  *