From 44532ff4465138f3e34b1ac9d1c892c8a81e90bc Mon Sep 17 00:00:00 2001
From: Gus Caplan <me@gus.host>
Date: Wed, 5 Sep 2018 18:29:31 -0500
Subject: [PATCH 1/4] worker: implement web locks api

---
 doc/api/worker_threads.md | 104 +++++++++++++
 lib/internal/worker.js    | 152 ++++++++++++++++++-
 lib/worker_threads.js     |   6 +-
 node.gyp                  |   2 +
 src/env.h                 |   5 +
 src/node_internals.h      |   1 +
 src/node_locks.cc         | 304 ++++++++++++++++++++++++++++++++++++++
 src/node_locks.h          | 117 +++++++++++++++
 tools/doc/type-parser.js  |   2 +
 9 files changed, 690 insertions(+), 3 deletions(-)
 create mode 100644 src/node_locks.cc
 create mode 100644 src/node_locks.h

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index b9f28cbfbe411b..ed5f23d10e1a4f 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -92,6 +92,106 @@ added: v10.5.0
 An arbitrary JavaScript value that contains a clone of the data passed
 to this thread’s `Worker` constructor.
 
+## worker.locks
+<!-- YAML
+added: REPLACEME
+-->
+
+* {LockManager}
+
+An instance of a [`LockManager`][].
+
+## Class: Lock
+<!-- YAML
+added: REPLACEME
+-->
+
+The Lock interface provides the name and mode of a previously requested lock,
+which is received in the callback to [`LockManager.request()`][].
+
+### lock.name
+<!-- YAML
+added: REPLACEME
+-->
+
+* {string}
+
+The name of this lock.
+
+### lock.mode
+<!-- YAML
+added: REPLACEME
+-->
+
+* {string}
+
+The mode of this lock. Either `shared` or `exclusive`.
+
+## Class: LockManager
+<!-- YAML
+added: REPLACEME
+-->
+
+The `LockManager` interface provides methods for requesting a new [`Lock`][]
+object and querying for an existing `Lock` object. To get an instance of
+`LockManager`, call `worker_threads.locks`.
+
+With the exception of `AbortController` support, this implementation matches
+the [browser `LockManager`][] API.
+
+### locks.request(name[, options], callback)
+<!-- YAML
+added: REPLACEME
+-->
+
+* `name` {string}
+* `options` {Object}
+  * `mode` {string} Either `'exclusive'` or `'shared'`. **Default:**
+    `'exclusive'`.
+  * `ifAvailable` {boolean} If `true`, the lock request will only be
+    granted if it is not already held. If it cannot be granted, the
+    callback will be invoked with `null` instead of a `Lock` instance.
+    **Default:** `false`.
+  * `steal` {boolean} If `true`, then any held locks with the same name will be
+    released, and the request will be granted, preempting any queued requests
+    for it. **Default:** `false`.
+* `callback` {Function} The function to be invoked while the lock is acquired.
+  The lock will be released when the function ends, or if the function returns
+  a promise, when that promise settles.
+* Returns: {Promise}
+
+Requests a [`Lock`][] object with parameters specifying its name and
+characteristics.
+
+```js
+worker_threads.locks.request('my_resource', async (lock) => {
+  // The lock was granted.
+}).then(() => {
+  // The lock is released here.
+});
+```
+
+### locks.query()
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {Promise}
+
+Returns a Promise that resolves with a [`LockManagerSnapshot`][] which contains
+information about held and pending locks.
+
+```js
+worker_threads.locks.query().then((state) => {
+  state.held.forEach((lock) => {
+    console.log(`held lock: name ${lock.name}, mode ${lock.mode}`);
+  });
+  state.pending.forEach((request) => {
+    console.log(`requested lock: name ${request.name}, mode ${request.mode}`);
+  });
+});
+```
+
 ## Class: MessageChannel
 <!-- YAML
 added: v10.5.0
@@ -483,10 +583,14 @@ active handle in the event system. If the worker is already `unref()`ed calling
 [`require('worker_threads').threadId`]: #worker_threads_worker_threadid
 [`cluster` module]: cluster.html
 [`inspector`]: inspector.html
