feat(runtime): Implement classic workers

cli/main.rs

@@ -109,13 +109,15 @@ fn create_web_worker_callback(
         .log_level
         .map_or(false, |l| l == log::Level::Debug),
       unstable: program_state.flags.unstable,
+      enable_testing_features: program_state.flags.enable_testing_features,
       ca_data: program_state.ca_data.clone(),
       user_agent: version::get_user_agent(),
       seed: program_state.flags.seed,
       module_loader,
       create_web_worker_cb,
       js_error_create_fn: Some(js_error_create_fn),
       use_deno_namespace: args.use_deno_namespace,
+      worker_type: args.worker_type,
       maybe_inspector_server,
       runtime_version: version::deno(),
       ts_version: version::TYPESCRIPT.to_string(),
@@ -188,6 +190,7 @@ pub fn create_main_worker(
       .log_level
       .map_or(false, |l| l == log::Level::Debug),
     unstable: program_state.flags.unstable,
+    enable_testing_features: program_state.flags.enable_testing_features,
     ca_data: program_state.ca_data.clone(),
     user_agent: version::get_user_agent(),
     seed: program_state.flags.seed,

cli/standalone.rs

@@ -233,6 +233,7 @@ pub async fn run(
     debug_flag: metadata.log_level.map_or(false, |l| l == log::Level::Debug),
     user_agent: version::get_user_agent(),
     unstable: metadata.unstable,
+    enable_testing_features: false,
     ca_data: metadata.ca_data,
     seed: metadata.seed,
     js_error_create_fn: None,

extensions/fetch/lib.rs

@@ -54,7 +54,9 @@ use tokio::sync::mpsc;
 use tokio_stream::wrappers::ReceiverStream;
 use tokio_util::io::StreamReader;
 
-pub use reqwest; // Re-export reqwest
+// Re-export reqwest and data_url
+pub use data_url;
+pub use reqwest;
 
 pub fn init<P: FetchPermissions + 'static>(
   user_agent: String,

runtime/errors.rs

@@ -159,6 +159,9 @@ pub fn get_error_class_name(e: &AnyError) -> Option<&'static str> {
     .or_else(|| deno_webgpu::error::get_error_class_name(e))
     .or_else(|| deno_web::get_error_class_name(e))
     .or_else(|| deno_webstorage::get_not_supported_error_class_name(e))
+    .or_else(|| {
+      crate::ops::web_worker::get_dom_exception_network_error_class_name(e)
+    })
     .or_else(|| {
       e.downcast_ref::<dlopen::Error>()
         .map(get_dlopen_error_class)

runtime/examples/hello_runtime.rs

@@ -27,6 +27,7 @@ async fn main() -> Result<(), AnyError> {
     args: vec![],
     debug_flag: false,
     unstable: false,
+    enable_testing_features: false,
     ca_data: None,
     user_agent: "hello_runtime".to_string(),
     seed: None,

runtime/js/11_workers.js

@@ -7,7 +7,6 @@
     ArrayIsArray,
     ArrayPrototypeMap,
     Error,
-    Uint8Array,
     StringPrototypeStartsWith,
     String,
     SymbolIterator,
@@ -28,6 +27,7 @@
     useDenoNamespace,
     permissions,
     name,
+    workerType,
   ) {
     return core.opSync("op_create_worker", {
       hasSourceCode,
@@ -36,6 +36,7 @@
       sourceCode,
       specifier,
       useDenoNamespace,
+      workerType,
     });
   }
 
@@ -173,27 +174,29 @@
         }
       }
 
-      if (type !== "module") {
-        throw new Error(
-          'Not yet implemented: only "module" type workers are supported',
-        );
-      }
-
-      this.#name = name;
-      const hasSourceCode = false;
-      const sourceCode = core.decode(new Uint8Array());
+      const workerType = webidl.converters["WorkerType"](type);
 
       if (
         StringPrototypeStartsWith(specifier, "./") ||
         StringPrototypeStartsWith(specifier, "../") ||
-        StringPrototypeStartsWith(specifier, "/") || type == "classic"
+        StringPrototypeStartsWith(specifier, "/") || workerType === "classic"
       ) {
         const baseUrl = getLocationHref();
         if (baseUrl != null) {
           specifier = new URL(specifier, baseUrl).href;
         }
       }
 
+      this.#name = name;
+      let hasSourceCode, sourceCode;
+      if (workerType === "classic") {
+        hasSourceCode = true;
+        sourceCode = `importScripts("#");`;
+      } else {
+        hasSourceCode = false;
+        sourceCode = "";
+      }
+
       const id = createWorker(
         specifier,
         hasSourceCode,
@@ -203,6 +206,7 @@
           ? null
           : parsePermissions(workerDenoAttributes.permissions),
         options?.name,
+        workerType,
       );
       this.#id = id;
       this.#pollControl();
@@ -331,6 +335,11 @@
   defineEventHandler(Worker.prototype, "message");
   defineEventHandler(Worker.prototype, "messageerror");
 
+  webidl.converters["WorkerType"] = webidl.createEnumConverter("WorkerType", [
+    "classic",
+    "module",
+  ]);
+
   window.__bootstrap.worker = {
     parsePermissions,
     Worker,

runtime/js/99_main.js

@@ -8,6 +8,7 @@ delete Object.prototype.__proto__;
 ((window) => {
   const core = Deno.core;
   const {
+    ArrayPrototypeMap,
     Error,
     FunctionPrototypeCall,
     FunctionPrototypeBind,
@@ -161,6 +162,44 @@ delete Object.prototype.__proto__;
     }
   }
 
+  let loadedMainWorkerScript = false;
+
+  function importScripts(...urls) {
+    if (core.opSync("op_worker_get_type") === "module") {
+      throw new TypeError("Can't import scripts in a module worker.");
+    }
+
+    const baseUrl = location.getLocationHref();
+    const parsedUrls = ArrayPrototypeMap(urls, (scriptUrl) => {
+      try {
+        return new url.URL(scriptUrl, baseUrl ?? undefined).href;
+      } catch {
+        throw new domException.DOMException(
+          "Failed to parse URL.",
+          "SyntaxError",
+        );
+      }
+    });
+
+    // A classic worker's main script has looser MIME type checks than any
+    // imported scripts, so we use `loadedMainWorkerScript` to distinguish them.
+    // TODO(andreubotella) Refactor worker creation so the main script isn't
+    // loaded with `importScripts()`.
+    const scripts = core.opSync(
+      "op_worker_sync_fetch",
+      parsedUrls,
+      !loadedMainWorkerScript,
+    );
+    loadedMainWorkerScript = true;
+
+    for (const { url, script } of scripts) {
+      const err = core.evalContext(script, url)[1];
+      if (err !== null) {
+        throw err.thrown;
+      }
+    }
+  }
+
   function opMainModule() {
     return core.opSync("op_main_module");
   }
@@ -233,6 +272,12 @@ delete Object.prototype.__proto__;
         return new domException.DOMException(msg, "InvalidCharacterError");
       },
     );
+    core.registerErrorBuilder(
+      "DOMExceptionNetworkError",
+      function DOMExceptionNetworkError(msg) {
+        return new domException.DOMException(msg, "NetworkError");
+      },
+    );
   }
 
   class Navigator {
@@ -552,6 +597,13 @@ delete Object.prototype.__proto__;
     ObjectDefineProperties(globalThis, windowOrWorkerGlobalScope);
     ObjectDefineProperties(globalThis, workerRuntimeGlobalProperties);
     ObjectDefineProperties(globalThis, { name: util.readOnly(name) });
+    if (runtimeOptions.enableTestingFeaturesFlag) {
+      ObjectDefineProperty(
+        globalThis,
+        "importScripts",
+        util.writable(importScripts),
+      );
+    }
     ObjectSetPrototypeOf(globalThis, DedicatedWorkerGlobalScope.prototype);
 
     const consoleFromDeno = globalThis.console;

runtime/ops/mod.rs

@@ -85,3 +85,35 @@ pub fn check_unstable2(state: &Rc<RefCell<OpState>>, api_name: &str) {
   let state = state.borrow();
   state.borrow::<UnstableChecker>().check_unstable(api_name)
 }
+
+pub struct TestingFeatureChecker {
+  pub enable_testing_features: bool,
+}
+
+impl TestingFeatureChecker {
+  pub fn check_testing_features(&self, feature_name: &str) {
+    if !self.enable_testing_features {
+      eprintln!(
+        "Testing feature '{}'. The --enable-testing-features-do-not-use must be provided.",
+        feature_name
+      );
+      std::process::exit(70);
+    }
+  }
+}
+
+pub fn check_testing_features(state: &OpState, feature_name: &str) {
+  state
+    .borrow::<TestingFeatureChecker>()
+    .check_testing_features(feature_name)
+}
+
+pub fn check_testing_features2(
+  state: &Rc<RefCell<OpState>>,
+  feature_name: &str,
+) {
+  let state = state.borrow();
+  state
+    .borrow::<TestingFeatureChecker>()
+    .check_testing_features(feature_name)
+}

runtime/ops/web_worker.rs

@@ -1,6 +1,9 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 
+mod sync_fetch;
+
 use crate::web_worker::WebWorkerInternalHandle;
+use crate::web_worker::WebWorkerType;
 use crate::web_worker::WorkerControlEvent;
 use deno_core::error::generic_error;
 use deno_core::error::AnyError;
@@ -13,6 +16,10 @@ use deno_web::JsMessageData;
 use std::cell::RefCell;
 use std::rc::Rc;
 
+use self::sync_fetch::op_worker_sync_fetch;
+
+pub use sync_fetch::get_dom_exception_network_error_class_name;
+
 pub fn init() -> Extension {
   Extension::builder()
     .ops(vec![
@@ -25,6 +32,8 @@ pub fn init() -> Extension {
         "op_worker_unhandled_error",
         op_sync(op_worker_unhandled_error),
       ),
+      ("op_worker_get_type", op_sync(op_worker_get_type)),
+      ("op_worker_sync_fetch", op_sync(op_worker_sync_fetch)),
     ])
     .build()
 }
@@ -79,3 +88,12 @@ fn op_worker_unhandled_error(
     .expect("Failed to propagate error event to parent worker");
   Ok(())
 }
+
+fn op_worker_get_type(
+  state: &mut OpState,
+  _: (),
+  _: (),
+) -> Result<WebWorkerType, AnyError> {
+  let handle = state.borrow::<WebWorkerInternalHandle>().clone();
+  Ok(handle.worker_type)
+}