core: snapshot improvements (#2052)

* Moves how snapshots are supplied to the Isolate. Previously they were
  given by Behavior::startup_data() but it was only called once at
  startup. It makes more sense (and simplifies Behavior) to pass it to the
  constructor of Isolate.
* Adds new libdeno type deno_snapshot instead of overloading
  deno_buf.
* Adds new libdeno method to delete snapshot deno_snapshot_delete().
* Renames deno_get_snapshot() to deno_snapshot_new().
* Makes StartupData hold references to snapshots. This was implicit when
  it previously held a deno_buf but is made explicit now. Note that
  include_bytes!() returns a &'static [u8] and we want to avoid
  copying that.

cli/cli_behavior.rs

@@ -4,24 +4,16 @@ use crate::ops;
 use deno::deno_buf;
 use deno::Behavior;
 use deno::Op;
-use deno::StartupData;
 use std::sync::Arc;
 
 /// Implements deno::Behavior for the main Deno command-line.
 pub struct CliBehavior {
-  startup_data: Option<StartupData>,
   pub state: Arc<IsolateState>,
 }
 
 impl CliBehavior {
-  pub fn new(
+  pub fn new(state: Arc<IsolateState>) -> Self {
-    startup_data: Option<StartupData>,
+    Self { state }
-    state: Arc<IsolateState>,
-  ) -> Self {
-    Self {
-      startup_data,
-      state,
-    }
   }
 }
 
@@ -38,10 +30,6 @@ impl IsolateStateContainer for CliBehavior {
 }
 
 impl Behavior for CliBehavior {
-  fn startup_data(&mut self) -> Option<StartupData> {
-    self.startup_data.take()
-  }
-
   fn dispatch(
     &mut self,
     control: &[u8],

cli/compiler.rs

@@ -17,7 +17,6 @@ use deno::Behavior;
 use deno::Buf;
 use deno::JSError;
 use deno::Op;
-use deno::StartupData;
 use futures::future::*;
 use futures::sync::oneshot;
 use futures::Future;
@@ -70,10 +69,6 @@ impl IsolateStateContainer for &CompilerBehavior {
 }
 
 impl Behavior for CompilerBehavior {
-  fn startup_data(&mut self) -> Option<StartupData> {
-    Some(startup_data::compiler_isolate_init())
-  }
-
   fn dispatch(
     &mut self,
     control: &[u8],
@@ -148,6 +143,7 @@ fn lazy_start(parent_state: Arc<IsolateState>) -> ResourceId {
   cell
     .get_or_insert_with(|| {
       let worker_result = workers::spawn(
+        startup_data::compiler_isolate_init(),
         CompilerBehavior::new(
           parent_state.flags.clone(),
           parent_state.argv.clone(),

cli/isolate.rs

@@ -13,6 +13,7 @@ use deno;
 use deno::deno_mod;
 use deno::Behavior;
 use deno::JSError;
+use deno::StartupData;
 use futures::future::Either;
 use futures::Async;
 use futures::Future;
@@ -32,10 +33,10 @@ pub struct Isolate<B: Behavior> {
 }
 
 impl<B: DenoBehavior> Isolate<B> {
-  pub fn new(behavior: B) -> Isolate<B> {
+  pub fn new(startup_data: StartupData, behavior: B) -> Isolate<B> {
     let state = behavior.state().clone();
     Self {
-      inner: CoreIsolate::new(behavior),
+      inner: CoreIsolate::new(startup_data, behavior),
       state,
     }
   }
@@ -270,8 +271,8 @@ mod tests {
     let state = Arc::new(IsolateState::new(flags, rest_argv, None, false));
     let state_ = state.clone();
     tokio_util::run(lazy(move || {
-      let cli = CliBehavior::new(None, state.clone());
+      let cli = CliBehavior::new(state.clone());
-      let mut isolate = Isolate::new(cli);
+      let mut isolate = Isolate::new(StartupData::None, cli);
       if let Err(err) = isolate.execute_mod(&filename, false) {
         eprintln!("execute_mod err {:?}", err);
       }
@@ -293,8 +294,8 @@ mod tests {
     let state = Arc::new(IsolateState::new(flags, rest_argv, None, false));
     let state_ = state.clone();
     tokio_util::run(lazy(move || {
-      let cli = CliBehavior::new(None, state.clone());
+      let cli = CliBehavior::new(state.clone());
-      let mut isolate = Isolate::new(cli);
+      let mut isolate = Isolate::new(StartupData::None, cli);
       if let Err(err) = isolate.execute_mod(&filename, false) {
         eprintln!("execute_mod err {:?}", err);
       }

cli/main.rs

@@ -107,9 +107,8 @@ fn main() {
 
   let state = Arc::new(IsolateState::new(flags, rest_argv, None, false));
   let state_ = state.clone();
-  let startup_data = startup_data::deno_isolate_init();
+  let cli = CliBehavior::new(state_);
-  let cli = CliBehavior::new(Some(startup_data), state_);
+  let mut isolate = Isolate::new(startup_data::deno_isolate_init(), cli);
-  let mut isolate = Isolate::new(cli);
 
   let main_future = lazy(move || {
     // Setup runtime.

cli/ops.rs

@@ -15,6 +15,7 @@ use crate::resolve_addr::resolve_addr;
 use crate::resources;
 use crate::resources::table_entries;
 use crate::resources::Resource;
+use crate::startup_data;
 use crate::tokio_util;
 use crate::tokio_write;
 use crate::version;
@@ -1865,6 +1866,7 @@ fn op_create_worker(
       parent_state.argv.clone(),
     );
     match workers::spawn(
+      startup_data::deno_isolate_init(),
       behavior,
       &format!("USER-WORKER-{}", specifier),
       workers::WorkerInit::Module(specifier.to_string()),

cli/startup_data.rs

@@ -1,8 +1,7 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-use deno::deno_buf;
 use deno::{Script, StartupData};
 
-pub fn deno_isolate_init() -> StartupData {
+pub fn deno_isolate_init() -> StartupData<'static> {
   if cfg!(feature = "no-snapshot-init") {
     debug!("Deno isolate init without snapshots.");
     #[cfg(not(feature = "check-only"))]
@@ -12,8 +11,8 @@ pub fn deno_isolate_init() -> StartupData {
     let source_bytes = vec![];
 
     StartupData::Script(Script {
-      filename: "gen/cli/bundle/main.js".to_string(),
+      filename: "gen/cli/bundle/main.js",
-      source: std::str::from_utf8(&source_bytes[..]).unwrap().to_string(),
+      source: std::str::from_utf8(&source_bytes[..]).unwrap(),
     })
   } else {
     debug!("Deno isolate init with snapshots.");
@@ -23,13 +22,11 @@ pub fn deno_isolate_init() -> StartupData {
     #[cfg(any(feature = "check-only", feature = "no-snapshot-init"))]
     let data = vec![];
 
-    unsafe {
+    StartupData::Snapshot(data)
-      StartupData::Snapshot(deno_buf::from_raw_parts(data.as_ptr(), data.len()))
-    }
   }
 }
 
-pub fn compiler_isolate_init() -> StartupData {
+pub fn compiler_isolate_init() -> StartupData<'static> {
   if cfg!(feature = "no-snapshot-init") {
     debug!("Compiler isolate init without snapshots.");
     #[cfg(not(feature = "check-only"))]
@@ -41,8 +38,8 @@ pub fn compiler_isolate_init() -> StartupData {
     let source_bytes = vec![];
 
     StartupData::Script(Script {
-      filename: "gen/cli/bundle/compiler.js".to_string(),
+      filename: "gen/cli/bundle/compiler.js",
-      source: std::str::from_utf8(&source_bytes[..]).unwrap().to_string(),
+      source: std::str::from_utf8(&source_bytes[..]).unwrap(),
     })
   } else {
     debug!("Deno isolate init with snapshots.");
@@ -54,8 +51,6 @@ pub fn compiler_isolate_init() -> StartupData {
     #[cfg(any(feature = "check-only", feature = "no-snapshot-init"))]
     let data = vec![];
 
-    unsafe {
+    StartupData::Snapshot(data)
-      StartupData::Snapshot(deno_buf::from_raw_parts(data.as_ptr(), data.len()))
-    }
   }
 }

cli/workers.rs

@@ -7,7 +7,6 @@ use crate::isolate_state::IsolateStateContainer;
 use crate::isolate_state::WorkerChannels;
 use crate::ops;
 use crate::resources;
-use crate::startup_data;
 use deno::deno_buf;
 use deno::Behavior;
 use deno::Buf;
@@ -44,10 +43,6 @@ impl IsolateStateContainer for &UserWorkerBehavior {
 }
 
 impl Behavior for UserWorkerBehavior {
-  fn startup_data(&mut self) -> Option<StartupData> {
-    Some(startup_data::deno_isolate_init())
-  }
-
   fn dispatch(
     &mut self,
     control: &[u8],
@@ -83,7 +78,7 @@ pub struct Worker<B: WorkerBehavior> {
 }
 
 impl<B: WorkerBehavior> Worker<B> {
-  pub fn new(mut behavior: B) -> Self {
+  pub fn new(startup_data: StartupData, mut behavior: B) -> Self {
     let (worker_in_tx, worker_in_rx) = mpsc::channel::<Buf>(1);
     let (worker_out_tx, worker_out_rx) = mpsc::channel::<Buf>(1);
 
@@ -92,7 +87,7 @@ impl<B: WorkerBehavior> Worker<B> {
 
     behavior.set_internal_channels(internal_channels);
 
-    let isolate = Isolate::new(behavior);
+    let isolate = Isolate::new(startup_data, behavior);
 
     Worker {
       isolate,
@@ -129,12 +124,13 @@ pub enum WorkerInit {
 }
 
 pub fn spawn<B: WorkerBehavior + 'static>(
+  startup_data: StartupData,
   behavior: B,
   worker_debug_name: &str,
   init: WorkerInit,
 ) -> Result<Worker<B>, RustOrJsError> {
   let state = behavior.state().clone();
-  let mut worker = Worker::new(behavior);
+  let mut worker = Worker::new(startup_data, behavior);
 
   worker
     .execute(&format!("denoMain('{}')", worker_debug_name))
@@ -172,6 +168,7 @@ mod tests {
   use crate::compiler::CompilerBehavior;
   use crate::isolate_state::IsolateState;
   use crate::js_errors::JSErrorColor;
+  use crate::startup_data;
   use crate::tokio_util;
   use futures::future::lazy;
   use std::thread;
@@ -180,6 +177,7 @@ mod tests {
   fn test_spawn() {
     tokio_util::init(|| {
       let worker_result = spawn(
+        startup_data::compiler_isolate_init(),
         CompilerBehavior::new(
           IsolateState::mock().flags.clone(),
           IsolateState::mock().argv.clone(),
@@ -242,6 +240,7 @@ mod tests {
   fn removed_from_resource_table_on_close() {
     tokio_util::init(|| {
       let worker_result = spawn(
+        startup_data::compiler_isolate_init(),
         CompilerBehavior::new(
           IsolateState::mock().flags.clone(),
           IsolateState::mock().argv.clone(),

core/http_bench.rs

@@ -99,15 +99,6 @@ pub type HttpBenchOp = dyn Future<Item = i32, Error = std::io::Error> + Send;
 struct HttpBench();
 
 impl Behavior for HttpBench {
-  fn startup_data(&mut self) -> Option<StartupData> {
-    let js_source = include_str!("http_bench.js");
-
-    Some(StartupData::Script(Script {
-      source: js_source.to_string(),
-      filename: "http_bench.js".to_string(),
-    }))
-  }
-
   fn dispatch(
     &mut self,
     control: &[u8],
@@ -168,7 +159,15 @@ fn main() {
     // TODO currently isolate.execute() must be run inside tokio, hence the
     // lazy(). It would be nice to not have that contraint. Probably requires
     // using v8::MicrotasksPolicy::kExplicit
-    let isolate = deno::Isolate::new(HttpBench());
+
+    let js_source = include_str!("http_bench.js");
+
+    let startup_data = StartupData::Script(Script {
+      source: js_source,
+      filename: "http_bench.js",
+    });
+
+    let isolate = deno::Isolate::new(startup_data, HttpBench());
 
     isolate.then(|r| {
       js_check(r);

core/isolate.rs

@@ -8,6 +8,8 @@ use crate::js_errors::JSError;
 use crate::libdeno;
 use crate::libdeno::deno_buf;
 use crate::libdeno::deno_mod;
+use crate::libdeno::Snapshot1;
+use crate::libdeno::Snapshot2;
 use crate::shared_queue::SharedQueue;
 use crate::shared_queue::RECOMMENDED_SIZE;
 use futures::Async;
@@ -16,6 +18,7 @@ use futures::Poll;
 use libc::c_void;
 use std::ffi::CStr;
 use std::ffi::CString;
+use std::ptr::null;
 use std::sync::{Arc, Mutex, Once, ONCE_INIT};
 
 pub type Buf = Box<[u8]>;
@@ -48,26 +51,24 @@ impl Future for PendingOp {
 }
 
 /// Stores a script used to initalize a Isolate
-pub struct Script {
+pub struct Script<'a> {
-  pub source: String,
+  pub source: &'a str,
-  pub filename: String,
+  pub filename: &'a str,
 }
 
 /// Represents data used to initialize isolate at startup
 /// either a binary snapshot or a javascript source file
 /// in the form of the StartupScript struct.
-pub enum StartupData {
+pub enum StartupData<'a> {
-  Script(Script),
+  Script(Script<'a>),
-  Snapshot(deno_buf),
+  Snapshot(&'a [u8]),
+  None,
 }
 
 /// Defines the behavior of an Isolate.
+// TODO(ry) Now that Behavior only has the dispatch method, it should be renamed
+// to Dispatcher.
 pub trait Behavior {
-  /// Allow for a behavior to define the snapshot or script used at
-  /// startup to initalize the isolate. Called exactly once when an
-  /// Isolate is created.
-  fn startup_data(&mut self) -> Option<StartupData>;
-
   /// Called whenever Deno.core.dispatch() is called in JavaScript. zero_copy_buf
   /// corresponds to the second argument of Deno.core.dispatch().
   fn dispatch(
@@ -109,7 +110,9 @@ impl<B: Behavior> Drop for Isolate<B> {
 static DENO_INIT: Once = ONCE_INIT;
 
 impl<B: Behavior> Isolate<B> {
-  pub fn new(mut behavior: B) -> Self {
+  /// startup_data defines the snapshot or script used at startup to initalize
+  /// the isolate.
+  pub fn new(startup_data: StartupData, behavior: B) -> Self {
     DENO_INIT.call_once(|| {
       unsafe { libdeno::deno_init() };
     });
@@ -118,16 +121,16 @@ impl<B: Behavior> Isolate<B> {
 
     let needs_init = true;
     // Seperate into Option values for eatch startup type
-    let (startup_snapshot, startup_script) = match behavior.startup_data() {
+    let (startup_snapshot, startup_script) = match startup_data {
-      Some(StartupData::Snapshot(d)) => (Some(d), None),
+      StartupData::Snapshot(d) => (Some(d), None),
-      Some(StartupData::Script(d)) => (None, Some(d)),
+      StartupData::Script(d) => (None, Some(d)),
-      None => (None, None),
+      StartupData::None => (None, None),
     };
     let config = libdeno::deno_config {
       will_snapshot: 0,
       load_snapshot: match startup_snapshot {
-        Some(s) => s,
+        Some(s) => Snapshot2::from(s),
-        None => libdeno::deno_buf::empty(),
+        None => Snapshot2::empty(),
       },
       shared: shared.as_deno_buf(),
       recv_cb: Self::pre_dispatch,
@@ -146,9 +149,7 @@ impl<B: Behavior> Isolate<B> {
 
     // If we want to use execute this has to happen here sadly.
     if let Some(s) = startup_script {
-      core_isolate
+      core_isolate.execute(s.filename, s.source).unwrap()
-        .execute(s.filename.as_str(), s.source.as_str())
-        .unwrap()
     };
 
     core_isolate
@@ -329,6 +330,18 @@ impl<B: Behavior> Isolate<B> {
     }
     out
   }
+
+  pub fn snapshot_new(&self) -> Result<Snapshot1, JSError> {
+    let snapshot = unsafe { libdeno::deno_snapshot_new(self.libdeno_isolate) };
+    if let Some(js_error) = self.last_exception() {
+      assert_eq!(snapshot.data_ptr, null());
+      assert_eq!(snapshot.data_len, 0);
+      return Err(js_error);
+    }
+    assert_ne!(snapshot.data_ptr, null());
+    assert_ne!(snapshot.data_len, 0);
+    Ok(snapshot)
+  }
 }
 
 /// Called during mod_instantiate() to resolve imports.
@@ -546,10 +559,13 @@ pub mod tests {
 
   impl TestBehavior {
     pub fn setup(mode: TestBehaviorMode) -> Isolate<Self> {
-      let mut isolate = Isolate::new(TestBehavior {
+      let mut isolate = Isolate::new(
+        StartupData::None,
+        TestBehavior {
           dispatch_count: 0,
           mode,
-      });
+        },
+      );
       js_check(isolate.execute(
         "setup.js",
         r#"
@@ -566,10 +582,6 @@ pub mod tests {
   }
 
   impl Behavior for TestBehavior {
-    fn startup_data(&mut self) -> Option<StartupData> {
-      None
-    }
-
     fn dispatch(
       &mut self,
       control: &[u8],

core/libdeno.rs

@@ -4,6 +4,7 @@ use libc::c_char;
 use libc::c_int;
 use libc::c_void;
 use libc::size_t;
+use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 use std::ptr::null;
 
@@ -108,6 +109,56 @@ impl AsMut<[u8]> for deno_buf {
   }
 }
 
+#[repr(C)]
+pub struct deno_snapshot<'a> {
+  pub data_ptr: *const u8,
+  pub data_len: usize,
+  _marker: PhantomData<&'a [u8]>,
+}
+
+/// `deno_snapshot` can not clone, and there is no interior mutability.
+/// This type satisfies Send bound.
+unsafe impl Send for deno_snapshot<'_> {}
+
+// TODO(ry) Snapshot1 and Snapshot2 are not very good names and need to be
+// reconsidered. The entire snapshotting interface is still under construction.
+
+/// The type returned from deno_snapshot_new. Needs to be dropped.
+pub type Snapshot1<'a> = deno_snapshot<'a>;
+
+// TODO Does this make sense?
+impl Drop for Snapshot1<'_> {
+  fn drop(&mut self) {
+    unsafe { deno_snapshot_delete(self) }
+  }
+}
+
+/// The type created from slice. Used for loading.
+pub type Snapshot2<'a> = deno_snapshot<'a>;
+
+/// Converts Rust &Buf to libdeno `deno_buf`.
+impl<'a> From<&'a [u8]> for Snapshot2<'a> {
+  #[inline]
+  fn from(x: &'a [u8]) -> Self {
+    Self {
+      data_ptr: x.as_ref().as_ptr(),
+      data_len: x.len(),
+      _marker: PhantomData,
+    }
+  }
+}
+
+impl Snapshot2<'_> {
+  #[inline]
+  pub fn empty() -> Self {
+    Self {
+      data_ptr: null(),
+      data_len: 0,
+      _marker: PhantomData,
+    }
+  }
+}
+
 #[allow(non_camel_case_types)]
 type deno_recv_cb = unsafe extern "C" fn(
   user_data: *mut c_void,
@@ -126,9 +177,9 @@ type deno_resolve_cb = unsafe extern "C" fn(
 ) -> deno_mod;
 
 #[repr(C)]
-pub struct deno_config {
+pub struct deno_config<'a> {
   pub will_snapshot: c_int,
-  pub load_snapshot: deno_buf,
+  pub load_snapshot: Snapshot2<'a>,
   pub shared: deno_buf,
   pub recv_cb: deno_recv_cb,
 }
@@ -214,4 +265,9 @@ extern "C" {
     user_data: *const c_void,
     id: deno_mod,
   );
+
+  pub fn deno_snapshot_new(i: *const isolate) -> Snapshot1<'static>;
+
+  #[allow(dead_code)]
+  pub fn deno_snapshot_delete(s: &mut deno_snapshot);
 }

core/libdeno/api.cc

@@ -93,7 +93,7 @@ void deno_unlock(Deno* d_) {
   d->locker_ = nullptr;
 }
 
-deno_buf deno_get_snapshot(Deno* d_) {
+deno_snapshot deno_snapshot_new(Deno* d_) {
   auto* d = unwrap(d_);
   CHECK_NOT_NULL(d->snapshot_creator_);
   d->ClearModules();
@@ -101,8 +101,12 @@ deno_buf deno_get_snapshot(Deno* d_) {
 
   auto blob = d->snapshot_creator_->CreateBlob(
       v8::SnapshotCreator::FunctionCodeHandling::kKeep);
-  return {nullptr, 0, reinterpret_cast<uint8_t*>(const_cast<char*>(blob.data)),
+  return {reinterpret_cast<uint8_t*>(const_cast<char*>(blob.data)),
-          blob.raw_size, 0};
+          blob.raw_size};
+}
+
+void deno_snapshot_delete(deno_snapshot snapshot) {
+  delete[] snapshot.data_ptr;
 }
 
 static std::unique_ptr<v8::Platform> platform;

core/libdeno/deno.h

@@ -18,6 +18,11 @@ typedef struct {
   size_t zero_copy_id;  // 0 = normal, 1 = must call deno_zero_copy_release.
 } deno_buf;
 
+typedef struct {
+  uint8_t* data_ptr;
+  size_t data_len;
+} deno_snapshot;
+
 typedef struct deno_s Deno;
 
 // A callback to receive a message from a libdeno.send() javascript call.
@@ -31,23 +36,28 @@ const char* deno_v8_version();
 void deno_set_v8_flags(int* argc, char** argv);
 
 typedef struct {
-  int will_snapshot;       // Default 0. If calling deno_get_snapshot 1.
+  int will_snapshot;            // Default 0. If calling deno_snapshot_new 1.
-  deno_buf load_snapshot;  // Optionally: A deno_buf from deno_get_snapshot.
+  deno_snapshot load_snapshot;  // A startup snapshot to use.
   deno_buf shared;              // Shared buffer to be mapped to libdeno.shared
   deno_recv_cb recv_cb;         // Maps to libdeno.send() calls.
 } deno_config;
 
 // Create a new deno isolate.
-// Warning: If config.will_snapshot is set, deno_get_snapshot() must be called
+// Warning: If config.will_snapshot is set, deno_snapshot_new() must be called
 // or an error will result.
 Deno* deno_new(deno_config config);
-
-// Generate a snapshot. The resulting buf can be used with deno_new.
-// The caller must free the returned data by calling delete[] buf.data_ptr.
-deno_buf deno_get_snapshot(Deno* d);
-
 void deno_delete(Deno* d);
 
+// Generate a snapshot. The resulting buf can be used in as the load_snapshot
+// member in deno_confg.
+// When calling this function, the caller must have created the isolate "d" with
+// "will_snapshot" set to 1.
+// The caller must free the returned data with deno_snapshot_delete().
+deno_snapshot deno_snapshot_new(Deno* d);
+
+// Only for use with data returned from deno_snapshot_new.
+void deno_snapshot_delete(deno_snapshot);
+
 void deno_lock(Deno* d);
 void deno_unlock(Deno* d);
 

core/libdeno/internal.h

@@ -169,6 +169,7 @@ static intptr_t external_references[] = {
     0};
 
 static const deno_buf empty_buf = {nullptr, 0, nullptr, 0, 0};
+static const deno_snapshot empty_snapshot = {nullptr, 0};
 
 Deno* NewFromSnapshot(void* user_data, deno_recv_cb cb);
 

core/libdeno/libdeno_test.cc

@@ -10,10 +10,10 @@ TEST(LibDenoTest, InitializesCorrectly) {
 }
 
 TEST(LibDenoTest, Snapshotter) {
-  Deno* d1 = deno_new(deno_config{1, empty, empty, nullptr});
+  Deno* d1 = deno_new(deno_config{1, empty_snapshot, empty, nullptr});
   deno_execute(d1, nullptr, "a.js", "a = 1 + 2");
   EXPECT_EQ(nullptr, deno_last_exception(d1));
-  deno_buf test_snapshot = deno_get_snapshot(d1);
+  deno_snapshot test_snapshot = deno_snapshot_new(d1);
   deno_delete(d1);
 
   Deno* d2 = deno_new(deno_config{0, test_snapshot, empty, nullptr});
@@ -21,7 +21,7 @@ TEST(LibDenoTest, Snapshotter) {
   EXPECT_EQ(nullptr, deno_last_exception(d2));
   deno_delete(d2);
 
-  delete[] test_snapshot.data_ptr;
+  deno_snapshot_delete(test_snapshot);
 }
 
 TEST(LibDenoTest, CanCallFunction) {
@@ -249,7 +249,7 @@ TEST(LibDenoTest, CheckPromiseErrors) {
 }
 
 TEST(LibDenoTest, LastException) {
-  Deno* d = deno_new(deno_config{0, empty, empty, nullptr});
+  Deno* d = deno_new(deno_config{0, empty_snapshot, empty, nullptr});
   EXPECT_EQ(deno_last_exception(d), nullptr);
   deno_execute(d, nullptr, "a.js", "\n\nthrow Error('boo');\n\n");
   EXPECT_STREQ(deno_last_exception(d),
@@ -264,7 +264,7 @@ TEST(LibDenoTest, LastException) {
 }
 
 TEST(LibDenoTest, EncodeErrorBug) {
-  Deno* d = deno_new(deno_config{0, empty, empty, nullptr});
+  Deno* d = deno_new(deno_config{0, empty_snapshot, empty, nullptr});
   EXPECT_EQ(deno_last_exception(d), nullptr);
   deno_execute(d, nullptr, "a.js", "eval('a')");
   EXPECT_STREQ(
@@ -293,7 +293,7 @@ TEST(LibDenoTest, Shared) {
 }
 
 TEST(LibDenoTest, Utf8Bug) {
-  Deno* d = deno_new(deno_config{0, empty, empty, nullptr});
+  Deno* d = deno_new(deno_config{0, empty_snapshot, empty, nullptr});
   // The following is a valid UTF-8 javascript which just defines a string
   // literal. We had a bug where libdeno would choke on this.
   deno_execute(d, nullptr, "a.js", "x = \"\xEF\xBF\xBD\"");
@@ -318,7 +318,7 @@ TEST(LibDenoTest, LibDenoEvalContextError) {
 TEST(LibDenoTest, SharedAtomics) {
   int32_t s[] = {0, 1, 2};
   deno_buf shared = {nullptr, 0, reinterpret_cast<uint8_t*>(s), sizeof s, 0};
-  Deno* d = deno_new(deno_config{0, empty, shared, nullptr});
+  Deno* d = deno_new(deno_config{0, empty_snapshot, shared, nullptr});
   deno_execute(d, nullptr, "a.js",
                "Atomics.add(new Int32Array(Deno.core.shared), 0, 1)");
   EXPECT_EQ(nullptr, deno_last_exception(d));

core/libdeno/modules_test.cc

@@ -13,7 +13,7 @@ void recv_cb(void* user_data, deno_buf buf, deno_buf zero_copy_buf) {
 
 TEST(ModulesTest, Resolution) {
   exec_count = 0;  // Reset
-  Deno* d = deno_new(deno_config{0, empty, empty, recv_cb});
+  Deno* d = deno_new(deno_config{0, empty_snapshot, empty, recv_cb});
   EXPECT_EQ(0, exec_count);
 
   static deno_mod a = deno_mod_new(d, true, "a.js",
@@ -66,7 +66,7 @@ TEST(ModulesTest, Resolution) {
 
 TEST(ModulesTest, ResolutionError) {
   exec_count = 0;  // Reset
-  Deno* d = deno_new(deno_config{0, empty, empty, recv_cb});
+  Deno* d = deno_new(deno_config{0, empty_snapshot, empty, recv_cb});
   EXPECT_EQ(0, exec_count);
 
   static deno_mod a = deno_mod_new(d, true, "a.js",
@@ -99,7 +99,7 @@ TEST(ModulesTest, ResolutionError) {
 
 TEST(ModulesTest, ImportMetaUrl) {
   exec_count = 0;  // Reset
-  Deno* d = deno_new(deno_config{0, empty, empty, recv_cb});
+  Deno* d = deno_new(deno_config{0, empty_snapshot, empty, recv_cb});
   EXPECT_EQ(0, exec_count);
 
   static deno_mod a =
@@ -119,7 +119,7 @@ TEST(ModulesTest, ImportMetaUrl) {
 }
 
 TEST(ModulesTest, ImportMetaMain) {
-  Deno* d = deno_new(deno_config{0, empty, empty, recv_cb});
+  Deno* d = deno_new(deno_config{0, empty_snapshot, empty, recv_cb});
 
   const char* throw_not_main_src = "if (!import.meta.main) throw 'err'";
   static deno_mod throw_not_main =

core/libdeno/snapshot_creator.cc

@@ -8,8 +8,6 @@
 #include "third_party/v8/include/v8.h"
 #include "third_party/v8/src/base/logging.h"
 
-namespace deno {}  // namespace deno
-
 int main(int argc, char** argv) {
   const char* snapshot_out_bin = argv[1];
   const char* js_fn = argv[2];
@@ -23,7 +21,7 @@ int main(int argc, char** argv) {
   CHECK(deno::ReadFileToString(js_fn, &js_source));
 
   deno_init();
-  deno_config config = {1, deno::empty_buf, deno::empty_buf, nullptr};
+  deno_config config = {1, deno::empty_snapshot, deno::empty_buf, nullptr};
   Deno* d = deno_new(config);
 
   deno_execute(d, nullptr, js_fn, js_source.c_str());
@@ -34,13 +32,13 @@ int main(int argc, char** argv) {
     return 1;
   }
 
-  auto snapshot = deno_get_snapshot(d);
+  auto snapshot = deno_snapshot_new(d);
 
   std::ofstream file_(snapshot_out_bin, std::ios::binary);
   file_.write(reinterpret_cast<char*>(snapshot.data_ptr), snapshot.data_len);
   file_.close();
 
-  delete[] snapshot.data_ptr;
+  deno_snapshot_delete(snapshot);
   deno_delete(d);
 
   return file_.bad();

core/libdeno/test.cc

@@ -3,7 +3,7 @@
 #include <string>
 #include "file_util.h"
 
-deno_buf snapshot = {nullptr, 0, nullptr, 0, 0};
+deno_snapshot snapshot = {nullptr, 0};
 
 int main(int argc, char** argv) {
   // Locate the snapshot.

core/libdeno/test.h

@@ -5,7 +5,8 @@
 #include "deno.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-extern deno_buf snapshot;  // Loaded in libdeno/test.cc
+extern deno_snapshot snapshot;  // Loaded in libdeno/test.cc
 const deno_buf empty = {nullptr, 0, nullptr, 0, 0};
+const deno_snapshot empty_snapshot = {nullptr, 0};
 
 #endif  // TEST_H_