+[`Lock`]: #worker_threads_class_lock
+[`LockManager`]: #worker_threads_class_lockmanager
+[`LockManagerSnapshot`]: https://developer.mozilla.org/en-US/docs/Web/API/LockManagerSnapshot
 [v8.serdes]: v8.html#v8_serialization_api
 [`SharedArrayBuffer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer
 [Signals events]: process.html#process_signal_events
 [`Uint8Array`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array
+[browser `LockManager`]: https://developer.mozilla.org/en-US/docs/Web/API/LockManager
 [browser `MessagePort`]: https://developer.mozilla.org/en-US/docs/Web/API/MessagePort
 [child processes]: child_process.html
 [HTML structured clone algorithm]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 402fc30b591d2d..2c2f547057aea5 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -15,8 +15,10 @@ const {
 const { internalBinding } = require('internal/bootstrap/loaders');
 const { MessagePort, MessageChannel } = internalBinding('messaging');
 const { handle_onclose } = internalBinding('symbols');
+const locks = internalBinding('locks');
 const { clearAsyncIdStack } = require('internal/async_hooks');
 const { serializeError, deserializeError } = require('internal/error-serdes');
+const DOMException = require('internal/domexception');
 
 util.inherits(MessagePort, EventEmitter);
 
@@ -44,6 +46,7 @@ const kStdioWantsMoreDataCallback = Symbol('kStdioWantsMoreDataCallback');
 const kStartedReading = Symbol('kStartedReading');
 const kWaitingStreams = Symbol('kWaitingStreams');
 const kIncrementsPortRef = Symbol('kIncrementsPortRef');
+const kMode = Symbol('mode');
 
 const debug = util.debuglog('worker');
 
@@ -505,6 +508,152 @@ function pipeWithoutWarning(source, dest) {
   dest._maxListeners = destMaxListeners;
 }
 
+// https://wicg.github.io/web-locks/#api-lock
+class Lock {
+  constructor() {
+    // eslint-disable-next-line no-restricted-syntax
+    throw new TypeError('Illegal constructor');
+  }
+
+  get name() {
+    return this[kName];
+  }
+
+  get mode() {
+    return this[kMode];
+  }
+}
+
+Object.defineProperties(Lock.prototype, {
+  name: { enumerable: true },
+  mode: { enumerable: true },
+  [Symbol.toStringTag]: {
+    value: 'Lock',
+    writable: false,
+    enumerable: false,
+    configurable: true,
+  },
+});
+
+// https://wicg.github.io/web-locks/#api-lock-manager
+class LockManager {
+  constructor() {
+    // eslint-disable-next-line no-restricted-syntax
+    throw new TypeError('Illegal constructor');
+  }
+
+  // https://wicg.github.io/web-locks/#api-lock-manager-request
+  request(name, options, callback) {
+    if (callback === undefined) {
+      callback = options;
+      options = undefined;
+    }
+
+    // Let promise be a new promise.
+    let reject;
+    let resolve;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+
+    // If options was not passed, then let options be a new LockOptions
+    // dictionary with default members.
+    if (options === undefined) {
+      options = {
+        mode: 'exclusive',
+        ifAvailable: false,
+        steal: false,
+      };
+    }
+
+    if (name.startsWith('-')) {
+      // if name starts with U+002D HYPHEN-MINUS (-), then reject promise with a
+      // "NotSupportedError" DOMException.
+      reject(new DOMException('NotSupportedError'));
+    } else if (options.ifAvailable === true && options.steal === true) {
+      // Otherwise, if both options' steal dictionary member and option's
+      // ifAvailable dictionary member are true, then reject promise with a
+      // "NotSupportedError" DOMException.
+      reject(new DOMException('NotSupportedError'));
+    } else if (options.steal === true && options.mode !== 'exclusive') {
+      // Otherwise, if options' steal dictionary member is true and option's
+      // mode dictionary member is not "exclusive", then reject promise with a
+      // "NotSupportedError" DOMException.
+      reject(new DOMException('NotSupportedError'));
+    } else {
+      // Otherwise, run these steps:
+
+      // Let request be the result of running the steps to request a lock with
+      // promise, the current agent, environment's id, origin, callback, name,
+      // options' mode dictionary member, options' ifAvailable dictionary
+      // member, and option's steal dictionary member.
+      process.nextTick(() => {
+        locks.request(
+          promise,
+          (name, mode, waitingPromise, release) => {
+            const lock = Object.create(Lock.prototype, {
+              [kName]: {
+                value: name,
+                writable: false,
+                enumerable: false,
+                configurable: false,
+              },
+              [kMode]: {
+                value: mode === 0 ? 'shared' : 'exclusive',
+                writable: false,
+                enumerable: false,
+                configurable: false,
+              },
+            });
+
+            // When lock lock's waiting promise settles (fulfills or rejects),
+            // enqueue the following steps on the lock task queue:
+            waitingPromise
+              .finally(() => undefined)
+              .then(() => {
+                // Release the lock lock.
+                release();
+
+                // Resolve lock's released promise with lock's waiting promise.
+                resolve(waitingPromise);
+              });
+
+            return callback(lock);
+          },
+          name,
+          options.mode === 'shared' ? 0 : 1,
+          options.ifAvailable,
+          options.steal);
+      });
+    }
+
+    // Return promise.
+    return promise;
+  }
+
+  // https://wicg.github.io/web-locks/#api-lock-manager-query
+  query() {
+    return new Promise((resolve) => {
+      process.nextTick(() => {
+        const snapshot = locks.snapshot();
+        resolve(snapshot);
+      });
+    });
+  }
+}
+
+Object.defineProperties(LockManager.prototype, {
+  request: { enumerable: true },
+  query: { enumerable: true },
+  [Symbol.toStringTag]: {
+    value: 'LockManager',
+    writable: false,
+    enumerable: false,
+    configurable: true,
+  },
+});
+
 module.exports = {
   MessagePort,
   MessageChannel,
@@ -512,5 +661,6 @@ module.exports = {
   Worker,
   setupChild,
   isMainThread,
-  workerStdio
+  workerStdio,
+  LockManager,
 };
diff --git a/lib/worker_threads.js b/lib/worker_threads.js
index 0609650cd5731d..5a4aba3979f1c9 100644
--- a/lib/worker_threads.js
+++ b/lib/worker_threads.js
@@ -5,7 +5,8 @@ const {
   MessagePort,
   MessageChannel,
   threadId,
-  Worker
+  Worker,
+  LockManager,
 } = require('internal/worker');
 
 module.exports = {
@@ -14,5 +15,6 @@ module.exports = {
   MessageChannel,
   threadId,
   Worker,
-  parentPort: null
+  parentPort: null,
+  locks: Object.create(LockManager.prototype),
 };
diff --git a/node.gyp b/node.gyp
index d94e6ff62aa0db..d2f61e39f099ea 100644
--- a/node.gyp
+++ b/node.gyp
@@ -350,6 +350,7 @@
         'src/node_file.cc',
         'src/node_http2.cc',
         'src/node_http_parser.cc',
+        'src/node_locks.cc',
         'src/node_messaging.cc',
         'src/node_options.cc',
         'src/node_os.cc',
@@ -413,6 +414,7 @@
         'src/node_http2_state.h',
         'src/node_internals.h',
         'src/node_javascript.h',
+        'src/node_locks.h',
         'src/node_messaging.h',
         'src/node_mutex.h',
         'src/node_options.h',
diff --git a/src/env.h b/src/env.h
index fa802e4016dfdb..6f1012295c7bd2 100644
--- a/src/env.h
+++ b/src/env.h
@@ -153,6 +153,7 @@ struct PackageConfig {
   V(duration_string, "duration")                                              \
   V(emit_warning_string, "emitWarning")                                       \
   V(exchange_string, "exchange")                                              \
+  V(exclusive_string, "exclusive")                                            \
   V(encoding_string, "encoding")                                              \
   V(entries_string, "entries")                                                \
   V(entry_type_string, "entryType")                                           \
@@ -178,6 +179,7 @@ struct PackageConfig {
   V(get_shared_array_buffer_id_string, "_getSharedArrayBufferId")             \
   V(gid_string, "gid")                                                        \
   V(handle_string, "handle")                                                  \
+  V(held_string, "held")                                                      \
   V(help_text_string, "helpText")                                             \
   V(homedir_string, "homedir")                                                \
   V(host_string, "host")                                                      \
@@ -201,6 +203,7 @@ struct PackageConfig {
   V(message_port_string, "messagePort")                                       \
   V(message_port_constructor_string, "MessagePort")                           \
   V(minttl_string, "minttl")                                                  \
+  V(mode_string, "mode")                                                      \
   V(modulus_string, "modulus")                                                \
   V(name_string, "name")                                                      \
   V(netmask_string, "netmask")                                                \
@@ -242,6 +245,7 @@ struct PackageConfig {
   V(parse_error_string, "Parse Error")                                        \
   V(password_string, "password")                                              \
   V(path_string, "path")                                                      \
+  V(pending_string, "pending")                                                \
   V(pending_handle_string, "pendingHandle")                                   \
   V(pid_string, "pid")                                                        \
   V(pipe_string, "pipe")                                                      \
@@ -270,6 +274,7 @@ struct PackageConfig {
   V(service_string, "service")                                                \
   V(servername_string, "servername")                                          \
   V(session_id_string, "sessionId")                                           \
+  V(shared_string, "shared")                                                  \
   V(shell_string, "shell")                                                    \
   V(signal_string, "signal")                                                  \
   V(sink_string, "sink")                                                      \
diff --git a/src/node_internals.h b/src/node_internals.h
index edfc00e53f13a7..a3827a94d56c56 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -117,6 +117,7 @@ struct sockaddr;
     V(http_parser)                                                            \
     V(inspector)                                                              \
     V(js_stream)                                                              \
+    V(locks)                                                                  \
     V(messaging)                                                              \
     V(module_wrap)                                                            \
     V(options)                                                                \
diff --git a/src/node_locks.cc b/src/node_locks.cc
new file mode 100644
index 00000000000000..4e89f909359155
--- /dev/null
+++ b/src/node_locks.cc
@@ -0,0 +1,304 @@
+#include "node_locks.h"
+#include <algorithm>
+#include <memory>
+#include <utility>
+#include "env-inl.h"
+#include "node.h"
+#include "node_internals.h"
+#include "v8.h"
+
+namespace node {
+namespace worker {
+
+using v8::Array;
+using v8::Boolean;
+using v8::Context;
+using v8::External;
+using v8::Function;
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
+using v8::Local;
+using v8::Null;
+using v8::Number;
+using v8::Object;
+using v8::Promise;
+using v8::String;
+using v8::TryCatch;
+using v8::Undefined;
+using v8::Value;
+
+LockManager LockManager::current_;
+
+void LockManager::ReleaseLock(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  LockManager* manager = LockManager::GetCurrent();
+
+  Lock* lock = reinterpret_cast<Lock*>(args.Data().As<External>()->Value());
+
+  Mutex::ScopedLock(manager->work_mutex_);
+
+  for (auto const& maybe : manager->held_locks_) {
+    if (maybe.get() == lock) {
+      manager->held_locks_.erase(
+          std::remove(
+              manager->held_locks_.begin(), manager->held_locks_.end(), maybe),
+          manager->held_locks_.end());
+      break;
+    }
+  }
+
+  manager->ProcessQueue(env);
+}
+
+void LockManager::ProcessQueue(Environment* env) {
+  // For each request of queue:
+  for (auto const& request : pending_requests_) {
+    // If request is grantable, then run these steps:
+    if (IsGrantable(request.get())) {
+      // Let waiting be a new Promise.
+      Local<Promise::Resolver> waiting =
+        Promise::Resolver::New(env->context()).ToLocalChecked();
+
+      Lock* lock = new Lock(
+          env, request->mode(), request->name(), request->promise(), waiting);
+
+      // Let r be the result of invoking callback with a
+      // new Lock object associated with lock as the only argument.
+
+      Local<Value> args[] = {
+          String::NewFromUtf8(env->isolate(), lock->name().c_str()),
+          Number::New(env->isolate(), lock->mode()),
+          waiting->GetPromise(),
+          Function::New(env->context(),
+                        LockManager::ReleaseLock,
+                        External::New(env->isolate(), lock))
+              .ToLocalChecked(),
+      };
+
+      TryCatch try_catch(env->isolate());
+      Local<Value> r;
+      if (request->callback()
+              ->Call(env->context(), Undefined(env->isolate()), 4, args)
+              .ToLocal(&r)) {
+        waiting->Resolve(env->context(), r).ToChecked();
+      } else {
+        waiting->Reject(env->context(), try_catch.Exception()).ToChecked();
+      }
+
+      // Remove request from queue.
+      pending_requests_.erase(
+          std::remove(
+              pending_requests_.begin(), pending_requests_.end(), request),
+          pending_requests_.end());
+
+      // Append lock to origin’s held lock set.
+      held_locks_.emplace_back(lock);
+    }
+  }
+}
+
+bool LockManager::IsGrantable(const LockRequest* request) {
+  // If mode is "exclusive", then return true if all of the
+  // following conditions are true, and false otherwise:
+  if (request->mode() == Lock::Mode::kExclusive) {
+    // No lock in held has a name that equals name
+    for (auto const& lock : held_locks_) {
+      if (lock->name() == request->name()) {
+        return false;
+      }
+    }
+
+    // No lock request in queue earlier than request has a name that equals
+    // name.
+    for (auto const& req : pending_requests_) {
+      if (request == req.get()) {
+        break;
+      }
+      if (req->name() == request->name()) {
+        return false;
+      }
+    }
+    return true;
+  } else {
+    // Otherwise, mode is "shared"; return true if all of the
+    // following conditions are true, and false otherwise:
+
+    // No lock in held has mode "exclusive" and has a name that equals name.
+    for (auto const& lock : held_locks_) {
+      if (lock->name() == request->name() &&
+          lock->mode() == Lock::Mode::kExclusive) {
+        return false;
+      }
+    }
+
+    // No lock request in queue earlier than request has a
+    // mode "exclusive" and name that equals name
+    for (auto const& req : pending_requests_) {
+      if (request == req.get()) {
+        break;
+      }
+      if (req->name() == request->name() &&
+          req->mode() == Lock::Mode::kExclusive) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+
+// https://wicg.github.io/web-locks/#algorithm-request-lock
+// promise, callback, name, mode, ifAvailable, steal
+void LockManager::Request(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  LockManager* manager = LockManager::GetCurrent();
+
+  CHECK_EQ(args.Length(), 6);
+
+  CHECK(args[0]->IsPromise());
+  CHECK(args[1]->IsFunction());
+  CHECK(args[2]->IsString());
+  CHECK(args[3]->IsNumber());
+  CHECK(args[4]->IsBoolean());
+  CHECK(args[5]->IsBoolean());
+
+  Local<Promise::Resolver> promise = args[0].As<Promise::Resolver>();
+  Local<Function> callback = args[1].As<Function>();
+
+  String::Utf8Value name_utf8(env->isolate(), args[2]);
+  std::string name(*name_utf8);
+
+  Lock::Mode mode = static_cast<Lock::Mode>(args[3].As<Number>()->Int32Value());
+
+  bool if_available = args[4]->IsTrue();
+  bool steal = args[5]->IsTrue();
+
+  Mutex::ScopedLock(manager->work_mutex_);
+
+  LockRequest* request = new LockRequest(env, promise, callback, name, mode);
+
+  if (steal) {
+    for (auto const& lock : manager->held_locks_) {
+      if (lock->name() == name) {
+        // Reject lock’s released promise with an "AbortError" DOMException.
+        Local<Function> domexception_ctor = env->domexception_function();
+        CHECK(!domexception_ctor.IsEmpty());
+        Local<Value> argv[] = {
+            FIXED_ONE_BYTE_STRING(env->isolate(),
+                                  "Lock request could not be fulfilled"),
+            FIXED_ONE_BYTE_STRING(env->isolate(), "AbortError"),
+        };
+        Local<Value> exception =
+            domexception_ctor->NewInstance(env->context(), 2, argv)
+                .ToLocalChecked();
+        lock->released_promise()->Reject(env->context(), exception).ToChecked();
+
+        // Remove lock from held lock set
+        manager->held_locks_.erase(
+            std::remove(
+                manager->held_locks_.begin(), manager->held_locks_.end(), lock),
+            manager->held_locks_.end());
+      }
+    }
+    // Prepend request in origin’s lock request queue.
+    manager->pending_requests_.emplace_front(request);
+  } else {
+    // Otherwise, run these steps:
+    // If ifAvailable is true and request is not
+    // grantable, then run these steps:
+    if (if_available && !manager->IsGrantable(request)) {
+      // Let r be the result of invoking callback with null as the only
+      // argument. Note that r could be a regular completion, an abrupt
+      // completion, or an unresolved Promise.
+      TryCatch try_catch(env->isolate());
+      Local<Value> r;
+      Local<Value> null = Null(env->isolate());
+      if (callback->Call(env->context(), Undefined(env->isolate()), 1, &null)
+              .ToLocal(&r)) {
+        // Resolve promise with r and abort these steps.
+        promise->Resolve(env->context(), r).ToChecked();
+        return;
+      } else {
+        promise->Reject(env->context(), try_catch.Exception()).ToChecked();
+      }
+    }
+    // Enqueue request in origin's lock request queue;
+    manager->pending_requests_.emplace_back(request);
+  }
+
+  manager->ProcessQueue(env);
+}
+
+// https://wicg.github.io/web-locks/#snapshot-the-lock-state
+void LockManager::Snapshot(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  Isolate* isolate = env->isolate();
+  Local<Context> context = env->context();
+  LockManager* manager = LockManager::GetCurrent();
+
+  Mutex::ScopedLock(manager->work_mutex_);
+
+  Local<Object> obj = Object::New(isolate);
+
+  {
+    Local<Array> pending =
+        Array::New(isolate, manager->pending_requests_.size());
+
+    for (uint32_t i = 0; i < manager->pending_requests_.size(); i += 1) {
+      LockRequest* request = manager->pending_requests_[i].get();
+
+      Local<Object> obj = Object::New(isolate);
+      obj->Set(context,
+               env->name_string(),
+               String::NewFromUtf8(isolate, request->name().c_str()))
+          .ToChecked();
+      obj->Set(context,
+               env->mode_string(),
+               request->mode() == Lock::Mode::kShared ? env->shared_string()
+                                                      : env->exclusive_string())
+          .ToChecked();
+
+      pending->Set(context, i, obj).ToChecked();
+    }
+
+    obj->Set(context, env->pending_string(), pending).ToChecked();
+  }
+
+  {
+    Local<Array> held = Array::New(isolate, manager->held_locks_.size());
+
+    for (uint32_t i = 0; i < manager->held_locks_.size(); i += 1) {
+      Lock* lock = manager->held_locks_[i].get();
+
+      Local<Object> obj = Object::New(isolate);
+      obj->Set(context,
+               env->name_string(),
+               String::NewFromUtf8(isolate, lock->name().c_str()))
+          .ToChecked();
+      obj->Set(context,
+               env->mode_string(),
+               lock->mode() == Lock::Mode::kShared ? env->shared_string()
+                                                   : env->exclusive_string())
+          .ToChecked();
+
+      held->Set(context, i, obj).ToChecked();
+    }
+
+    obj->Set(context, env->held_string(), held).ToChecked();
+  }
+
+  args.GetReturnValue().Set(obj);
+}
+
+void InitializeLocks(Local<Object> target,
+                     Local<Value> unused,
+                     Local<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
+
+  env->SetMethod(target, "snapshot", LockManager::Snapshot);
+  env->SetMethod(target, "request", LockManager::Request);
+}
+
+}  // namespace worker
+}  // namespace node
+
+NODE_MODULE_CONTEXT_AWARE_INTERNAL(locks, node::worker::InitializeLocks)
diff --git a/src/node_locks.h b/src/node_locks.h
new file mode 100644
index 00000000000000..5a25498f046b73
--- /dev/null
+++ b/src/node_locks.h
@@ -0,0 +1,117 @@
+#ifndef SRC_NODE_LOCKS_H_
+#define SRC_NODE_LOCKS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <deque>
+#include <memory>  // std::unique_ptr
+#include <string>
+#include "node.h"
+#include "node_persistent.h"
+#include "node_internals.h"
+#include "env-inl.h"
+#include "v8.h"
+
+namespace node {
+namespace worker {
+
+class Lock {
+ public:
+  enum Mode {
+    kShared,
+    kExclusive,
+  };
+
+  Lock(Environment* env,
+       Lock::Mode mode,
+       const std::string& name,
+       v8::Local<v8::Promise::Resolver> released_promise,
+       v8::Local<v8::Promise::Resolver> waiting_promise)
+      : env_(env), mode_(mode), name_(name) {
+    released_promise_.Reset(env->isolate(), released_promise);
+    waiting_promise_.Reset(env->isolate(), waiting_promise);
+  }
+
+  ~Lock() {
+    waiting_promise_.Reset();
+    released_promise_.Reset();
+  }
+
+  inline const std::string& name() const { return name_; }
+  inline Mode mode() const { return mode_; }
+  inline v8::Local<v8::Promise::Resolver> released_promise() {
+    return released_promise_.Get(env_->isolate());
+  }
+
+ private:
+  Environment* env_;
+  Mode mode_;
+  std::string name_;
+  Persistent<v8::Promise::Resolver> waiting_promise_;
+  Persistent<v8::Promise::Resolver> released_promise_;
+};
+
+class LockRequest {
+ public:
+  LockRequest(Environment* env,
+              v8::Local<v8::Promise::Resolver> promise,
+              v8::Local<v8::Function> callback,
+              const std::string& name,
+              Lock::Mode mode)
+      : env_(env), name_(name), mode_(mode) {
+    promise_.Reset(env->isolate(), promise);
+    callback_.Reset(env->isolate(), callback);
+  }
+
+  ~LockRequest() {
+    callback_.Reset();
+    promise_.Reset();
+  }
+
+  inline const std::string& name() const { return name_; }
+  inline Lock::Mode mode() const { return mode_; }
+  inline v8::Local<v8::Promise::Resolver> promise() const {
+    return promise_.Get(env_->isolate());
+  }
+  inline v8::Local<v8::Function> callback() const {
+    return callback_.Get(env_->isolate());
+  }
+
+ private:
+  Environment* env_;
+  std::string name_;
+  Lock::Mode mode_;
+  Persistent<v8::Function> callback_;
+  Persistent<v8::Promise::Resolver> promise_;
+};
+
+class LockManager {
+ public:
+  void Snapshot(Environment* env, v8::Local<v8::Promise::Resolver> promise);
+  void ProcessQueue(Environment* env);
+  bool IsGrantable(const LockRequest* request);
+
+  static void ReleaseLock(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Snapshot(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Request(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Query(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static inline LockManager* GetCurrent() { return &current_; }
+
+ private:
+  static LockManager current_;
+
+  std::deque<std::unique_ptr<LockRequest>> pending_requests_;
+  std::deque<std::unique_ptr<Lock>> held_locks_;
+
+  mutable Mutex work_mutex_;
+
+  friend class LockRequest;
+};
+
+}  // namespace worker
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_LOCKS_H_
diff --git a/tools/doc/type-parser.js b/tools/doc/type-parser.js
index b57dc6957a9ae0..bceec9ecf90138 100644
--- a/tools/doc/type-parser.js
+++ b/tools/doc/type-parser.js
@@ -120,6 +120,8 @@ const customTypesMap = {
   'URLSearchParams': 'url.html#url_class_urlsearchparams',
 
   'MessagePort': 'worker_threads.html#worker_threads_class_messageport',
+  'Lock': 'worker_threads.html#worker_threads_class_lock',
+  'LockManager': 'worker_threads.html#worker_threads_class_lockmanager',
 
   'zlib options': 'zlib.html#zlib_class_options',
 };

From 1626f5998c4647e22a72b6807fafa4b537d9d3a3 Mon Sep 17 00:00:00 2001
From: Gus Caplan <me@gus.host>
Date: Thu, 6 Sep 2018 21:38:31 -0500
Subject: [PATCH 2/4] squash! properly enter microtask queue

---
 lib/internal/process/next_tick.js | 20 +++++++++++++++++++-
 lib/internal/worker.js            |  5 +++--
 src/bootstrapper.cc               | 12 ++++++++++++
 3 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/lib/internal/process/next_tick.js b/lib/internal/process/next_tick.js
index df6984aabc8c07..817fdb9123b1d7 100644
--- a/lib/internal/process/next_tick.js
+++ b/lib/internal/process/next_tick.js
@@ -25,7 +25,8 @@ function setupNextTick(_setupNextTick, _setupPromises) {
   // runMicrotasks is used to run V8's micro task queue.
   const [
     tickInfo,
-    runMicrotasks
+    runMicrotasks,
+    enqueueMicrotask,
   ] = _setupNextTick(_tickCallback);
 
   // *Must* match Environment::TickInfo::Fields in src/env.h.
@@ -91,6 +92,23 @@ function setupNextTick(_setupNextTick, _setupPromises) {
     }
   }
 
+  // Internal method to enter the true microtask queue, ensuring that
+  // the callback isn't called out of order with promise jobs.
+  function queueMicrotask(callback) {
+    if (typeof callback !== 'function')
+      throw new ERR_INVALID_CALLBACK();
+
+    enqueueMicrotask(() => {
+      try {
+        callback();
+      } catch (e) {
+        process.emit('error', e);
+      }
+    });
+  }
+
+  exports.queueMicrotask = queueMicrotask;
+
   // `nextTick()` will not enqueue any callback when the process is about to
   // exit since the callback would not have a chance to be executed.
   function nextTick(callback) {
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 2c2f547057aea5..0f098566f3be9d 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -19,6 +19,7 @@ const locks = internalBinding('locks');
 const { clearAsyncIdStack } = require('internal/async_hooks');
 const { serializeError, deserializeError } = require('internal/error-serdes');
 const DOMException = require('internal/domexception');
+const nextTickUtil = require('internal/process/next_tick');
 
 util.inherits(MessagePort, EventEmitter);
 
@@ -588,7 +589,7 @@ class LockManager {
       // promise, the current agent, environment's id, origin, callback, name,
       // options' mode dictionary member, options' ifAvailable dictionary
       // member, and option's steal dictionary member.
-      process.nextTick(() => {
+      nextTickUtil.queueMicrotask(() => {
         locks.request(
           promise,
           (name, mode, waitingPromise, release) => {
@@ -635,7 +636,7 @@ class LockManager {
   // https://wicg.github.io/web-locks/#api-lock-manager-query
   query() {
     return new Promise((resolve) => {
-      process.nextTick(() => {
+      nextTickUtil.queueMicrotask(() => {
         const snapshot = locks.snapshot();
         resolve(snapshot);
       });
diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index 720f89c011801e..1df8861db78669 100644
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -31,6 +31,11 @@ void RunMicrotasks(const FunctionCallbackInfo<Value>& args) {
   args.GetIsolate()->RunMicrotasks();
 }
 
+void EnqueueMicrotask(const FunctionCallbackInfo<Value>& args) {
+  CHECK(args[0]->IsFunction());
+  args.GetIsolate()->EnqueueMicrotask(args[0].As<Function>());
+}
+
 void SetupTraceCategoryState(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
   CHECK(args[0]->IsFunction());
@@ -51,9 +56,16 @@ void SetupNextTick(const FunctionCallbackInfo<Value>& args) {
           .ToLocalChecked();
   run_microtasks_fn->SetName(FIXED_ONE_BYTE_STRING(isolate, "runMicrotasks"));
 
+  Local<Function> enqueue_microtasks_fn =
+    env->NewFunctionTemplate(EnqueueMicrotask)->GetFunction(context)
+        .ToLocalChecked();
+  enqueue_microtasks_fn->SetName(
+      FIXED_ONE_BYTE_STRING(isolate, "EnqueueMicrotask"));
+
   Local<Array> ret = Array::New(isolate, 2);
   ret->Set(context, 0, env->tick_info()->fields().GetJSArray()).FromJust();
   ret->Set(context, 1, run_microtasks_fn).FromJust();
+  ret->Set(context, 2, enqueue_microtasks_fn).FromJust();
 
   args.GetReturnValue().Set(ret);
 }

From 43ff4d37de7282dd8933cb378fd93982cdb7703c Mon Sep 17 00:00:00 2001
From: Gus Caplan <me@gus.host>
Date: Thu, 6 Sep 2018 21:48:35 -0500
Subject: [PATCH 3/4] squash! fix default option

---
 lib/internal/worker.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 0f098566f3be9d..ede9c6e9e5d39a 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -624,8 +624,8 @@ class LockManager {
           },
           name,
           options.mode === 'shared' ? 0 : 1,
-          options.ifAvailable,
-          options.steal);
+          options.ifAvailable || false,
+          options.steal || false);
       });
     }
 

From 27f5d56be185c8354253ab0cac511cdeb59e8533 Mon Sep 17 00:00:00 2001
From: Gus Caplan <me@gus.host>
Date: Fri, 7 Sep 2018 07:59:37 -0500
Subject: [PATCH 4/4] squash! if locks are pending on exit, there is a deadlock

---
 src/node.cc       | 10 ++++++++++
 src/node_locks.cc |  6 ++++++
 src/node_locks.h  |  1 +
 3 files changed, 17 insertions(+)

diff --git a/src/node.cc b/src/node.cc
index d1ce0ce1af3870..95eb7e73672d49 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -29,6 +29,7 @@
 #include "node_revert.h"
 #include "node_perf.h"
 #include "node_context_data.h"
+#include "node_locks.h"
 #include "tracing/traced_value.h"
 
 #if defined HAVE_PERFCTR
@@ -3079,6 +3080,15 @@ inline int Start(Isolate* isolate, IsolateData* isolate_data,
 
   env.set_trace_sync_io(false);
 
+  {
+    // If there are still pending locks, exit with a deadlock error
+    worker::LockManager* manager = worker::LockManager::GetCurrent();
+    if (manager->HasPending()) {
+      // FIXME: doesn't seem to actually throw
+      env.ThrowError("Worker lock deadlock detected");
+    }
+  }
+
   const int exit_code = EmitExit(&env);
 
   WaitForInspectorDisconnect(&env);
diff --git a/src/node_locks.cc b/src/node_locks.cc
index 4e89f909359155..fae5a3b1f5c758 100644
--- a/src/node_locks.cc
+++ b/src/node_locks.cc
@@ -146,6 +146,12 @@ bool LockManager::IsGrantable(const LockRequest* request) {
   }
 }
 
+bool LockManager::HasPending() {
+  Mutex::ScopedLock lock(work_mutex_);
+
+  return pending_requests_.size() > 0 || held_locks_.size() > 0;
+}
+
 // https://wicg.github.io/web-locks/#algorithm-request-lock
 // promise, callback, name, mode, ifAvailable, steal
 void LockManager::Request(const FunctionCallbackInfo<Value>& args) {
diff --git a/src/node_locks.h b/src/node_locks.h
index 5a25498f046b73..28d74763d682b9 100644
--- a/src/node_locks.h
+++ b/src/node_locks.h
@@ -90,6 +90,7 @@ class LockManager {
   void Snapshot(Environment* env, v8::Local<v8::Promise::Resolver> promise);
   void ProcessQueue(Environment* env);
   bool IsGrantable(const LockRequest* request);
+  bool HasPending();
 
   static void ReleaseLock(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Snapshot(const v8::FunctionCallbackInfo<v8::Value>& args);