Revert json ops (#2814)

* Revert "port more ops to JSON (#2809)"

This reverts commit 137f33733d365026903d40e7cde6e34ac6c36dcf.

* Revert "port ops to JSON: compiler, errors, fetch, files (#2804)"

This reverts commit 79f82cf10ed1dbf91346994250d7311a4d74377a.

* Revert "Port rest of os ops to JSON (#2802)"

This reverts commit 5b2baa5c990fbeae747e952c5dcd7a5369e950b1.

1 files changed, 46 insertions, 52 deletions

diff --git a/cli/ops/files.rs b/cli/ops/files.rs
index c02a69b9c..023bd65f9 100644
--- a/cli/ops/files.rs
+++ b/cli/ops/files.rs
@@ -1,6 +1,5 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
 use super::dispatch_flatbuffers::serialize_response;
-use super::dispatch_json::{Deserialize, JsonOp, Value};
 use super::utils::*;
 use crate::deno_error;
 use crate::fs as deno_fs;
@@ -15,22 +14,17 @@ use std;
 use std::convert::From;
 use tokio;
 
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct OpenArgs {
-  promise_id: Option<u64>,
-  filename: String,
-  mode: String,
-}
-
 pub fn op_open(
   state: &ThreadSafeState,
-  args: Value,
-  _zero_copy: Option<PinnedBuf>,
-) -> Result<JsonOp, ErrBox> {
-  let args: OpenArgs = serde_json::from_value(args)?;
-  let (filename, filename_) = deno_fs::resolve_from_cwd(&args.filename)?;
-  let mode = args.mode.as_ref();
+  base: &msg::Base<'_>,
+  data: Option<PinnedBuf>,
+) -> CliOpResult {
+  assert!(data.is_none());
+  let cmd_id = base.cmd_id();
+  let inner = base.inner_as_open().unwrap();
+  let (filename, filename_) =
+    deno_fs::resolve_from_cwd(inner.filename().unwrap())?;
+  let mode = inner.mode().unwrap();
 
   let mut open_options = tokio::fs::OpenOptions::new();
 
@@ -81,39 +75,44 @@ pub fn op_open(
     }
   }
 
-  let is_sync = args.promise_id.is_none();
   let op = open_options.open(filename).map_err(ErrBox::from).and_then(
     move |fs_file| {
       let resource = resources::add_fs_file(fs_file);
-      futures::future::ok(json!(resource.rid))
+      let builder = &mut FlatBufferBuilder::new();
+      let inner =
+        msg::OpenRes::create(builder, &msg::OpenResArgs { rid: resource.rid });
+      Ok(serialize_response(
+        cmd_id,
+        builder,
+        msg::BaseArgs {
+          inner: Some(inner.as_union_value()),
+          inner_type: msg::Any::OpenRes,
+          ..Default::default()
+        },
+      ))
     },
   );
-
-  if is_sync {
+  if base.sync() {
     let buf = op.wait()?;
-    Ok(JsonOp::Sync(buf))
+    Ok(Op::Sync(buf))
   } else {
-    Ok(JsonOp::Async(Box::new(op)))
+    Ok(Op::Async(Box::new(op)))
   }
 }
 
-#[derive(Deserialize)]
-struct CloseArgs {
-  rid: i32,
-}
-
 pub fn op_close(
   _state: &ThreadSafeState,
-  args: Value,
-  _zero_copy: Option<PinnedBuf>,
-) -> Result<JsonOp, ErrBox> {
-  let args: CloseArgs = serde_json::from_value(args)?;
-
-  match resources::lookup(args.rid as u32) {
+  base: &msg::Base<'_>,
+  data: Option<PinnedBuf>,
+) -> CliOpResult {
+  assert!(data.is_none());
+  let inner = base.inner_as_close().unwrap();
+  let rid = inner.rid();
+  match resources::lookup(rid) {
     None => Err(deno_error::bad_resource()),
     Some(resource) => {
       resource.close();
-      Ok(JsonOp::Sync(json!({})))
+      ok_buf(empty_buf())
     }
   }
 }
@@ -203,32 +202,27 @@ pub fn op_write(
   }
 }
 
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct SeekArgs {
-  promise_id: Option<u64>,
-  rid: i32,
-  offset: i32,
-  whence: i32,
-}
-
 pub fn op_seek(
   _state: &ThreadSafeState,
-  args: Value,
-  _zero_copy: Option<PinnedBuf>,
-) -> Result<JsonOp, ErrBox> {
-  let args: SeekArgs = serde_json::from_value(args)?;
+  base: &msg::Base<'_>,
+  data: Option<PinnedBuf>,
+) -> CliOpResult {
+  assert!(data.is_none());
+  let inner = base.inner_as_seek().unwrap();
+  let rid = inner.rid();
+  let offset = inner.offset();
+  let whence = inner.whence();
 
-  match resources::lookup(args.rid as u32) {
+  match resources::lookup(rid) {
     None => Err(deno_error::bad_resource()),
     Some(resource) => {
-      let op = resources::seek(resource, args.offset, args.whence as u32)
-        .and_then(move |_| futures::future::ok(json!({})));
-      if args.promise_id.is_none() {
+      let op = resources::seek(resource, offset, whence)
+        .and_then(move |_| Ok(empty_buf()));
+      if base.sync() {
         let buf = op.wait()?;
-        Ok(JsonOp::Sync(buf))
+        Ok(Op::Sync(buf))
       } else {
-        Ok(JsonOp::Async(Box::new(op)))
+        Ok(Op::Async(Box::new(op)))
       }
     }
   }