6 files changed, 77 insertions, 68 deletions

diff --git a/cli/ops/errors.rs b/cli/ops/errors.rs
index dbb72139d..d9893b0ef 100644
--- a/cli/ops/errors.rs
+++ b/cli/ops/errors.rs
@@ -1,6 +1,7 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 
 use crate::diagnostics::Diagnostics;
+use crate::program_state::ProgramState;
 use crate::source_maps::get_orig_position;
 use crate::source_maps::CachedMaps;
 use deno_core::error::AnyError;
@@ -11,6 +12,7 @@ use deno_core::OpState;
 use deno_core::ZeroCopyBuf;
 use serde::Deserialize;
 use std::collections::HashMap;
+use std::sync::Arc;
 
 pub fn init(rt: &mut deno_core::JsRuntime) {
   super::reg_json_sync(rt, "op_apply_source_map", op_apply_source_map);
@@ -33,13 +35,15 @@ fn op_apply_source_map(
   let args: ApplySourceMap = serde_json::from_value(args)?;
 
   let mut mappings_map: CachedMaps = HashMap::new();
+  let program_state = state.borrow::<Arc<ProgramState>>().clone();
+
   let (orig_file_name, orig_line_number, orig_column_number) =
     get_orig_position(
       args.file_name,
       args.line_number.into(),
       args.column_number.into(),
       &mut mappings_map,
-      super::program_state(state),
+      program_state,
     );
 
   Ok(json!({
diff --git a/cli/ops/mod.rs b/cli/ops/mod.rs
index b450f8989..56c0f1ad5 100644
--- a/cli/ops/mod.rs
+++ b/cli/ops/mod.rs
@@ -27,7 +27,6 @@ pub mod websocket;
 pub mod worker_host;
 
 use crate::metrics::metrics_op;
-use crate::program_state::ProgramState;
 use deno_core::error::AnyError;
 use deno_core::json_op_async;
 use deno_core::json_op_sync;
@@ -39,7 +38,6 @@ use deno_core::ZeroCopyBuf;
 use std::cell::RefCell;
 use std::future::Future;
 use std::rc::Rc;
-use std::sync::Arc;
 
 pub fn reg_json_async<F, R>(rt: &mut JsRuntime, name: &'static str, op_fn: F)
 where
@@ -57,24 +55,33 @@ where
   rt.register_op(name, metrics_op(json_op_sync(op_fn)));
 }
 
+pub struct UnstableChecker {
+  pub unstable: bool,
+}
+
+impl UnstableChecker {
+  /// Quits the process if the --unstable flag was not provided.
+  ///
+  /// This is intentionally a non-recoverable check so that people cannot probe
+  /// for unstable APIs from stable programs.
+  // NOTE(bartlomieju): keep in sync with `cli/program_state.rs`
+  pub fn check_unstable(&self, api_name: &str) {
+    if !self.unstable {
+      eprintln!(
+        "Unstable API '{}'. The --unstable flag must be provided.",
+        api_name
+      );
+      std::process::exit(70);
+    }
+  }
+}
 /// Helper for checking unstable features. Used for sync ops.
 pub fn check_unstable(state: &OpState, api_name: &str) {
-  state.borrow::<Arc<ProgramState>>().check_unstable(api_name)
+  state.borrow::<UnstableChecker>().check_unstable(api_name)
 }
 
 /// Helper for checking unstable features. Used for async ops.
 pub fn check_unstable2(state: &Rc<RefCell<OpState>>, api_name: &str) {
   let state = state.borrow();
-  state.borrow::<Arc<ProgramState>>().check_unstable(api_name)
-}
-
-/// Helper for extracting the commonly used state. Used for sync ops.
-pub fn program_state(state: &OpState) -> Arc<ProgramState> {
-  state.borrow::<Arc<ProgramState>>().clone()
-}
-
-/// Helper for extracting the commonly used state. Used for async ops.
-pub fn global_state2(state: &Rc<RefCell<OpState>>) -> Arc<ProgramState> {
-  let state = state.borrow();
-  state.borrow::<Arc<ProgramState>>().clone()
+  state.borrow::<UnstableChecker>().check_unstable(api_name)
 }
diff --git a/cli/ops/runtime.rs b/cli/ops/runtime.rs
index 38b23f3b3..cb3b53d53 100644
--- a/cli/ops/runtime.rs
+++ b/cli/ops/runtime.rs
@@ -1,9 +1,7 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 
-use crate::colors;
 use crate::metrics::Metrics;
 use crate::permissions::Permissions;
-use crate::version;
 use deno_core::error::AnyError;
 use deno_core::serde_json;
 use deno_core::serde_json::json;
@@ -11,50 +9,17 @@ use deno_core::serde_json::Value;
 use deno_core::ModuleSpecifier;
 use deno_core::OpState;
 use deno_core::ZeroCopyBuf;
-use std::env;
 
-type ApplySourceMaps = bool;
-
-pub fn init(
-  rt: &mut deno_core::JsRuntime,
-  main_module: ModuleSpecifier,
-  apply_source_maps: bool,
-) {
+pub fn init(rt: &mut deno_core::JsRuntime, main_module: ModuleSpecifier) {
   {
     let op_state = rt.op_state();
     let mut state = op_state.borrow_mut();
     state.put::<ModuleSpecifier>(main_module);
-    state.put::<ApplySourceMaps>(apply_source_maps);
   }
-  super::reg_json_sync(rt, "op_start", op_start);
   super::reg_json_sync(rt, "op_main_module", op_main_module);
   super::reg_json_sync(rt, "op_metrics", op_metrics);
 }
 
-fn op_start(
-  state: &mut OpState,
-  _args: Value,
-  _zero_copy: &mut [ZeroCopyBuf],
-) -> Result<Value, AnyError> {
-  let apply_source_maps = *state.borrow::<ApplySourceMaps>();
-  let gs = &super::program_state(state);
-
-  Ok(json!({
-    "args": gs.flags.argv.clone(),
-    "applySourceMaps": apply_source_maps,
-    "debugFlag": gs.flags.log_level.map_or(false, |l| l == log::Level::Debug),
-    "denoVersion": version::deno(),
-    "noColor": !colors::use_color(),
-    "pid": std::process::id(),
-    "ppid": ppid(),
-    "target": env!("TARGET"),
-    "tsVersion": version::TYPESCRIPT,
-    "unstableFlag": gs.flags.unstable,
-    "v8Version": version::v8(),
-    "versionFlag": gs.flags.version,
-  }))
-}
-
 fn op_main_module(
   state: &mut OpState,
   _args: Value,
@@ -93,7 +58,7 @@ fn op_metrics(
   }))
 }
 
-fn ppid() -> Value {
+pub fn ppid() -> Value {
   #[cfg(windows)]
   {
     // Adopted from rustup:
diff --git a/cli/ops/runtime_compiler.rs b/cli/ops/runtime_compiler.rs
index f47f2fdb3..03ba88c76 100644
--- a/cli/ops/runtime_compiler.rs
+++ b/cli/ops/runtime_compiler.rs
@@ -7,10 +7,12 @@ use crate::module_graph::BundleType;
 use crate::module_graph::EmitOptions;
 use crate::module_graph::GraphBuilder;
 use crate::permissions::Permissions;
+use crate::program_state::ProgramState;
 use crate::specifier_handler::FetchHandler;
 use crate::specifier_handler::MemoryHandler;
 use crate::specifier_handler::SpecifierHandler;
 use crate::tsc_config;
+use std::sync::Arc;
 
 use deno_core::error::AnyError;
 use deno_core::error::Context;
@@ -51,7 +53,7 @@ async fn op_compile(
   } else {
     super::check_unstable2(&state, "Deno.compile");
   }
-  let program_state = super::global_state2(&state);
+  let program_state = state.borrow().borrow::<Arc<ProgramState>>().clone();
   let runtime_permissions = {
     let state = state.borrow();
     state.borrow::<Permissions>().clone()
diff --git a/cli/ops/websocket.rs b/cli/ops/websocket.rs
index c04c3b476..de6357c87 100644
--- a/cli/ops/websocket.rs
+++ b/cli/ops/websocket.rs
@@ -33,7 +33,17 @@ use tokio_tungstenite::tungstenite::{
 use tokio_tungstenite::{client_async, WebSocketStream};
 use webpki::DNSNameRef;
 
-pub fn init(rt: &mut deno_core::JsRuntime) {
+#[derive(Clone)]
+struct WsCaFile(String);
+
+pub fn init(rt: &mut deno_core::JsRuntime, maybe_ca_file: Option<&str>) {
+  {
+    let op_state = rt.op_state();
+    let mut state = op_state.borrow_mut();
+    if let Some(ca_file) = maybe_ca_file {
+      state.put::<WsCaFile>(WsCaFile(ca_file.to_string()));
+    }
+  }
   super::reg_json_sync(rt, "op_ws_check_permission", op_ws_check_permission);
   super::reg_json_async(rt, "op_ws_create", op_ws_create);
   super::reg_json_async(rt, "op_ws_send", op_ws_send);
@@ -92,10 +102,7 @@ pub async fn op_ws_create(
       );
   }
 
-  let ca_file = {
-    let program_state = super::global_state2(&state);
-    program_state.flags.ca_file.clone()
-  };
+  let maybe_ca_file = state.borrow().try_borrow::<WsCaFile>().cloned();
   let uri: Uri = args.url.parse()?;
   let mut request = Request::builder().method(Method::GET).uri(&uri);
 
@@ -128,8 +135,8 @@ pub async fn op_ws_create(
         .root_store
         .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS);
 
-      if let Some(path) = ca_file {
-        let key_file = File::open(path)?;
+      if let Some(ws_ca_file) = maybe_ca_file {
+        let key_file = File::open(ws_ca_file.0)?;
         let reader = &mut BufReader::new(key_file);
         config.root_store.add_pem_file(reader).unwrap();
       }
diff --git a/cli/ops/worker_host.rs b/cli/ops/worker_host.rs
index 6a2d79968..871e4b9fe 100644
--- a/cli/ops/worker_host.rs
+++ b/cli/ops/worker_host.rs
@@ -21,8 +21,27 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::convert::From;
 use std::rc::Rc;
+use std::sync::Arc;
 use std::thread::JoinHandle;
 
+pub struct CreateWebWorkerArgs {
+  pub name: String,
+  pub worker_id: u32,
+  pub permissions: Permissions,
+  pub main_module: ModuleSpecifier,
+  pub use_deno_namespace: bool,
+}
+
+pub type CreateWebWorkerCb =
+  dyn Fn(CreateWebWorkerArgs) -> WebWorker + Sync + Send;
+
+/// A holder for callback that is used to create a new
+/// WebWorker. It's a struct instead of a type alias
+/// because `GothamState` used in `OpState` overrides
+/// value if type alises have the same underlying type
+#[derive(Clone)]
+pub struct CreateWebWorkerCbHolder(Arc<CreateWebWorkerCb>);
+
 #[derive(Deserialize)]
 struct HostUnhandledErrorArgs {
   message: String,
@@ -31,12 +50,16 @@ struct HostUnhandledErrorArgs {
 pub fn init(
   rt: &mut deno_core::JsRuntime,
   sender: Option<mpsc::Sender<WorkerEvent>>,
+  create_web_worker_cb: Arc<CreateWebWorkerCb>,
 ) {
   {
     let op_state = rt.op_state();
     let mut state = op_state.borrow_mut();
     state.put::<WorkersTable>(WorkersTable::default());
     state.put::<WorkerId>(WorkerId::default());
+
+    let create_module_loader = CreateWebWorkerCbHolder(create_web_worker_cb);
+    state.put::<CreateWebWorkerCbHolder>(create_module_loader);
   }
   super::reg_json_sync(rt, "op_create_worker", op_create_worker);
   super::reg_json_sync(
@@ -102,11 +125,12 @@ fn op_create_worker(
   }
   let permissions = state.borrow::<Permissions>().clone();
   let worker_id = state.take::<WorkerId>();
+  let create_module_loader = state.take::<CreateWebWorkerCbHolder>();
+  state.put::<CreateWebWorkerCbHolder>(create_module_loader.clone());
   state.put::<WorkerId>(worker_id + 1);
 
   let module_specifier = ModuleSpecifier::resolve_url(&specifier)?;
   let worker_name = args_name.unwrap_or_else(|| "".to_string());
-  let program_state = super::program_state(state);
 
   let (handle_sender, handle_receiver) =
     std::sync::mpsc::sync_channel::<Result<WebWorkerHandle, AnyError>>(1);
@@ -121,14 +145,14 @@ fn op_create_worker(
     // - JS worker is useless - meaning it throws an exception and can't do anything else,
     //  all action done upon it should be noops
     // - newly spawned thread exits
-    let worker = WebWorker::new(
-      worker_name,
+
+    let worker = (create_module_loader.0)(CreateWebWorkerArgs {
+      name: worker_name,
+      worker_id,
       permissions,
-      module_specifier.clone(),
-      program_state,
+      main_module: module_specifier.clone(),
       use_deno_namespace,
-      worker_id,
-    );
+    });
 
     // Send thread safe handle to newly created worker to host thread
     handle_sender.send(Ok(worker.thread_safe_handle())).unwrap();