1 files changed, 44 insertions, 39 deletions

diff --git a/cli/ops/signal.rs b/cli/ops/signal.rs
index 3868c6e17..8c0b338b3 100644
--- a/cli/ops/signal.rs
+++ b/cli/ops/signal.rs
@@ -1,26 +1,35 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use super::dispatch_json::{JsonOp, Value};
+use super::dispatch_json::Value;
 use crate::state::State;
+use deno_core::BufVec;
 use deno_core::CoreIsolate;
-use deno_core::CoreIsolateState;
 use deno_core::ErrBox;
+use deno_core::ResourceTable;
 use deno_core::ZeroCopyBuf;
+use std::cell::RefCell;
 use std::rc::Rc;
 
 #[cfg(unix)]
 use super::dispatch_json::Deserialize;
 #[cfg(unix)]
-#[cfg(unix)]
-use futures::future::{poll_fn, FutureExt};
+use futures::future::poll_fn;
 #[cfg(unix)]
 use std::task::Waker;
 #[cfg(unix)]
 use tokio::signal::unix::{signal, Signal, SignalKind};
 
 pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
-  i.register_op("op_signal_bind", s.stateful_json_op2(op_signal_bind));
-  i.register_op("op_signal_unbind", s.stateful_json_op2(op_signal_unbind));
-  i.register_op("op_signal_poll", s.stateful_json_op2(op_signal_poll));
+  let t = &CoreIsolate::state(i).borrow().resource_table.clone();
+
+  i.register_op("op_signal_bind", s.stateful_json_op_sync(t, op_signal_bind));
+  i.register_op(
+    "op_signal_unbind",
+    s.stateful_json_op_sync(t, op_signal_unbind),
+  );
+  i.register_op(
+    "op_signal_poll",
+    s.stateful_json_op_async(t, op_signal_poll),
+  );
 }
 
 #[cfg(unix)]
@@ -42,14 +51,13 @@ struct SignalArgs {
 
 #[cfg(unix)]
 fn op_signal_bind(
-  isolate_state: &mut CoreIsolateState,
-  state: &Rc<State>,
+  state: &State,
+  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
+) -> Result<Value, ErrBox> {
   state.check_unstable("Deno.signal");
   let args: BindSignalArgs = serde_json::from_value(args)?;
-  let mut resource_table = isolate_state.resource_table.borrow_mut();
   let rid = resource_table.add(
     "signal",
     Box::new(SignalStreamResource(
@@ -57,22 +65,21 @@ fn op_signal_bind(
       None,
     )),
   );
-  Ok(JsonOp::Sync(json!({
+  Ok(json!({
     "rid": rid,
-  })))
+  }))
 }
 
 #[cfg(unix)]
-fn op_signal_poll(
-  isolate_state: &mut CoreIsolateState,
-  state: &Rc<State>,
+async fn op_signal_poll(
+  state: Rc<State>,
+  resource_table: Rc<RefCell<ResourceTable>>,
   args: Value,
-  _zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
+  _zero_copy: BufVec,
+) -> Result<Value, ErrBox> {
   state.check_unstable("Deno.signal");
   let args: SignalArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
-  let resource_table = isolate_state.resource_table.clone();
 
   let future = poll_fn(move |cx| {
     let mut resource_table = resource_table.borrow_mut();
@@ -83,23 +90,21 @@ fn op_signal_poll(
       return signal.0.poll_recv(cx);
     }
     std::task::Poll::Ready(None)
-  })
-  .then(|result| async move { Ok(json!({ "done": result.is_none() })) });
-
-  Ok(JsonOp::AsyncUnref(future.boxed_local()))
+  });
+  let result = future.await;
+  Ok(json!({ "done": result.is_none() }))
 }
 
 #[cfg(unix)]
 pub fn op_signal_unbind(
-  isolate_state: &mut CoreIsolateState,
-  state: &Rc<State>,
+  state: &State,
+  resource_table: &mut ResourceTable,
   args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
+) -> Result<Value, ErrBox> {
   state.check_unstable("Deno.signal");
   let args: SignalArgs = serde_json::from_value(args)?;
   let rid = args.rid as u32;
-  let mut resource_table = isolate_state.resource_table.borrow_mut();
   let resource = resource_table.get::<SignalStreamResource>(rid);
   if let Some(signal) = resource {
     if let Some(waker) = &signal.1 {
@@ -111,35 +116,35 @@ pub fn op_signal_unbind(
   resource_table
     .close(rid)
     .ok_or_else(ErrBox::bad_resource_id)?;
-  Ok(JsonOp::Sync(json!({})))
+  Ok(json!({}))
 }
 
 #[cfg(not(unix))]
 pub fn op_signal_bind(
-  _isolate_state: &mut CoreIsolateState,
-  _state: &Rc<State>,
+  _state: &State,
+  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
+) -> Result<Value, ErrBox> {
   unimplemented!();
 }
 
 #[cfg(not(unix))]
 fn op_signal_unbind(
-  _isolate_state: &mut CoreIsolateState,
-  _state: &Rc<State>,
+  _state: &State,
+  _resource_table: &mut ResourceTable,
   _args: Value,
   _zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
+) -> Result<Value, ErrBox> {
   unimplemented!();
 }
 
 #[cfg(not(unix))]
-fn op_signal_poll(
-  _isolate_state: &mut CoreIsolateState,
-  _state: &Rc<State>,
+async fn op_signal_poll(
+  _state: Rc<State>,
+  _resource_table: Rc<RefCell<ResourceTable>>,
   _args: Value,
-  _zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, ErrBox> {
+  _zero_copy: BufVec,
+) -> Result<Value, ErrBox> {
   unimplemented!();
 }