diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index 7de28b99e403dc..faa42bf4b1cad7 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -274,6 +274,109 @@ if (isMainThread) {
 }
 ```
 
+## `worker.locks`
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+* {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 [`locks.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`.
+
+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`.
+  * `signal` {AbortSignal} A signal that can be used to abort pending, not-yet
+    acquired lock requests.
+* `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: `BroadcastChannel extends EventTarget`
 <!-- YAML
 added: v15.4.0
@@ -1086,6 +1189,9 @@ active handle in the event system. If the worker is already `unref()`ed calling
 [`EventTarget`]: https://developer.mozilla.org/en-US/docs/Web/API/EventTarget
 [`FileHandle`]: fs.md#fs_class_filehandle
 [`KeyObject`]: crypto.md#crypto_class_keyobject
+[`Lock`]: #worker_threads_class_lock
+[`LockManager`]: #worker_threads_class_lockmanager
+[`LockManagerSnapshot`]: https://developer.mozilla.org/en-US/docs/Web/API/LockManagerSnapshot
 [`MessagePort`]: #worker_threads_class_messageport
 [`SharedArrayBuffer`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer
 [`Uint8Array`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array
@@ -1095,6 +1201,7 @@ active handle in the event system. If the worker is already `unref()`ed calling
 [`data:` URL]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
 [`fs.close()`]: fs.md#fs_fs_close_fd_callback
 [`fs.open()`]: fs.md#fs_fs_open_path_flags_mode_callback
+[`locks.request()`]: #worker_threads_locks_request_name_options_callback
 [`markAsUntransferable()`]: #worker_threads_worker_markasuntransferable_object
 [`perf_hooks.performance`]: perf_hooks.md#perf_hooks_perf_hooks_performance
 [`perf_hooks` `eventLoopUtilization()`]: perf_hooks.md#perf_hooks_performance_eventlooputilization_utilization1_utilization2
@@ -1126,6 +1233,7 @@ active handle in the event system. If the worker is already `unref()`ed calling
 [`worker.terminate()`]: #worker_threads_worker_terminate
 [`worker.threadId`]: #worker_threads_worker_threadid_1
 [async-resource-worker-pool]: async_hooks.md#async-resource-worker-pool
+[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.md
 [contextified]: vm.md#vm_what_does_it_mean_to_contextify_an_object
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index cb51c0a1a5efd0..bce2e6b79131f0 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -85,6 +85,7 @@ let debug = require('internal/util/debuglog').debuglog('worker', (fn) => {
 });
 
 let cwdCounter;
+let locksInitialized = false;
 
 if (isMainThread) {
   cwdCounter = new Uint32Array(new SharedArrayBuffer(4));
@@ -166,6 +167,13 @@ class Worker extends EventEmitter {
         options.env);
     }
 
+    if (isMainThread && !locksInitialized) {
+      locksInitialized = true;
+      // Make sure that locks are initialized before active
+      // multithreading starts.
+      require('worker_threads').locks.query();
+    }
+
     // Set up the C++ handle for the worker, as well as some internal wiring.
     this[kHandle] = new WorkerImpl(url,
                                    env === process.env ? null : env,
diff --git a/lib/internal/worker/io.js b/lib/internal/worker/io.js
index 56fea9778f8785..d8fd1557c3bc0e 100644
--- a/lib/internal/worker/io.js
+++ b/lib/internal/worker/io.js
@@ -348,7 +348,7 @@ class BroadcastChannel extends EventTarget {
       throw new ERR_MISSING_ARGS('name');
     super();
     this[kName] = `${name}`;
-    this[kHandle] = broadcastChannel(this[kName]);
+    this[kHandle] = broadcastChannel(`userland:${this[kName]}`);
     this[kOnMessage] = FunctionPrototypeBind(onMessageEvent, this, 'message');
     this[kOnMessageError] =
       FunctionPrototypeBind(onMessageEvent, this, 'messageerror');
@@ -412,6 +412,7 @@ defineEventHandler(BroadcastChannel.prototype, 'messageerror');
 module.exports = {
   drainMessagePort,
   messageTypes,
+  kHandle,
   kPort,
   kIncrementsPortRef,
   kWaitingStreams,
diff --git a/lib/internal/worker/locks.js b/lib/internal/worker/locks.js
new file mode 100644
index 00000000000000..bb2c3726283f8c
--- /dev/null
+++ b/lib/internal/worker/locks.js
@@ -0,0 +1,543 @@
+/* global SharedArrayBuffer */
+'use strict';
+const {
+  broadcastChannel,
+  DOMException,
+} = internalBinding('messaging');
+const {
+  threadId,
+  isMainThread,
+} = require('internal/worker');
+const {
+  receiveMessageOnPort,
+} = require('internal/worker/io');
+const {
+  sticky_message_symbol,
+  onclose_message_symbol,
+} = internalBinding('symbols');
+const assert = require('internal/assert');
+const {
+  ERR_INVALID_ARG_VALUE,
+} = require('internal/errors');
+const {
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
+  BigUint64Array,
+  Int32Array,
+  ObjectCreate,
+  ObjectDefineProperties,
+  Promise,
+  PromiseResolve,
+  SafeMap,
+  Symbol,
+  SymbolToStringTag,
+  TypeError,
+} = primordials;
+
+const kName = Symbol('kName');
+const kMode = Symbol('kMode');
+const MUTEX_UNOWNED = -1;
+
+// Class that contains all the state around active and pending locks.
+class LockInternals {
+  constructor() {
+    // We identify each thread by the pid + thread id combination.
+    this.clientId = `node-${process.pid}-${threadId}`;
+
+    // These maps store the resolve/reject functions for a) when the lock
+    // request is granted and b) when the final result of the operation is
+    // known.
+    this.availableMap = new SafeMap();
+    this.resolveMap = new SafeMap();
+    this.queueProcessingScheduled = false;
+
+    // Create an internal BroadcastChannel instance for communication with
+    // other threads.
+    this.channel = broadcastChannel('nodejs-internal:locking');
+    this.channel.on('message', (msg) => this.onmessage(msg));
+    // Post the message that will be sent when this thread closes down
+    // (regardless of how exactly that happens).
+    this.channel.postMessage({
+      op: 'terminated',
+      clientId: this.clientId,
+      threadId: threadId,
+      [onclose_message_symbol]: true
+    });
+    // By default, do not keep the event loop running just for locks.
+    this.channel.unref();
+
+    // Look for existing messages on the channel. There should be some, unless
+    // we are the first thread to set this up.
+    this.readSynchronousMessages();
+    if (!this.state) {
+      // This assertion should be valid because the first Worker instantiation
+      // on the main thread makes sure that locks will be initialized.
+      assert(isMainThread);
+      const sab = new SharedArrayBuffer(16);
+      this.state = {
+        // Use a shared global counter to get ids for the individual
+        // lock requests.
+        lockIdCounter: new BigUint64Array(sab, 0, 1),
+        // The mutex used to ensure that no two threads access the internal
+        // state at the same time. Contains MUTEX_UNOWNED if unlocked, and the
+        // locker's threadId otherwise.
+        mutexOwner: new Int32Array(sab, 8, 1),
+        // Lists of the lock (request)s in their individual states.
+        held: [],
+        pending: [],
+        stolen: [],
+      };
+      this.unlockMutex();
+    }
+  }
+
+  readSynchronousMessages() {
+    let msg;
+    while (msg = receiveMessageOnPort(this.channel)) {
+      this.onmessage(msg.message);
+    }
+  }
+
+  publishState() {
+    this.channel.postMessage({
+      op: 'stateUpdate',
+      state: this.state,
+      [sticky_message_symbol]: true
+    });
+  }
+
+  lockMutex() {
+    // Lock the mutex and load all pending messages in order to update the
+    // internal state.
+    const mutex = this.state.mutexOwner;
+    let owner;
+    while ((owner = Atomics.compareExchange(
+      mutex, 0, MUTEX_UNOWNED, threadId)) !== MUTEX_UNOWNED) {
+      // We use a timeout to make sure that we still receive messages from
+      // threads that have terminated. It should be very rare to actually
+      // end up blocked on this, because the first other thread to observe
+      // the termination message will use Atomics.notify() to wake us up.
+      while (Atomics.wait(mutex, 0, owner, 100) === 'timed-out') {
+        this.readSynchronousMessages();
+      }
+    }
+    this.readSynchronousMessages();
+  }
+
+  unlockMutex(publish = true) {
+    // Provide the updated internal state to the other threads and
+    // unlock the mutex.
+    if (publish) {
+      this.publishState();
+    }
+    const owner = Atomics.compareExchange(
+      this.state.mutexOwner, 0, threadId, MUTEX_UNOWNED);
+    Atomics.notify(this.state.mutexOwner, 0);
+    assert(owner === threadId);
+  }
+
+  request(
+    { resolve, reject },
+    name,
+    shared,
+    ifAvailable,
+    steal) {
+    this.lockMutex();
+
+    // Let request be a new lock request (agent, clientId, origin, name,
+    // mode, promise).
+    const request = {
+      name,
+      shared,
+      clientId: this.clientId,
+      id: Atomics.add(this.state.lockIdCounter, 0, 1n)
+    };
+    const available = new Promise((resolve, reject) => {
+      this.availableMap.set(request.id, { resolve, reject });
+    });
+    this.resolveMap.set(request.id, { resolve, reject });
+
+    if (steal) {
+      // If steal is true, then run these steps:
+      for (let i = 0; i < this.state.held.length;) {
+        // For each lock of held:
+        // If lock's name is name, then run these steps:
+        if (this.state.held[i].name !== name) {
+          i++;
+          continue;
+        }
+        ArrayPrototypePush(this.state.stolen, this.state.held[i]);
+        // Remove lock from held.
+        ArrayPrototypeSplice(this.state.held, i, 1);
+      }
+      // Prepend request in queue.
+      ArrayPrototypeUnshift(this.state.pending, request);
+    } else {
+      // If ifAvailable is true and request is not grantable, then enqueue the
+      // following steps on callback's relevant settings object's responsible
+      // event loop:
+      if (ifAvailable && !this.isGrantable(request)) {
+        // Let r be the result of invoking callback with null as the
+        // only argument.
+        this.availableMap.delete(request.id);
+        this.resolveMap.delete(request.id);
+        this.unlockMutex();
+        return null;
+      }
+      // Enqueue request in queue.
+      ArrayPrototypePush(this.state.pending, request);
+    }
+    // Process the lock request queue queue.
+    this.processLockRequestQueue();
+    this.unlockMutex();
+    // Return request.
+    return {
+      available,
+      abort: () => {
+        this.lockMutex();
+        // Remove request from queue.
+        for (let i = 0; i < this.state.pending.length; i++) {
+          if (this.state.pending[i].id === request.id) {
+            ArrayPrototypeSplice(this.state.pending, i, 1);
+            break;
+          }
+        }
+        this.availableMap.get(request.id).resolve();
+        this.availableMap.delete(request.id);
+        this.resolveMap.delete(request.id);
+        // Process the lock request queue queue.
+        this.processLockRequestQueue();
+        this.unlockMutex();
+      },
+      release: () => {
+        this.lockMutex();
+        for (let i = 0; i < this.state.held.length; i++) {
+          if (this.state.held[i].id === request.id) {
+            ArrayPrototypeSplice(this.state.held, i, 1);
+            break;
+          }
+        }
+        this.resolveMap.delete(request.id);
+        this.processLockRequestQueue();
+        this.unlockMutex();
+      }
+    };
+  }
+
+  processLockRequestQueue() {
+    let didModify = false;
+    let hasOwnPendingRequests = false;
+    // For each request of queue:
+    for (let i = 0; i < this.state.pending.length;) {
+      const request = this.state.pending[i];
+      if (request.clientId !== this.clientId) {
+        i++;
+        continue;
+      }
+      if (!this.isGrantable(request)) {
+        hasOwnPendingRequests = true;
+        i++;
+        continue;
+      }
+      // If request is grantable, then run these steps:
+      // Append lock to origin's held lock set.
+      ArrayPrototypeSplice(this.state.pending, i, 1);
+      ArrayPrototypePush(this.state.held, request);
+      this.availableMap.get(request.id).resolve();
+      this.availableMap.delete(request.id);
+      didModify = true;
+    }
+    for (let i = 0; i < this.state.stolen.length;) {
+      const request = this.state.stolen[i];
+      if (request.clientId !== this.clientId) {
+        i++;
+        continue;
+      }
+
+      // Reject lock's released promise with an "AbortError" DOMException.
+      this.resolveMap.get(request.id).reject(
+        new DOMException('The operation was aborted', 'AbortError'));
+      this.resolveMap.delete(request.id);
+      ArrayPrototypeSplice(this.state.stolen, i, 1);
+      didModify = true;
+    }
+    // Let the event loop spin in case there are any pending requests pertaining
+    // to this thread.
+    if (hasOwnPendingRequests) {
+      this.channel.ref();
+    } else {
+      this.channel.unref();
+    }
+    return didModify;
+  }
+
+  isGrantable(request) {
+    // A lock request request is said to be grantable if the following steps
+    // return true:
+    // If mode is "exclusive", then return true if all of the following
+    // conditions are true, and false otherwise:
+    // - No lock in held has a name that equals name
+    // - No lock request in queue earlier than request exists.
+    // 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.
+    // - No lock request in queue earlier than request exists.
+    for (const lock of this.state.held) {
+      if (lock.name === request.name && (!lock.shared || !request.shared)) {
+        return false;
+      }
+    }
+    for (const lock of this.state.pending) {
+      if (lock.id < request.id &&
+          lock.name === request.name && (!lock.shared || !request.shared)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  onmessage(message) {
+    switch (message.op) {
+      case 'terminated': {
+        const { threadId, clientId } = message;
+        Atomics.compareExchange(
+          this.state.mutexOwner, 0, threadId, MUTEX_UNOWNED);
+        Atomics.notify(this.state.mutexOwner, 0);
+        queueMicrotask(() => {
+          this.lockMutex();
+          for (const list of [
+            this.state.held, this.state.pending, this.state.stolen
+          ]) {
+            // For each lock request request with agent equal to the
+            // terminating agent:
+            // - Abort the request request.
+            // For each lock lock with agent equal to the terminating agent:
+            // - Release the lock lock.
+            for (let i = 0; i < list.length;) {
+              if (list[i].clientId === clientId) {
+                ArrayPrototypeSplice(list, i, 1);
+              } else {
+                i++;
+              }
+            }
+          }
+          this.scheduleQueueProcessing();
+          this.unlockMutex();
+        });
+        break;
+      }
+      case 'stateUpdate': {
+        const { state } = message;
+        this.state = state;
+        // Enueue a call to processLockRequestQueue().
+        this.scheduleQueueProcessing();
+        break;
+      }
+      default:
+        assert(false);
+    }
+  }
+
+  scheduleQueueProcessing() {
+    if (this.queueProcessingScheduled) return;
+    this.queueProcessingScheduled = true;
+    queueMicrotask(() => {
+      this.queueProcessingScheduled = false;
+      this.lockMutex();
+      const didModify = this.processLockRequestQueue();
+      // Only publish the state information again in case we did make
+      // a change of some kind to avoid snowballing with state update
+      // messages.
+      this.unlockMutex(didModify);
+    });
+  }
+
+  snapshot() {
+    this.readSynchronousMessages();
+    const printLock = ({ name, shared, clientId }) =>
+      ({ name, mode: shared ? 'shared' : 'exclusive', clientId });
+    return {
+      held: ArrayPrototypeMap(this.state.held, printLock),
+      pending: ArrayPrototypeMap(this.state.pending, printLock),
+    };
+  }
+}
+let locks;
+
+// 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];
+  }
+}
+
+ObjectDefineProperties(Lock.prototype, {
+  name: { enumerable: true },
+  mode: { enumerable: true },
+  [SymbolToStringTag]: {
+    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
+  async request(name, options, callback) {
+    if (!locks) locks = new LockInternals();
+
+    if (callback === undefined) {
+      callback = options;
+      options = undefined;
+    }
+
+    // If options was not passed, then let options be a new LockOptions
+    // dictionary with default members.
+    options = {
+      mode: 'exclusive',
+      ifAvailable: false,
+      steal: false,
+      signal: undefined,
+      ...options
+    };
+
+    if (name.startsWith('-')) {
+      // If name starts with U+002D HYPHEN-MINUS (-), then reject promise with a
+      // "NotSupportedError" DOMException.
+      throw new DOMException('Lock name may not start with hyphen',
+                             '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.
+      throw new DOMException('ifAvailable and steal are mutually exclusive',
+                             'NotSupportedError');
+    } else if (options.mode !== 'shared' && options.mode !== 'exclusive') {
+      throw new ERR_INVALID_ARG_VALUE.TypeError(
+        'mode must be "shared" or "exclusive"');
+    } else if (options.mode !== 'exclusive' && options.steal === true) {
+      // If options' steal dictionary member is true and options' mode
+      // dictionary member is not "exclusive", then return a promise rejected
+      // with a "NotSupportedError" DOMException.
+      throw new DOMException('mode: "shared" and steal are mutually exclusive',
+                             'NotSupportedError');
+    } else if (options.signal &&
+               (options.steal === true || options.ifAvailable === true)) {
+      // If options' signal dictionary member is present, and either of
+      // options' steal dictionary member or options' ifAvailable dictionary
+      // member is true, then return a promise rejected with a
+      // "NotSupportedError" DOMException.
+      throw new DOMException('signal cannot be used with steal or ifAvailable',
+                             'NotSupportedError');
+    } else if (options.signal && options.signal.aborted) {
+      throw new DOMException('The operation was aborted', 'AbortError');
+    }
+
+    // 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.
+
+    let resolve, reject;
+    const result = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const shared = options.mode === 'shared';
+    const waiting = locks.request(
+      { resolve, reject },
+      name,
+      shared,
+      options.ifAvailable || false,
+      options.steal || false);
+
+    if (!waiting) {
+      assert(options.ifAvailable);
+      return callback(null);
+    }
+
+    const onabort = () => {
+      reject(new DOMException('The operation was aborted', 'AbortError'));
+      waiting.abort();
+    };
+    if (options.signal) {
+      options.signal.addEventListener('abort', onabort);
+    }
+
+    await waiting.available;
+
+    if (options.signal) {
+      options.signal.removeEventListener('abort', onabort);
+      if (options.signal.aborted) {
+        return result;
+      }
+    }
+
+    const lock = ObjectCreate(Lock.prototype, {
+      [kName]: {
+        value: name,
+        writable: false,
+        enumerable: false,
+        configurable: false,
+      },
+      [kMode]: {
+        value: shared ? 'shared' : 'exclusive',
+        writable: false,
+        enumerable: false,
+        configurable: false,
+      },
+    });
+
+    try {
+      // This is different from returning the awaited value, because using
+      // steal: true can be used by another thread to call reject() on the
+      // returned Promise.
+      resolve(await callback(lock));
+    } finally {
+      waiting.release();
+    }
+    return result;
+  }
+
+  // https://wicg.github.io/web-locks/#api-lock-manager-query
+  query() {
+    if (!locks) locks = new LockInternals();
+
+    return PromiseResolve().then(() => locks.snapshot());
+  }
+}
+
+ObjectDefineProperties(LockManager.prototype, {
+  request: { enumerable: true },
+  query: { enumerable: true },
+  [SymbolToStringTag]: {
+    value: 'LockManager',
+    writable: false,
+    enumerable: false,
+    configurable: true,
+  },
+});
+
+module.exports = {
+  Lock,
+  LockManager,
+  locks: ObjectCreate(LockManager.prototype),
+};
diff --git a/lib/worker_threads.js b/lib/worker_threads.js
index efa1c51112aac0..3c3ab01a390547 100644
--- a/lib/worker_threads.js
+++ b/lib/worker_threads.js
@@ -16,6 +16,10 @@ const {
   BroadcastChannel,
 } = require('internal/worker/io');
 
+const {
+  locks,
+} = require('internal/worker/locks');
+
 const {
   markAsUntransferable,
 } = require('internal/buffer');
@@ -34,4 +38,5 @@ module.exports = {
   parentPort: null,
   workerData: null,
   BroadcastChannel,
+  locks,
 };
diff --git a/node.gyp b/node.gyp
index 865a7de93176e5..703be4321fe832 100644
--- a/node.gyp
+++ b/node.gyp
@@ -243,6 +243,7 @@
       'lib/internal/worker.js',
       'lib/internal/worker/io.js',
       'lib/internal/worker/js_transferable.js',
+      'lib/internal/worker/locks.js',
       'lib/internal/watchdog.js',
       'lib/internal/streams/lazy_transform.js',
       'lib/internal/streams/add-abort-signal.js',
diff --git a/src/env.h b/src/env.h
index a0d59ff8728deb..104b27533db2fc 100644
--- a/src/env.h
+++ b/src/env.h
@@ -166,10 +166,12 @@ constexpr size_t kFsStatsBufferLength =
   V(messaging_transfer_symbol, "messaging_transfer_symbol")                    \
   V(messaging_clone_symbol, "messaging_clone_symbol")                          \
   V(messaging_transfer_list_symbol, "messaging_transfer_list_symbol")          \
+  V(onclose_message_symbol, "onclose_message_symbol")                          \
   V(oninit_symbol, "oninit")                                                   \
   V(owner_symbol, "owner_symbol")                                              \
   V(onpskexchange_symbol, "onpskexchange")                                     \
   V(resource_symbol, "resource_symbol")                                        \
+  V(sticky_message_symbol, "sticky_message_symbol")                            \
   V(trigger_async_id_symbol, "trigger_async_id_symbol")                        \
 
 // Strings are per-isolate primitives but Environment proxies them
diff --git a/src/node_messaging.cc b/src/node_messaging.cc
index 5f054c41c8eb04..fe9585ae526169 100644
--- a/src/node_messaging.cc
+++ b/src/node_messaging.cc
@@ -808,7 +808,8 @@ BaseObjectPtr<BaseObject> MessagePortData::Deserialize(
 
 Maybe<bool> MessagePort::PostMessage(Environment* env,
                                      Local<Value> message_v,
-                                     const TransferList& transfer_v) {
+                                     const TransferList& transfer_v,
+                                     MessageMode mode) {
   Isolate* isolate = env->isolate();
   Local<Object> obj = object(isolate);
   Local<Context> context = obj->CreationContext();
@@ -827,8 +828,13 @@ Maybe<bool> MessagePort::PostMessage(Environment* env,
     return Nothing<bool>();
   }
 
+  if (mode == MessageMode::ONCLOSE) {
+    data_->close_message_ = msg;
+    return Just(true);
+  }
+
   std::string error;
-  Maybe<bool> res = data_->Dispatch(msg, &error);
+  Maybe<bool> res = data_->Dispatch(msg, mode, &error);
   if (res.IsNothing())
     return res;
 
@@ -840,13 +846,14 @@ Maybe<bool> MessagePort::PostMessage(Environment* env,
 
 Maybe<bool> MessagePortData::Dispatch(
     std::shared_ptr<Message> message,
+    MessageMode mode,
     std::string* error) {
   if (!group_) {
     if (error != nullptr)
       *error = "MessagePortData is not entangled.";
     return Nothing<bool>();
   }
-  return group_->Dispatch(this, message, error);
+  return group_->Dispatch(this, message, mode, error);
 }
 
 static Maybe<bool> ReadIterable(Environment* env,
@@ -943,6 +950,17 @@ void MessagePort::PostMessage(const FunctionCallbackInfo<Value>& args) {
     }
   }
 
+  bool is_sticky = false;
+  bool is_onclose = false;
+  if (args[0]->IsObject()) {
+    if (!args[0].As<Object>()->Has(
+        context, env->sticky_message_symbol()).To(&is_sticky)) return;
+    if (!args[0].As<Object>()->Has(
+        context, env->onclose_message_symbol()).To(&is_onclose)) return;
+  }
+  MessageMode mode = is_sticky ? MessageMode::STICKY :
+      is_onclose ? MessageMode::ONCLOSE : MessageMode::NORMAL;
+
   MessagePort* port = Unwrap<MessagePort>(args.This());
   // Even if the backing MessagePort object has already been deleted, we still
   // want to serialize the message to ensure spec-compliant behavior w.r.t.
@@ -953,7 +971,7 @@ void MessagePort::PostMessage(const FunctionCallbackInfo<Value>& args) {
     return;
   }
 
-  Maybe<bool> res = port->PostMessage(env, args[0], transfer_list);
+  Maybe<bool> res = port->PostMessage(env, args[0], transfer_list, mode);
   if (res.IsJust())
     args.GetReturnValue().Set(res.FromJust());
 }
@@ -1291,8 +1309,8 @@ SiblingGroup::~SiblingGroup() {
 Maybe<bool> SiblingGroup::Dispatch(
     MessagePortData* source,
     std::shared_ptr<Message> message,
+    MessageMode mode,
     std::string* error) {
-
   Mutex::ScopedLock lock(group_mutex_);
 
   // The source MessagePortData is not part of this group.
@@ -1302,10 +1320,6 @@ Maybe<bool> SiblingGroup::Dispatch(
     return Nothing<bool>();
   }
 
-  // There are no destination ports.
-  if (size() <= 1)
-    return Just(false);
-
   // Transferables cannot be used when there is more
   // than a single destination.
   if (size() > 2 && message->has_transferables()) {
@@ -1314,6 +1328,14 @@ Maybe<bool> SiblingGroup::Dispatch(
     return Nothing<bool>();
   }
 
+  if (mode == MessageMode::STICKY) {
+    sticky_message_ = message;
+  }
+
+  // There are no destination ports.
+  if (size() <= 1)
+    return Just(false);
+
   for (MessagePortData* port : ports_) {
     if (port == source)
       continue;
@@ -1343,11 +1365,17 @@ void SiblingGroup::Entangle(std::initializer_list<MessagePortData*> ports) {
     ports_.insert(data);
     CHECK(!data->group_);
     data->group_ = shared_from_this();
+    if (sticky_message_) {
+      data->AddToIncomingQueue(sticky_message_);
+    }
   }
 }
 
 void SiblingGroup::Disentangle(MessagePortData* data) {
   auto self = shared_from_this();  // Keep alive until end of function.
+  if (data->close_message_) {
+    Dispatch(data, std::move(data->close_message_));
+  }
   Mutex::ScopedLock lock(group_mutex_);
   ports_.erase(data);
   data->group_.reset();
diff --git a/src/node_messaging.h b/src/node_messaging.h
index ad06565977215c..42b01e1e95b0af 100644
--- a/src/node_messaging.h
+++ b/src/node_messaging.h
@@ -113,6 +113,20 @@ class Message : public MemoryRetainer {
   friend class MessagePort;
 };
 
+enum class MessageMode {
+  // Regular messages. Sent and delivered to all recipients.
+  NORMAL,
+
+  // Sticky messages. Like normal, but also delivered as the first message for
+  // new message ports in the sibling group. A new sticky message replaces
+  // previous ones for the group.
+  STICKY,
+
+  // Close message. Will only be delivered right before the sending message port
+  // is being closed. A new onclose message replaces previous ones for the port.
+  ONCLOSE
+};
+
 class SiblingGroup final : public std::enable_shared_from_this<SiblingGroup> {
  public:
   // Named SiblingGroup, Used for one-to-many BroadcastChannels.
@@ -134,6 +148,7 @@ class SiblingGroup final : public std::enable_shared_from_this<SiblingGroup> {
   v8::Maybe<bool> Dispatch(
       MessagePortData* source,
       std::shared_ptr<Message> message,
+      MessageMode = MessageMode::NORMAL,
       std::string* error = nullptr);
 
   void Entangle(MessagePortData* data);
@@ -147,6 +162,7 @@ class SiblingGroup final : public std::enable_shared_from_this<SiblingGroup> {
  private:
   std::string name_;
   std::set<MessagePortData*> ports_;
+  std::shared_ptr<Message> sticky_message_;
   Mutex group_mutex_;
 
   static void CheckSiblingGroup(const std::string& name);
@@ -175,6 +191,7 @@ class MessagePortData : public TransferData {
   void AddToIncomingQueue(std::shared_ptr<Message> message);
   v8::Maybe<bool> Dispatch(
       std::shared_ptr<Message> message,
+      MessageMode mode = MessageMode::NORMAL,
       std::string* error = nullptr);
 
   // Turns `a` and `b` into siblings, i.e. connects the sending side of one
@@ -203,6 +220,7 @@ class MessagePortData : public TransferData {
   std::deque<std::shared_ptr<Message>> incoming_messages_;
   MessagePort* owner_ = nullptr;
   std::shared_ptr<SiblingGroup> group_;
+  std::shared_ptr<Message> close_message_;
   friend class MessagePort;
   friend class SiblingGroup;
 };
@@ -235,7 +253,8 @@ class MessagePort : public HandleWrap {
   // serialized with transfers, then silently discarded.
   v8::Maybe<bool> PostMessage(Environment* env,
                               v8::Local<v8::Value> message,
-                              const TransferList& transfer);
+                              const TransferList& transfer,
+                              MessageMode mode = MessageMode::NORMAL);
 
   // Start processing messages on this port as a receiving end.
   void Start();
diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md
index 855fca6d179ff6..e3fbbab2c7f9e9 100644
--- a/test/fixtures/wpt/README.md
+++ b/test/fixtures/wpt/README.md
@@ -13,13 +13,14 @@ Last update:
 - console: https://github.com/web-platform-tests/wpt/tree/3b1f72e99a/console
 - encoding: https://github.com/web-platform-tests/wpt/tree/1821fb5f77/encoding
 - url: https://github.com/web-platform-tests/wpt/tree/09d8830be1/url
-- resources: https://github.com/web-platform-tests/wpt/tree/001e50de41/resources
-- interfaces: https://github.com/web-platform-tests/wpt/tree/8719553b2d/interfaces
+- resources: https://github.com/web-platform-tests/wpt/tree/351a99782b/resources
+- interfaces: https://github.com/web-platform-tests/wpt/tree/c37c28b8a8/interfaces
 - html/webappapis/microtask-queuing: https://github.com/web-platform-tests/wpt/tree/2c5c3c4c27/html/webappapis/microtask-queuing
 - html/webappapis/timers: https://github.com/web-platform-tests/wpt/tree/264f12bc7b/html/webappapis/timers
 - hr-time: https://github.com/web-platform-tests/wpt/tree/a5d1774ecf/hr-time
 - common: https://github.com/web-platform-tests/wpt/tree/4dacb6e2ff/common
 - dom/abort: https://github.com/web-platform-tests/wpt/tree/7caa3de747/dom/abort
+- web-locks: https://github.com/web-platform-tests/wpt/tree/e2ddf48b78/web-locks
 
 [Web Platform Tests]: https://github.com/web-platform-tests/wpt
 [`git node wpt`]: https://github.com/nodejs/node-core-utils/blob/master/docs/git-node.md#git-node-wpt
diff --git a/test/fixtures/wpt/interfaces/dom.idl b/test/fixtures/wpt/interfaces/dom.idl
index ffc5b063219d4d..9d371fbe7c5f63 100644
--- a/test/fixtures/wpt/interfaces/dom.idl
+++ b/test/fixtures/wpt/interfaces/dom.idl
@@ -9,7 +9,7 @@ interface Event {
 
   readonly attribute DOMString type;
   readonly attribute EventTarget? target;
-  readonly attribute EventTarget? srcElement; // historical
+  readonly attribute EventTarget? srcElement; // legacy
   readonly attribute EventTarget? currentTarget;
   sequence<EventTarget> composedPath();
 
@@ -20,12 +20,12 @@ interface Event {
   readonly attribute unsigned short eventPhase;
 
   undefined stopPropagation();
-           attribute boolean cancelBubble; // historical alias of .stopPropagation
+           attribute boolean cancelBubble; // legacy alias of .stopPropagation()
   undefined stopImmediatePropagation();
 
   readonly attribute boolean bubbles;
   readonly attribute boolean cancelable;
-           attribute boolean returnValue;  // historical
+           attribute boolean returnValue;  // legacy
   undefined preventDefault();
   readonly attribute boolean defaultPrevented;
   readonly attribute boolean composed;
@@ -33,7 +33,7 @@ interface Event {
   [LegacyUnforgeable] readonly attribute boolean isTrusted;
   readonly attribute DOMHighResTimeStamp timeStamp;
 
-  undefined initEvent(DOMString type, optional boolean bubbles = false, optional boolean cancelable = false); // historical
+  undefined initEvent(DOMString type, optional boolean bubbles = false, optional boolean cancelable = false); // legacy
 };
 
 dictionary EventInit {
@@ -43,7 +43,7 @@ dictionary EventInit {
 };
 
 partial interface Window {
-  [Replaceable] readonly attribute any event; // historical
+  [Replaceable] readonly attribute any event; // legacy
 };
 
 [Exposed=(Window,Worker)]
@@ -52,7 +52,7 @@ interface CustomEvent : Event {
 
   readonly attribute any detail;
 
-  undefined initCustomEvent(DOMString type, optional boolean bubbles = false, optional boolean cancelable = false, optional any detail = null); // historical
+  undefined initCustomEvent(DOMString type, optional boolean bubbles = false, optional boolean cancelable = false, optional any detail = null); // legacy
 };
 
 dictionary CustomEventInit : EventInit {
@@ -79,6 +79,7 @@ dictionary EventListenerOptions {
 dictionary AddEventListenerOptions : EventListenerOptions {
   boolean passive = false;
   boolean once = false;
+  AbortSignal signal;
 };
 
 [Exposed=(Window,Worker)]
@@ -201,14 +202,14 @@ interface Node : EventTarget {
   const unsigned short ATTRIBUTE_NODE = 2;
   const unsigned short TEXT_NODE = 3;
   const unsigned short CDATA_SECTION_NODE = 4;
-  const unsigned short ENTITY_REFERENCE_NODE = 5; // historical
-  const unsigned short ENTITY_NODE = 6; // historical
+  const unsigned short ENTITY_REFERENCE_NODE = 5; // legacy
+  const unsigned short ENTITY_NODE = 6; // legacy
   const unsigned short PROCESSING_INSTRUCTION_NODE = 7;
   const unsigned short COMMENT_NODE = 8;
   const unsigned short DOCUMENT_NODE = 9;
   const unsigned short DOCUMENT_TYPE_NODE = 10;
   const unsigned short DOCUMENT_FRAGMENT_NODE = 11;
-  const unsigned short NOTATION_NODE = 12; // historical
+  const unsigned short NOTATION_NODE = 12; // legacy
   readonly attribute unsigned short nodeType;
   readonly attribute DOMString nodeName;
 
@@ -232,7 +233,7 @@ interface Node : EventTarget {
 
   [CEReactions, NewObject] Node cloneNode(optional boolean deep = false);
   boolean isEqualNode(Node? otherNode);
-  boolean isSameNode(Node? otherNode); // historical alias of ===
+  boolean isSameNode(Node? otherNode); // legacy alias of ===
 
   const unsigned short DOCUMENT_POSITION_DISCONNECTED = 0x01;
   const unsigned short DOCUMENT_POSITION_PRECEDING = 0x02;
@@ -266,8 +267,8 @@ interface Document : Node {
   readonly attribute USVString documentURI;
   readonly attribute DOMString compatMode;
   readonly attribute DOMString characterSet;
-  readonly attribute DOMString charset; // historical alias of .characterSet
-  readonly attribute DOMString inputEncoding; // historical alias of .characterSet
+  readonly attribute DOMString charset; // legacy alias of .characterSet
+  readonly attribute DOMString inputEncoding; // legacy alias of .characterSet
   readonly attribute DOMString contentType;
 
   readonly attribute DocumentType? doctype;
@@ -290,7 +291,7 @@ interface Document : Node {
   [NewObject] Attr createAttribute(DOMString localName);
   [NewObject] Attr createAttributeNS(DOMString? namespace, DOMString qualifiedName);
 
-  [NewObject] Event createEvent(DOMString interface); // historical
+  [NewObject] Event createEvent(DOMString interface); // legacy
 
   [NewObject] Range createRange();
 
@@ -372,14 +373,14 @@ interface Element : Node {
 
   Element? closest(DOMString selectors);
   boolean matches(DOMString selectors);
-  boolean webkitMatchesSelector(DOMString selectors); // historical alias of .matches
+  boolean webkitMatchesSelector(DOMString selectors); // legacy alias of .matches
 
   HTMLCollection getElementsByTagName(DOMString qualifiedName);
   HTMLCollection getElementsByTagNameNS(DOMString? namespace, DOMString localName);
   HTMLCollection getElementsByClassName(DOMString classNames);
 
-  [CEReactions] Element? insertAdjacentElement(DOMString where, Element element); // historical
-  undefined insertAdjacentText(DOMString where, DOMString data); // historical
+  [CEReactions] Element? insertAdjacentElement(DOMString where, Element element); // legacy
+  undefined insertAdjacentText(DOMString where, DOMString data); // legacy
 };
 
 dictionary ShadowRootInit {
@@ -545,14 +546,14 @@ callback interface NodeFilter {
   const unsigned long SHOW_ATTRIBUTE = 0x2;
   const unsigned long SHOW_TEXT = 0x4;
   const unsigned long SHOW_CDATA_SECTION = 0x8;
-  const unsigned long SHOW_ENTITY_REFERENCE = 0x10; // historical
-  const unsigned long SHOW_ENTITY = 0x20; // historical
+  const unsigned long SHOW_ENTITY_REFERENCE = 0x10; // legacy
+  const unsigned long SHOW_ENTITY = 0x20; // legacy
   const unsigned long SHOW_PROCESSING_INSTRUCTION = 0x40;
   const unsigned long SHOW_COMMENT = 0x80;
   const unsigned long SHOW_DOCUMENT = 0x100;
   const unsigned long SHOW_DOCUMENT_TYPE = 0x200;
   const unsigned long SHOW_DOCUMENT_FRAGMENT = 0x400;
-  const unsigned long SHOW_NOTATION = 0x800; // historical
+  const unsigned long SHOW_NOTATION = 0x800; // legacy
 
   unsigned short acceptNode(Node node);
 };
diff --git a/test/fixtures/wpt/interfaces/html.idl b/test/fixtures/wpt/interfaces/html.idl
index bf8da3733ec26f..dfe4e1e586b5a2 100644
--- a/test/fixtures/wpt/interfaces/html.idl
+++ b/test/fixtures/wpt/interfaces/html.idl
@@ -1701,8 +1701,7 @@ interface Window : EventTarget {
 
   // the user agent
   readonly attribute Navigator navigator;
-  [SecureContext] readonly attribute ApplicationCache applicationCache;
-  readonly attribute boolean originIsolated;
+  readonly attribute boolean originAgentCluster;
 
   // user prompts
   undefined alert();
@@ -1801,39 +1800,6 @@ interface BeforeUnloadEvent : Event {
   attribute DOMString returnValue;
 };
 
-[SecureContext,
- Exposed=Window]
-interface ApplicationCache : EventTarget {
-
-  // update status
-  const unsigned short UNCACHED = 0;
-  const unsigned short IDLE = 1;
-  const unsigned short CHECKING = 2;
-  const unsigned short DOWNLOADING = 3;
-  const unsigned short UPDATEREADY = 4;
-  const unsigned short OBSOLETE = 5;
-  readonly attribute unsigned short status;
-
-  // updates
-  undefined update();
-  undefined abort();
-  undefined swapCache();
-
-  // events
-  attribute EventHandler onchecking;
-  attribute EventHandler onerror;
-  attribute EventHandler onnoupdate;
-  attribute EventHandler ondownloading;
-  attribute EventHandler onprogress;
-  attribute EventHandler onupdateready;
-  attribute EventHandler oncached;
-  attribute EventHandler onobsolete;
-};
-
-interface mixin NavigatorOnLine {
-  readonly attribute boolean onLine;
-};
-
 [Exposed=(Window,Worker)]
 interface ErrorEvent : Event {
   constructor(DOMString type, optional ErrorEventInit eventInitDict = {});
@@ -2048,6 +2014,10 @@ interface mixin NavigatorLanguage {
   readonly attribute FrozenArray<DOMString> languages;
 };
 
+interface mixin NavigatorOnLine {
+  readonly attribute boolean onLine;
+};
+
 interface mixin NavigatorContentUtils {
   [SecureContext] undefined registerProtocolHandler(DOMString scheme, USVString url);
   [SecureContext] undefined unregisterProtocolHandler(DOMString scheme, USVString url);
diff --git a/test/fixtures/wpt/interfaces/web-locks.idl b/test/fixtures/wpt/interfaces/web-locks.idl
new file mode 100644
index 00000000000000..a0319a00fd208a
--- /dev/null
+++ b/test/fixtures/wpt/interfaces/web-locks.idl
@@ -0,0 +1,50 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into webref
+// (https://github.com/w3c/webref)
+// Source: Web Locks API (https://wicg.github.io/web-locks/)
+
+[SecureContext]
+interface mixin NavigatorLocks {
+  readonly attribute LockManager locks;
+};
+Navigator includes NavigatorLocks;
+WorkerNavigator includes NavigatorLocks;
+
+[SecureContext, Exposed=(Window,Worker)]
+interface LockManager {
+  Promise<any> request(DOMString name,
+                       LockGrantedCallback callback);
+  Promise<any> request(DOMString name,
+                       LockOptions options,
+                       LockGrantedCallback callback);
+
+  Promise<LockManagerSnapshot> query();
+};
+
+callback LockGrantedCallback = Promise<any> (Lock? lock);
+
+enum LockMode { "shared", "exclusive" };
+
+dictionary LockOptions {
+  LockMode mode = "exclusive";
+  boolean ifAvailable = false;
+  boolean steal = false;
+  AbortSignal signal;
+};
+
+dictionary LockManagerSnapshot {
+  sequence<LockInfo> held;
+  sequence<LockInfo> pending;
+};
+
+dictionary LockInfo {
+  DOMString name;
+  LockMode mode;
+  DOMString clientId;
+};
+
+[SecureContext, Exposed=(Window,Worker)]
+interface Lock {
+  readonly attribute DOMString name;
+  readonly attribute LockMode mode;
+};
diff --git a/test/fixtures/wpt/resources/testdriver-actions.js b/test/fixtures/wpt/resources/testdriver-actions.js
index f3e6388e8acd19..4dafa0c018b101 100644
--- a/test/fixtures/wpt/resources/testdriver-actions.js
+++ b/test/fixtures/wpt/resources/testdriver-actions.js
@@ -281,9 +281,12 @@
      *                               pointer source
      * @returns {Actions}
      */
-    pointerDown: function({button=this.ButtonType.LEFT, sourceName=null}={}) {
+    pointerDown: function({button=this.ButtonType.LEFT, sourceName=null,
+                           width, height, pressure, tangentialPressure,
+                           tiltX, tiltY, twist, altitudeAngle, azimuthAngle}={}) {
       let source = this.getSource("pointer", sourceName);
-      source.pointerDown(this, button);
+      source.pointerDown(this, button, width, height, pressure, tangentialPressure,
+                         tiltX, tiltY, twist, altitudeAngle, azimuthAngle);
       return this;
     },
 
@@ -314,9 +317,13 @@
      * @returns {Actions}
      */
     pointerMove: function(x, y,
-                          {origin="viewport", duration, sourceName=null}={}) {
+                          {origin="viewport", duration, sourceName=null,
+                           width, height, pressure, tangentialPressure,
+                           tiltX, tiltY, twist, altitudeAngle, azimuthAngle}={}) {
       let source = this.getSource("pointer", sourceName);
-      source.pointerMove(this, x, y, duration, origin);
+      source.pointerMove(this, x, y, duration, origin, width, height, pressure,
+                         tangentialPressure, tiltX, tiltY, twist, altitudeAngle,
+                         azimuthAngle);
       return this;
     },
 
@@ -424,6 +431,38 @@
     this.actions = new Map();
   }
 
+  function setPointerProperties(action, width, height, pressure, tangentialPressure,
+                                tiltX, tiltY, twist, altitudeAngle, azimuthAngle) {
+    if (width) {
+      action.width = width;
+    }
+    if (height) {
+      action.height = height;
+    }
+    if (pressure) {
+      action.pressure = pressure;
+    }
+    if (tangentialPressure) {
+      action.tangentialPressure = tangentialPressure;
+    }
+    if (tiltX) {
+      action.tiltX = tiltX;
+    }
+    if (tiltY) {
+      action.tiltY = tiltY;
+    }
+    if (twist) {
+      action.twist = twist;
+    }
+    if (altitudeAngle) {
+      action.altitudeAngle = altitudeAngle;
+    }
+    if (azimuthAngle) {
+      action.azimuthAngle = azimuthAngle;
+    }
+    return action;
+  }
+
   PointerSource.prototype = {
     serialize: function(tickCount) {
       if (!this.actions.size) {
@@ -441,12 +480,16 @@
       return data;
     },
 
-    pointerDown: function(actions, button) {
+    pointerDown: function(actions, button, width, height, pressure, tangentialPressure,
+                          tiltX, tiltY, twist, altitudeAngle, azimuthAngle) {
       let tick = actions.tickIdx;
       if (this.actions.has(tick)) {
         tick = actions.addTick().tickIdx;
       }
-      this.actions.set(tick, {type: "pointerDown", button});
+      let actionProperties = setPointerProperties({type: "pointerDown", button}, width, height,
+                                                  pressure, tangentialPressure, tiltX, tiltY,
+                                                  twist, altitudeAngle, azimuthAngle);
+      this.actions.set(tick, actionProperties);
     },
 
     pointerUp: function(actions, button) {
@@ -457,15 +500,20 @@
       this.actions.set(tick, {type: "pointerUp", button});
     },
 
-    pointerMove: function(actions, x, y, duration, origin) {
+    pointerMove: function(actions, x, y, duration, origin, width, height, pressure,
+                          tangentialPressure, tiltX, tiltY, twist, altitudeAngle, azimuthAngle) {
       let tick = actions.tickIdx;
       if (this.actions.has(tick)) {
         tick = actions.addTick().tickIdx;
       }
-      this.actions.set(tick, {type: "pointerMove", x, y, origin});
+      let moveAction = {type: "pointerMove", x, y, origin};
       if (duration) {
-        this.actions.get(tick).duration = duration;
+        moveAction.duration = duration;
       }
+      let actionProperties = setPointerProperties(moveAction, width, height, pressure,
+                                                  tangentialPressure, tiltX, tiltY, twist,
+                                                  altitudeAngle, azimuthAngle);
+      this.actions.set(tick, actionProperties);
     },
 
     addPause: function(actions, duration) {
diff --git a/test/fixtures/wpt/resources/testdriver.js b/test/fixtures/wpt/resources/testdriver.js
index c53b24136c091f..f3cee9821e13f9 100644
--- a/test/fixtures/wpt/resources/testdriver.js
+++ b/test/fixtures/wpt/resources/testdriver.js
@@ -146,6 +146,24 @@
                                                       y: centerPoint[1]});
         },
 
+        /**
+         * Deletes all cookies.
+         *
+         * This matches the behaviour of the {@link
+         * https://w3c.github.io/webdriver/#delete-all-cookies|WebDriver
+         * Delete All Cookies command}.
+         *
+         * @param {WindowProxy} context - Browsing context in which
+         *                                to run the call, or null for the current
+         *                                browsing context.
+         *
+         * @returns {Promise} fulfilled after cookies are deleted, or rejected in
+         *                    the cases the WebDriver command errors
+         */
+        delete_all_cookies: function(context=null) {
+            return window.test_driver_internal.delete_all_cookies(context);
+        },
+
         /**
          * Send keys to an element
          *
@@ -458,6 +476,10 @@
             });
         },
 
+        delete_all_cookies: function(context=null) {
+            return Promise.reject(new Error("unimplemented"));
+        },
+
         send_keys: function(element, keys) {
             if (this.in_automation) {
                 return Promise.reject(new Error('Not implemented'));
diff --git a/test/fixtures/wpt/resources/testharness.js b/test/fixtures/wpt/resources/testharness.js
index d50e094117df56..f7fe7531710d23 100644
--- a/test/fixtures/wpt/resources/testharness.js
+++ b/test/fixtures/wpt/resources/testharness.js
@@ -2956,22 +2956,16 @@ policies and contribution forms [3].
     }
 
     function sanitize_unpaired_surrogates(str) {
-        return str.replace(/([\ud800-\udbff])(?![\udc00-\udfff])/g,
-                           function(_, unpaired)
-                           {
-                               return code_unit_str(unpaired);
-                           })
-                  // This replacement is intentionally implemented without an
-                  // ES2018 negative lookbehind assertion to support runtimes
-                  // which do not yet implement that language feature.
-                  .replace(/(^|[^\ud800-\udbff])([\udc00-\udfff])/g,
-                           function(_, previous, unpaired) {
-                              if (/[\udc00-\udfff]/.test(previous)) {
-                                  previous = code_unit_str(previous);
-                              }
-
-                              return previous + code_unit_str(unpaired);
-                           });
+        return str.replace(
+            /([\ud800-\udbff]+)(?![\udc00-\udfff])|(^|[^\ud800-\udbff])([\udc00-\udfff]+)/g,
+            function(_, low, prefix, high) {
+                var output = prefix || "";  // prefix may be undefined
+                var string = low || high;  // only one of these alternates can match
+                for (var i = 0; i < string.length; i++) {
+                    output += code_unit_str(string[i]);
+                }
+                return output;
+            });
     }
 
     function sanitize_all_unpaired_surrogates(tests) {
@@ -3612,6 +3606,9 @@ policies and contribution forms [3].
 
     function AssertionError(message)
     {
+        if (typeof message == "string") {
+            message = sanitize_unpaired_surrogates(message);
+        }
         this.message = message;
         this.stack = this.get_stack();
     }
diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json
index f1e9b8304d5fda..4e7ea414a810d7 100644
--- a/test/fixtures/wpt/versions.json
+++ b/test/fixtures/wpt/versions.json
@@ -12,11 +12,11 @@
     "path": "url"
   },
   "resources": {
-    "commit": "001e50de41dc35820774b27e31f77a165f4c0b9b",
+    "commit": "351a99782b9677706b5dc0dd78e85978fa4ab130",
     "path": "resources"
   },
   "interfaces": {
-    "commit": "8719553b2dd8f0f39d38253ccac2ee9ab4d6c87b",
+    "commit": "c37c28b8a854c911a619f72c7f2bee5f28f3e1ee",
     "path": "interfaces"
   },
   "html/webappapis/microtask-queuing": {
@@ -38,5 +38,9 @@
   "dom/abort": {
     "commit": "7caa3de7471cf19b78ee9efa313c7341a462b5e3",
     "path": "dom/abort"
+  },
+  "web-locks": {
+    "commit": "e2ddf48b78209d0aef4fa513b53a9f28243c9335",
+    "path": "web-locks"
   }
 }
\ No newline at end of file
diff --git a/test/fixtures/wpt/web-locks/META.yml b/test/fixtures/wpt/web-locks/META.yml
new file mode 100644
index 00000000000000..24e7d28340606d
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/META.yml
@@ -0,0 +1,4 @@
+spec: https://wicg.github.io/web-locks/
+suggested_reviewers:
+  - inexorabletash
+  - pwnall
diff --git a/test/fixtures/wpt/web-locks/README.md b/test/fixtures/wpt/web-locks/README.md
new file mode 100644
index 00000000000000..8ff534e1b6f143
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/README.md
@@ -0,0 +1,5 @@
+This directory contains a test suite for the proposed Web Locks API.
+
+Explainer: https://github.com/WICG/web-locks/
+
+Spec: https://wicg.github.io/web-locks/
diff --git a/test/fixtures/wpt/web-locks/acquire.tentative.https.any.js b/test/fixtures/wpt/web-locks/acquire.tentative.https.any.js
new file mode 100644
index 00000000000000..fd7689b3e182c2
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/acquire.tentative.https.any.js
@@ -0,0 +1,124 @@
+// META: title=Web Locks API: navigator.locks.request method
+// META: script=resources/helpers.js
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+
+'use strict';
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  await promise_rejects_js(t, TypeError, navigator.locks.request());
+  await promise_rejects_js(t, TypeError, navigator.locks.request(res));
+}, 'navigator.locks.request requires a name and a callback');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  await promise_rejects_js(
+    t, TypeError,
+    navigator.locks.request(res, {mode: 'foo'}, lock => {}));
+  await promise_rejects_js(
+    t, TypeError,
+    navigator.locks.request(res, {mode: null }, lock => {}));
+  assert_equals(await navigator.locks.request(
+    res, {mode: 'exclusive'}, lock => lock.mode), 'exclusive',
+                'mode is exclusive');
+  assert_equals(await navigator.locks.request(
+    res, {mode: 'shared'}, lock => lock.mode), 'shared',
+                'mode is shared');
+}, 'mode must be "shared" or "exclusive"');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  await promise_rejects_dom(
+    t, 'NotSupportedError',
+    navigator.locks.request(
+      res, {steal: true, ifAvailable: true}, lock => {}),
+    "A NotSupportedError should be thrown if both " +
+    "'steal' and 'ifAvailable' are specified.");
+}, "The 'steal' and 'ifAvailable' options are mutually exclusive");
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  await promise_rejects_dom(
+    t, 'NotSupportedError',
+    navigator.locks.request(res, {mode: 'shared', steal: true}, lock => {}),
+    'Request with mode=shared and steal=true should fail');
+}, "The 'steal' option must be used with exclusive locks");
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  const controller = new AbortController();
+  await promise_rejects_dom(
+    t, 'NotSupportedError',
+    navigator.locks.request(
+      res, {signal: controller.signal, steal: true}, lock => {}),
+    'Request with signal and steal=true should fail');
+}, "The 'signal' and 'steal' options are mutually exclusive");
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  const controller = new AbortController();
+  await promise_rejects_dom(
+    t, 'NotSupportedError',
+    navigator.locks.request(
+      res, {signal: controller.signal, ifAvailable: true}, lock => {}),
+    'Request with signal and ifAvailable=true should fail');
+}, "The 'signal' and 'ifAvailable' options are mutually exclusive");
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  await promise_rejects_js(
+    t, TypeError, navigator.locks.request(res, undefined));
+  await promise_rejects_js(
+    t, TypeError, navigator.locks.request(res, null));
+  await promise_rejects_js(
+    t, TypeError, navigator.locks.request(res, 123));
+  await promise_rejects_js(
+    t, TypeError, navigator.locks.request(res, 'abc'));
+  await promise_rejects_js(
+    t, TypeError, navigator.locks.request(res, []));
+  await promise_rejects_js(
+    t, TypeError, navigator.locks.request(res, {}));
+  await promise_rejects_js(
+    t, TypeError, navigator.locks.request(res, new Promise(r => {})));
+}, 'callback must be a function');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  let release;
+  const promise = new Promise(r => { release = r; });
+
+  let returned = navigator.locks.request(res, lock => { return promise; });
+
+  const order = [];
+
+  returned.then(() => { order.push('returned'); });
+  promise.then(() => { order.push('holding'); });
+
+  release();
+
+  await Promise.all([returned, promise]);
+
+  assert_array_equals(order, ['holding', 'returned']);
+
+}, 'navigator.locks.request\'s returned promise resolves after' +
+   ' lock is released');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  const test_error = {name: 'test'};
+  const p = navigator.locks.request(res, lock => {
+    throw test_error;
+  });
+  assert_equals(Promise.resolve(p), p, 'request() result is a Promise');
+  await promise_rejects_exactly(t, test_error, p, 'result should reject');
+}, 'Returned Promise rejects if callback throws synchronously');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  const test_error = {name: 'test'};
+  const p = navigator.locks.request(res, async lock => {
+    throw test_error;
+  });
+  assert_equals(Promise.resolve(p), p, 'request() result is a Promise');
+  await promise_rejects_exactly(t, test_error, p, 'result should reject');
+}, 'Returned Promise rejects if callback throws asynchronously');
diff --git a/test/fixtures/wpt/web-locks/clientids.tentative.https.html b/test/fixtures/wpt/web-locks/clientids.tentative.https.html
new file mode 100644
index 00000000000000..c5d066d155582a
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/clientids.tentative.https.html
@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>Web Locks API: Client IDs in query() vs. Service Worker</title>
+<link rel=help href="https://wicg.github.io/web-locks/">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
+<script>
+
+// Returns a promise resolved by the next message event.
+function nextMessage() {
+  return new Promise(resolve => {
+    window.addEventListener('message', event => {
+      resolve(event.data);
+    }, {once: true});
+  });
+}
+
+promise_test(async t => {
+  assert_implements(navigator.locks);
+  const iframe_url = 'resources/sw-controlled-iframe.html';
+
+  // Register a service worker that will control an iframe.
+  const registration = await service_worker_unregister_and_register(
+    t, 'resources/service-worker.js', iframe_url);
+  await wait_for_state(t, registration.installing, 'activated');
+
+  const iframe = await with_iframe(iframe_url);
+
+  iframe.contentWindow.postMessage('get_sw_client_id', '*');
+  const sw_client_id = await nextMessage();
+
+  iframe.contentWindow.postMessage('get_lock_client_id', '*');
+  const lock_client_id = await nextMessage();
+
+  // NOTE: Not assert_equals(), as we don't want log the randomly generated
+  // clientIds, since they would not match any failure expectation files.
+  assert_equals(lock_client_id, sw_client_id,
+              'clientIds should match, but are different');
+
+  await registration.unregister();
+
+}, 'Client IDs match between Locks API and Service Workers');
+
+</script>
diff --git a/test/fixtures/wpt/web-locks/frames.tentative.https.html b/test/fixtures/wpt/web-locks/frames.tentative.https.html
new file mode 100644
index 00000000000000..84760f2f40577b
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/frames.tentative.https.html
@@ -0,0 +1,246 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>Web Locks API: Frames</title>
+<link rel=help href="https://wicg.github.io/web-locks/">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="resources/helpers.js"></script>
+<style>iframe { display: none; }</style>
+<script>
+'use strict';
+
+promise_test(async t => {
+  assert_implements(navigator.locks);
+  const res = uniqueName(t);
+
+  const frame = await iframe('resources/iframe.html');
+  t.add_cleanup(() => { frame.remove(); });
+
+  const lock_id = (await postToFrameAndWait(
+    frame, {op: 'request', name: res, mode: 'shared'})).lock_id;
+
+  await navigator.locks.request(res, {mode: 'shared'}, async lock => {
+    await postToFrameAndWait(frame, {op: 'release', lock_id});
+  });
+
+}, 'Window and Frame - shared mode');
+
+promise_test(async t => {
+  assert_implements(navigator.locks);
+  const res = uniqueName(t);
+
+  const frame = await iframe('resources/iframe.html');
+  t.add_cleanup(() => { frame.remove(); });
+
+  // frame acquires the lock.
+  const lock_id = (await postToFrameAndWait(
+    frame, {op: 'request', name: res})).lock_id;
+
+  // This request should be blocked.
+  let lock_granted = false;
+  const blocked = navigator.locks.request(res, lock => { lock_granted = true; });
+
+  // Verify that we can't get it.
+  let available = undefined;
+  await navigator.locks.request(
+    res, {ifAvailable: true}, lock => { available = lock !== null; });
+  assert_false(available);
+  assert_false(lock_granted);
+
+  // Ask the frame to release it.
+  await postToFrameAndWait(frame, {op: 'release', lock_id});
+
+  await blocked;
+  // Now we've got it.
+  assert_true(lock_granted);
+}, 'Window and Frame - exclusive mode');
+
+promise_test(async t => {
+  assert_implements(navigator.locks);
+  const res = uniqueName(t);
+
+  const frame1 = await iframe('resources/iframe.html');
+  const frame2 = await iframe('resources/iframe.html');
+
+  // frame1 acquires the lock.
+  const lock_id = (await postToFrameAndWait(
+    frame1, {op: 'request', name: res})).lock_id;
+
+  // frame2's request should be blocked.
+  let lock_granted = false;
+  const blocked = postToFrameAndWait(
+    frame2, {op: 'request', name: res});
+  blocked.then(f => { lock_granted = true; });
+
+  // Verify that frame2 can't get it.
+  assert_true((await postToFrameAndWait(frame2, {
+    op: 'request', name: res, ifAvailable: true
+  })).failed, 'Lock request should have failed');
+  assert_false(lock_granted);
+
+  // Ask frame1 to release it.
+  await postToFrameAndWait(frame1, {op: 'release', lock_id});
+
+  await blocked;
+  // Now frame2 can get it.
+  assert_true(lock_granted);
+  frame1.parentElement.removeChild(frame1);
+  frame2.parentElement.removeChild(frame2);
+}, 'Frame and Frame - exclusive mode');
+
+promise_test(async t => {
+  assert_implements(navigator.locks);
+  const res = uniqueName(t);
+
+  const frame = await iframe('resources/iframe.html');
+
+  // Frame acquires the lock.
+  await postToFrameAndWait(frame, {op: 'request', name: res});
+
+  // This request should be blocked.
+  let lock_granted = false;
+  const blocked = navigator.locks.request(
+    res, lock => { lock_granted = true; });
+
+  // Verify that we can't get it.
+  let available = undefined;
+  await navigator.locks.request(
+    res, {ifAvailable: true}, lock => { available = lock !== null; });
+  assert_false(available);
+  assert_false(lock_granted);
+
+  // Implicitly release it by terminating the frame.
+  frame.remove();
+  await blocked;
+  // Now we've got it.
+  assert_true(lock_granted);
+
+}, 'Terminated Frame with held lock');
+
+promise_test(async t => {
+  assert_implements(navigator.locks);
+  const res = uniqueName(t);
+
+  const frame = await iframe('resources/iframe.html');
+
+  // Frame acquires the lock.
+  await postToFrameAndWait(frame, {op: 'request', name: res});
+
+  // This request should be blocked.
+  let lock_granted = false;
+  const blocked = navigator.locks.request(
+    res, lock => { lock_granted = true; });
+
+  // Verify that we can't get it.
+  let available = undefined;
+  await navigator.locks.request(
+    res, {ifAvailable: true}, lock => { available = lock !== null; });
+  assert_false(available);
+  assert_false(lock_granted);
+
+  // Implicitly release it by navigating the frame.
+  frame.src = 'about:blank';
+  await blocked;
+  // Now we've got it.
+  assert_true(lock_granted);
+
+}, 'Navigated Frame with held lock');
+
+promise_test(async t => {
+  assert_implements(navigator.locks);
+  const res = uniqueName(t);
+
+  // frame1 requests and holds res - should be granted immediately.
+  // frame2 requests res - should be blocked.
+  // frame3 requests res - should be blocked.
+  // frame2 is navigated.
+  // frame1 releases res.
+  // frame3's request should be granted.
+
+  const frame1 = await iframe('resources/iframe.html');
+  const frame2 = await iframe('resources/iframe.html');
+  const frame3 = await iframe('resources/iframe.html');
+  t.add_cleanup(() => { frame1.remove(); });
+  t.add_cleanup(() => { frame2.remove(); });
+  t.add_cleanup(() => { frame3.remove(); });
+
+  // frame1 requests and holds res - should be granted immediately.
+  const lock_id = (await postToFrameAndWait(
+    frame1, {op: 'request', name: res})).lock_id;
+
+  // frame2 requests res - should be blocked.
+  // (don't attach listeners as they will keep the frame alive)
+  frame2.contentWindow.postMessage({op: 'request', name: res}, '*');
+
+  // frame3 requests res - should be blocked.
+  let lock_granted = false;
+  const blocked = postToFrameAndWait(frame3, {op: 'request', name: res});
+  blocked.then(f => { lock_granted = true; });
+
+  // Verify that frame3 can't get it.
+  assert_true((await postToFrameAndWait(frame3, {
+    op: 'request', name: res, ifAvailable: true
+  })).failed, 'Lock request should have failed');
+  assert_false(lock_granted);
+
+  // Navigate frame2.
+  frame2.src = 'about:blank';
+
+  // frame1 releases lock
+  await postToFrameAndWait(frame1, {op: 'release', lock_id});
+
+  // frame3's request should be granted.
+  await blocked;
+  assert_true(lock_granted);
+
+}, 'Navigated Frame with pending request');
+
+promise_test(async t => {
+  assert_implements(navigator.locks);
+  const res = uniqueName(t);
+
+  // frame1 requests and holds res - should be granted immediately.
+  // frame2 requests res - should be blocked.
+  // frame3 requests res - should be blocked.
+  // frame2 is removed.
+  // frame1 drops lock.
+  // frame3's request should be granted.
+
+  const frame1 = await iframe('resources/iframe.html');
+  const frame2 = await iframe('resources/iframe.html');
+  const frame3 = await iframe('resources/iframe.html');
+  t.add_cleanup(() => { frame1.remove(); });
+  t.add_cleanup(() => { frame3.remove(); });
+
+  // frame1 requests and holds res - should be granted immediately.
+  const lock_id = (await postToFrameAndWait(
+    frame1, {op: 'request', name: res})).lock_id;
+
+  // frame2 requests res - should be blocked.
+  // (don't attach listeners as they will keep the frame alive)
+  frame2.contentWindow.postMessage({op: 'request', name: res}, '*');
+
+  // frame3 requests res - should be blocked.
+  let lock_granted = false;
+  const blocked = postToFrameAndWait(frame3, {op: 'request', name: res});
+  blocked.then(f => { lock_granted = true; });
+
+  // So frame3 can't get it
+  assert_true((await postToFrameAndWait(frame3, {
+    op: 'request', name: res, ifAvailable: true
+  })).failed, 'Lock request should have failed');
+  assert_false(lock_granted);
+
+  // Remove frame2.
+  frame2.remove();
+
+  // frame1 releases lock
+  await postToFrameAndWait(frame1, {op: 'release', lock_id});
+
+  // frame3's request should be granted.
+  await blocked;
+  assert_true(lock_granted);
+
+}, 'Removed Frame with pending request');
+
+</script>
diff --git a/test/fixtures/wpt/web-locks/held.tentative.https.any.js b/test/fixtures/wpt/web-locks/held.tentative.https.any.js
new file mode 100644
index 00000000000000..7fc4c7354054c0
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/held.tentative.https.any.js
@@ -0,0 +1,91 @@
+// META: title=Web Locks API: Lock held until callback result resolves
+// META: script=resources/helpers.js
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+
+'use strict';
+
+// For uncaught rejections.
+setup({allow_uncaught_exception: true});
+
+function snooze(t, ms) { return new Promise(r => t.step_timeout(r, ms)); }
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  const p = navigator.locks.request(res, lock => 123);
+  assert_equals(Promise.resolve(p), p, 'request() result is a Promise');
+  assert_equals(await p, 123, 'promise resolves to the returned value');
+}, 'callback\'s result is promisified if not async');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  // Resolved when the lock is granted.
+  let granted;
+  const lock_granted_promise = new Promise(r => { granted = r; });
+
+  // Lock is held until this is resolved.
+  let resolve;
+  const lock_release_promise = new Promise(r => { resolve = r; });
+
+  const order = [];
+
+  navigator.locks.request(res, lock => {
+    granted(lock);
+    return lock_release_promise;
+  });
+  await lock_granted_promise;
+
+  await Promise.all([
+    snooze(t, 50).then(() => {
+      order.push('1st lock released');
+      resolve();
+    }),
+    navigator.locks.request(res, () => {
+      order.push('2nd lock granted');
+    })
+  ]);
+
+  assert_array_equals(order, ['1st lock released', '2nd lock granted']);
+}, 'lock is held until callback\'s returned promise resolves');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  // Resolved when the lock is granted.
+  let granted;
+  const lock_granted_promise = new Promise(r => { granted = r; });
+
+  // Lock is held until this is rejected.
+  let reject;
+  const lock_release_promise = new Promise((_, r) => { reject = r; });
+
+  const order = [];
+
+  navigator.locks.request(res, lock => {
+    granted(lock);
+    return lock_release_promise;
+  });
+  await lock_granted_promise;
+
+  await Promise.all([
+    snooze(t, 50).then(() => {
+      order.push('reject');
+      reject(new Error('this uncaught rejection is expected'));
+    }),
+    navigator.locks.request(res, () => {
+      order.push('2nd lock granted');
+    })
+  ]);
+
+  assert_array_equals(order, ['reject', '2nd lock granted']);
+}, 'lock is held until callback\'s returned promise rejects');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  let callback_called = false;
+  await navigator.locks.request(res, async lock => {
+    await navigator.locks.request(res, {ifAvailable: true}, lock => {
+      callback_called = true;
+      assert_equals(lock, null, 'lock request should fail if held');
+    });
+  });
+  assert_true(callback_called, 'callback should have executed');
+}, 'held lock prevents the same client from acquiring it');
diff --git a/test/fixtures/wpt/web-locks/idlharness.tentative.https.any.js b/test/fixtures/wpt/web-locks/idlharness.tentative.https.any.js
new file mode 100644
index 00000000000000..2df7831c340572
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/idlharness.tentative.https.any.js
@@ -0,0 +1,29 @@
+// META: script=/resources/WebIDLParser.js
+// META: script=/resources/idlharness.js
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+// META: timeout=long
+
+'use strict';
+
+idl_test(
+  ['web-locks'],
+  ['html'],
+  async idl_array => {
+    idl_array.add_objects({
+      LockManager: ['navigator.locks'],
+      Lock: ['lock'],
+    });
+
+    if (self.Window) {
+      idl_array.add_objects({ Navigator: ['navigator'] });
+    } else {
+      idl_array.add_objects({ WorkerNavigator: ['navigator'] });
+    }
+
+    try {
+      await navigator.locks.request('name', l => { self.lock = l; });
+    } catch (e) {
+      // Surfaced in idlharness.js's test_object below.
+    }
+  }
+);
diff --git a/test/fixtures/wpt/web-locks/ifAvailable.tentative.https.any.js b/test/fixtures/wpt/web-locks/ifAvailable.tentative.https.any.js
new file mode 100644
index 00000000000000..63e6d568fe5135
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/ifAvailable.tentative.https.any.js
@@ -0,0 +1,163 @@
+// META: title=Web Locks API: ifAvailable option
+// META: script=resources/helpers.js
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+
+'use strict';
+
+promise_test(async t => {
+  const res = self.uniqueName(t);
+  let callback_called = false;
+  await navigator.locks.request(res, {ifAvailable: true}, async lock => {
+    callback_called = true;
+    assert_not_equals(lock, null, 'lock should be granted');
+  });
+  assert_true(callback_called, 'callback should be called');
+}, 'Lock request with ifAvailable - lock available');
+
+promise_test(async t => {
+  const res = self.uniqueName(t);
+  let callback_called = false;
+  await navigator.locks.request(res, async lock => {
+    // Request would time out if |ifAvailable| was not specified.
+    const result = await navigator.locks.request(
+      res, {ifAvailable: true}, async lock => {
+        callback_called = true;
+        assert_equals(lock, null, 'lock should not be granted');
+        return 123;
+      });
+    assert_equals(result, 123, 'result should be value returned by callback');
+  });
+  assert_true(callback_called, 'callback should be called');
+}, 'Lock request with ifAvailable - lock not available');
+
+promise_test(async t => {
+  const res = self.uniqueName(t);
+  let callback_called = false;
+  await navigator.locks.request(res, async lock => {
+    try {
+      // Request would time out if |ifAvailable| was not specified.
+      await navigator.locks.request(res, {ifAvailable: true}, async lock => {
+        callback_called = true;
+        assert_equals(lock, null, 'lock should not be granted');
+        throw 123;
+      });
+      assert_unreached('call should throw');
+    } catch (ex) {
+      assert_equals(ex, 123, 'ex should be value thrown by callback');
+    }
+  });
+  assert_true(callback_called, 'callback should be called');
+}, 'Lock request with ifAvailable - lock not available, callback throws');
+
+promise_test(async t => {
+  const res = self.uniqueName(t);
+  let callback_called = false;
+  await navigator.locks.request(res, async lock => {
+    // Request with a different name - should be grantable.
+    await navigator.locks.request('different', {ifAvailable: true}, async lock => {
+      callback_called = true;
+      assert_not_equals(lock, null, 'lock should be granted');
+    });
+  });
+  assert_true(callback_called, 'callback should be called');
+}, 'Lock request with ifAvailable - unrelated lock held');
+
+promise_test(async t => {
+  const res = self.uniqueName(t);
+  let callback_called = false;
+  await navigator.locks.request(res, {mode: 'shared'}, async lock => {
+    await navigator.locks.request(
+      res, {mode: 'shared', ifAvailable: true}, async lock => {
+        callback_called = true;
+        assert_not_equals(lock, null, 'lock should be granted');
+      });
+  });
+  assert_true(callback_called, 'callback should be called');
+}, 'Shared lock request with ifAvailable - shared lock held');
+
+promise_test(async t => {
+  const res = self.uniqueName(t);
+  let callback_called = false;
+  await navigator.locks.request(res, {mode: 'shared'}, async lock => {
+    // Request would time out if |ifAvailable| was not specified.
+    await navigator.locks.request(res, {ifAvailable: true}, async lock => {
+      callback_called = true;
+      assert_equals(lock, null, 'lock should not be granted');
+    });
+  });
+  assert_true(callback_called, 'callback should be called');
+}, 'Exclusive lock request with ifAvailable - shared lock held');
+
+promise_test(async t => {
+  const res = self.uniqueName(t);
+  let callback_called = false;
+  await navigator.locks.request(res, async lock => {
+    // Request would time out if |ifAvailable| was not specified.
+    await navigator.locks.request(
+      res, {mode: 'shared', ifAvailable: true}, async lock => {
+        callback_called = true;
+        assert_equals(lock, null, 'lock should not be granted');
+      });
+  });
+  assert_true(callback_called, 'callback should be called');
+}, 'Shared lock request with ifAvailable - exclusive lock held');
+
+promise_test(async t => {
+  const res = self.uniqueName(t);
+  let callback_called = false;
+  await navigator.locks.request(res, async lock => {
+    callback_called = true;
+    const test_error = {name: 'test'};
+    const p = navigator.locks.request(
+      res, {ifAvailable: true}, lock => {
+        assert_equals(lock, null, 'lock should not be available');
+        throw test_error;
+      });
+    assert_equals(Promise.resolve(p), p, 'request() result is a Promise');
+    await promise_rejects_exactly(t, test_error, p, 'result should reject');
+  });
+  assert_true(callback_called, 'callback should be called');
+}, 'Returned Promise rejects if callback throws synchronously');
+
+promise_test(async t => {
+  const res = self.uniqueName(t);
+  let callback_called = false;
+  await navigator.locks.request(res, async lock => {
+    callback_called = true;
+    const test_error = {name: 'test'};
+    const p = navigator.locks.request(
+      res, {ifAvailable: true}, async lock => {
+        assert_equals(lock, null, 'lock should not be available');
+        throw test_error;
+      });
+    assert_equals(Promise.resolve(p), p, 'request() result is a Promise');
+    await promise_rejects_exactly(t, test_error, p, 'result should reject');
+  });
+  assert_true(callback_called, 'callback should be called');
+}, 'Returned Promise rejects if async callback yields rejected promise');
+
+// Regression test for: https://crbug.com/840994
+promise_test(async t => {
+  const res1 = self.uniqueName(t);
+  const res2 = self.uniqueName(t);
+  let callback1_called = false;
+  await navigator.locks.request(res1, async lock => {
+    callback1_called = true;
+    let callback2_called = false;
+    await navigator.locks.request(res2, async lock => {
+      callback2_called = true;
+    });
+    assert_true(callback2_called, 'callback2 should be called');
+
+    let callback3_called = false;
+    await navigator.locks.request(res2, {ifAvailable: true}, async lock => {
+      callback3_called = true;
+      // This request would fail if the "is this grantable?" test
+      // failed, e.g. due to the release without a pending request
+      // skipping steps.
+      assert_not_equals(lock, null, 'Lock should be available');
+    });
+    assert_true(callback3_called, 'callback2 should be called');
+  });
+  assert_true(callback1_called, 'callback1 should be called');
+}, 'Locks are available once previous release is processed');
diff --git a/test/fixtures/wpt/web-locks/lock-attributes.tentative.https.any.js b/test/fixtures/wpt/web-locks/lock-attributes.tentative.https.any.js
new file mode 100644
index 00000000000000..d1c03103e0b7d7
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/lock-attributes.tentative.https.any.js
@@ -0,0 +1,18 @@
+// META: title=Web Locks API: Lock Attributes
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+
+'use strict';
+
+promise_test(async t => {
+  await navigator.locks.request('resource', lock => {
+    assert_equals(lock.name, 'resource');
+    assert_equals(lock.mode, 'exclusive');
+  });
+}, 'Lock attributes reflect requested properties (exclusive)');
+
+promise_test(async t => {
+  await navigator.locks.request('resource', {mode: 'shared'}, lock => {
+    assert_equals(lock.name, 'resource');
+    assert_equals(lock.mode, 'shared');
+  });
+}, 'Lock attributes reflect requested properties (shared)');
diff --git a/test/fixtures/wpt/web-locks/mode-exclusive.tentative.https.any.js b/test/fixtures/wpt/web-locks/mode-exclusive.tentative.https.any.js
new file mode 100644
index 00000000000000..8450e237c3555a
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/mode-exclusive.tentative.https.any.js
@@ -0,0 +1,34 @@
+// META: title=Web Locks API: Exclusive Mode
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+
+'use strict';
+
+promise_test(async t => {
+  const granted = [];
+  function log_grant(n) { return () => { granted.push(n); }; }
+
+  await Promise.all([
+    navigator.locks.request('a', log_grant(1)),
+    navigator.locks.request('a', log_grant(2)),
+    navigator.locks.request('a', log_grant(3))
+  ]);
+  assert_array_equals(granted, [1, 2, 3]);
+}, 'Lock requests are granted in order');
+
+promise_test(async t => {
+  const granted = [];
+  function log_grant(n) { return () => { granted.push(n); }; }
+
+  let inner_promise;
+  await navigator.locks.request('a', async lock => {
+    inner_promise = Promise.all([
+      // This will be blocked.
+      navigator.locks.request('a', log_grant(1)),
+      // But this should be grantable immediately.
+      navigator.locks.request('b', log_grant(2))
+    ]);
+  });
+
+  await inner_promise;
+  assert_array_equals(granted, [2, 1]);
+}, 'Requests for distinct resources can be granted');
diff --git a/test/fixtures/wpt/web-locks/mode-mixed.tentative.https.any.js b/test/fixtures/wpt/web-locks/mode-mixed.tentative.https.any.js
new file mode 100644
index 00000000000000..0dfa7e511e07d6
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/mode-mixed.tentative.https.any.js
@@ -0,0 +1,45 @@
+// META: title=Web Locks API: Mixed Modes
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+
+'use strict';
+
+promise_test(async t => {
+  let unblock;
+  const blocked = new Promise(r => { unblock = r; });
+
+  const granted = [];
+
+  // These should be granted immediately, and held until unblocked.
+  navigator.locks.request('a', {mode: 'shared'}, async lock => {
+    granted.push('a-shared-1'); await blocked; });
+  navigator.locks.request('a', {mode: 'shared'}, async lock => {
+    granted.push('a-shared-2'); await blocked; });
+  navigator.locks.request('a', {mode: 'shared'}, async lock => {
+    granted.push('a-shared-3'); await blocked; });
+
+  // This should be blocked.
+  let exclusive_lock;
+  const exclusive_request = navigator.locks.request('a', async lock => {
+    granted.push('a-exclusive');
+    exclusive_lock = lock;
+  });
+
+  // This should be granted immediately (different name).
+  await navigator.locks.request('b', {mode: 'exclusive'}, lock => {
+    granted.push('b-exclusive'); });
+
+  assert_array_equals(
+    granted, ['a-shared-1', 'a-shared-2', 'a-shared-3', 'b-exclusive']);
+
+  // Release the shared locks granted above.
+  unblock();
+
+  // Now the blocked request can be granted.
+  await exclusive_request;
+  assert_equals(exclusive_lock.mode, 'exclusive');
+
+  assert_array_equals(
+    granted,
+    ['a-shared-1', 'a-shared-2', 'a-shared-3', 'b-exclusive', 'a-exclusive']);
+
+}, 'Lock requests are granted in order');
diff --git a/test/fixtures/wpt/web-locks/mode-shared.tentative.https.any.js b/test/fixtures/wpt/web-locks/mode-shared.tentative.https.any.js
new file mode 100644
index 00000000000000..fc4a6012fab567
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/mode-shared.tentative.https.any.js
@@ -0,0 +1,38 @@
+// META: title=Web Locks API: Shared Mode
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+
+'use strict';
+
+promise_test(async t => {
+  const granted = [];
+  function log_grant(n) { return () => { granted.push(n); }; }
+
+  await Promise.all([
+    navigator.locks.request('a', {mode: 'shared'}, log_grant(1)),
+    navigator.locks.request('b', {mode: 'shared'}, log_grant(2)),
+    navigator.locks.request('c', {mode: 'shared'}, log_grant(3)),
+    navigator.locks.request('a', {mode: 'shared'}, log_grant(4)),
+    navigator.locks.request('b', {mode: 'shared'}, log_grant(5)),
+    navigator.locks.request('c', {mode: 'shared'}, log_grant(6)),
+  ]);
+
+  assert_array_equals(granted, [1, 2, 3, 4, 5, 6]);
+}, 'Lock requests are granted in order');
+
+promise_test(async t => {
+  let a_acquired = false, a_acquired_again = false;
+
+  await navigator.locks.request('a', {mode: 'shared'}, async lock => {
+    a_acquired = true;
+
+    // Since lock is held, this request would be blocked if the
+    // lock was not 'shared', causing this test to time out.
+
+    await navigator.locks.request('a', {mode: 'shared'}, lock => {
+      a_acquired_again = true;
+    });
+  });
+
+  assert_true(a_acquired, 'first lock acquired');
+  assert_true(a_acquired_again, 'second lock acquired');
+}, 'Shared locks are not exclusive');
diff --git a/test/fixtures/wpt/web-locks/non-secure-context.tentative.any.js b/test/fixtures/wpt/web-locks/non-secure-context.tentative.any.js
new file mode 100644
index 00000000000000..94553591f37249
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/non-secure-context.tentative.any.js
@@ -0,0 +1,14 @@
+// META: title=Web Locks API: API not available in non-secure context
+// META: global=window,dedicatedworker,sharedworker
+
+'use strict';
+
+test(t => {
+  assert_false(self.isSecureContext);
+  assert_false('locks' in navigator,
+               'navigator.locks is only present in secure contexts');
+  assert_false('LockManager' in self,
+               'LockManager is only present in secure contexts');
+  assert_false('Lock' in self,
+               'Lock interface is only present in secure contexts');
+}, 'API presence in non-secure contexts');
diff --git a/test/fixtures/wpt/web-locks/opaque-origin.tentative.https.html b/test/fixtures/wpt/web-locks/opaque-origin.tentative.https.html
new file mode 100644
index 00000000000000..589c2a7cdd8bbc
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/opaque-origin.tentative.https.html
@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>Web Locks API: Opaque origins</title>
+<link rel=help href="https://wicg.github.io/web-locks/">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+
+function load_iframe(src, sandbox) {
+  return new Promise(resolve => {
+    const iframe = document.createElement('iframe');
+    iframe.onload = () => { resolve(iframe); };
+    if (sandbox)
+      iframe.sandbox = sandbox;
+    iframe.srcdoc = src;
+    iframe.style.display = 'none';
+    document.documentElement.appendChild(iframe);
+  });
+}
+
+function wait_for_message(iframe) {
+  return new Promise(resolve => {
+    self.addEventListener('message', function listener(e) {
+      if (e.source === iframe.contentWindow) {
+        resolve(e.data);
+        self.removeEventListener('message', listener);
+      }
+    });
+  });
+}
+
+const script = `
+<script>
+  "use strict";
+  window.onmessage = async () => {
+    try {
+      await navigator.locks.request('name', lock => {});
+      window.parent.postMessage({result: "no exception"}, "*");
+    } catch (ex) {
+      window.parent.postMessage({result: ex.name}, "*");
+    };
+  };
+<\/script>
+`;
+
+promise_test(async t => {
+  const iframe = await load_iframe(script);
+  iframe.contentWindow.postMessage({}, '*');
+  const message = await wait_for_message(iframe);
+  assert_equals(message.result, 'no exception',
+                'navigator.locks.request() should not throw');
+}, 'navigator.locks.request() in non-sandboxed iframe should not throw');
+
+promise_test(async t => {
+  const iframe = await load_iframe(script, 'allow-scripts');
+  iframe.contentWindow.postMessage({}, '*');
+  const message = await wait_for_message(iframe);
+  assert_equals(message.result, 'SecurityError',
+                'Exception should be SecurityError');
+}, 'navigator.locks.request() in sandboxed iframe should throw SecurityError');
+</script>
diff --git a/test/fixtures/wpt/web-locks/query-empty.tentative.https.any.js b/test/fixtures/wpt/web-locks/query-empty.tentative.https.any.js
new file mode 100644
index 00000000000000..88ffdb7f810d6d
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/query-empty.tentative.https.any.js
@@ -0,0 +1,18 @@
+// META: title=Web Locks API: navigator.locks.query method - no locks held
+// META: script=resources/helpers.js
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+
+'use strict';
+
+promise_test(async t => {
+  const state = await navigator.locks.query();
+
+  assert_own_property(state, 'pending', 'State has `pending` property');
+  assert_true(Array.isArray(state.pending),
+              'State `pending` property is an array');
+  assert_array_equals(state.pending, [], 'Pending array is empty');
+
+  assert_own_property(state, 'held', 'State has `held` property');
+  assert_true(Array.isArray(state.held), 'State `held` property is an array');
+  assert_array_equals(state.held, [], 'Held array is empty');
+}, 'query() returns dictionary with empty arrays when no locks are held');
diff --git a/test/fixtures/wpt/web-locks/query-ordering.tentative.https.html b/test/fixtures/wpt/web-locks/query-ordering.tentative.https.html
new file mode 100644
index 00000000000000..172a1db87b7d25
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/query-ordering.tentative.https.html
@@ -0,0 +1,131 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>Web Locks API: navigator.locks.query ordering</title>
+<link rel=help href="https://wicg.github.io/web-locks/">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="resources/helpers.js"></script>
+<style>iframe { display: none; }</style>
+<script>
+'use strict';
+
+// Grab a lock and hold until a release function is called. Resolves
+// to a release function.
+function getLockAndHoldUntilReleased(name, options) {
+  let release;
+  const promise = new Promise(resolve => { release = resolve; });
+  return new Promise(resolve => {
+    navigator.locks.request(name, options || {}, lock => {
+      resolve(release);
+      return promise;
+    }).catch(_ => {});
+  });
+}
+
+// Returns a promise resolved by the next message event.
+function nextMessage() {
+  return new Promise(resolve => {
+    window.addEventListener('message', event => {
+      resolve(event.data);
+    }, {once: true});
+  });
+}
+
+// Tests the ordering constraints on the requested lock state returned by
+// navigator.locks.query(). Three separate iframes are instantiated to make
+// lock requests on the same resource, first in one order and then in another,
+// different order. For each set of requests, it is verified that the requests
+// appear in the result of navigator.locks.query() in the same order in which
+// they were made.
+//
+// It is necessary to use separate iframes here so that the lock requests have
+// distinguishable client_ids (otherwise it would not be possible to
+// distinguish the requests and thus impossible to verify ordering).
+promise_test(async testCase => {
+  assert_implements(navigator.locks);
+  const resourceName = uniqueName(testCase);
+
+  // Set up clients.
+  const frame1 = await iframe('resources/iframe.html');
+  const frame2 = await iframe('resources/iframe.html');
+  const frame3 = await iframe('resources/iframe.html');
+  testCase.add_cleanup(() => { frame1.remove(); });
+  testCase.add_cleanup(() => { frame2.remove(); });
+  testCase.add_cleanup(() => { frame3.remove(); });
+
+  // Collect the client ids.
+  const clientId1 =
+      (await postToFrameAndWait(frame1, {op: 'client_id',
+                                         name: resourceName})).client_id;
+  const clientId2 =
+      (await postToFrameAndWait(frame2, {op: 'client_id',
+                                         name: resourceName})).client_id;
+  const clientId3 =
+      (await postToFrameAndWait(frame3, {op: 'client_id',
+                                         name: resourceName})).client_id;
+
+  // Preemptively take the lock.
+  const firstRequestGroupReleaseFunction =
+      await getLockAndHoldUntilReleased(resourceName);
+
+  // Queue the first group of lock requests from the different clients. These
+  // will be blocked until firstRequestGroupReleaseFunction() is called.
+  let lockId1;
+  let lockId2;
+  const lockPromise1 =
+      postToFrameAndWait(frame1, {op: 'request', name: resourceName})
+          .then(val => {lockId1 = val.lock_id;});
+  const lockPromise2 =
+      postToFrameAndWait(frame2, {op: 'request', name: resourceName})
+          .then(val => {lockId2 = val.lock_id;});
+
+  // This third request will later be granted and held in order to block a
+  // second group of requests to test a different client ordering. It is not
+  // meant to be released.
+  postToFrameAndWait(frame3, {op: 'request', name: resourceName});
+
+  // Request and wait for the release of a separate lock to ensure all previous
+  // requests are processed.
+  const checkpointName = uniqueName(testCase, 'checkpoint');
+  const checkpointId = (await postToFrameAndWait(
+                                  frame3,
+                                  {op: 'request', name: checkpointName})).lock_id;
+  await postToFrameAndWait(frame3, {op: 'release', lock_id: checkpointId});
+
+  // Query the state and test the ordering of requested locks.
+  const state = await navigator.locks.query();
+  const relevant_pending_ids = state.pending
+      .filter(lock => [clientId1, clientId2, clientId3].includes(lock.clientId))
+      .map(lock => lock.clientId);
+  assert_array_equals(
+      [clientId1, clientId2, clientId3],
+      relevant_pending_ids,
+      'Querying the state should return requested locks in the order they were '
+      + 'requested.');
+
+  // Add the second group of requests from the clients in a new order.
+  postToFrameAndWait(frame3, {op: 'request', name: resourceName});
+  postToFrameAndWait(frame1, {op: 'request', name: resourceName});
+  postToFrameAndWait(frame2, {op: 'request', name: resourceName});
+
+  // Release locks such that only the newly added locks are requested. This
+  // acts like a checkpoint for the newly queued requests.
+  firstRequestGroupReleaseFunction();
+  await lockPromise1;
+  await postToFrameAndWait(frame1, {op: 'release', lock_id: lockId1});
+  await lockPromise2;
+  await postToFrameAndWait(frame2, {op: 'release', lock_id: lockId2});
+
+  // Query the state and test the new ordering.
+  const state2 = await navigator.locks.query();
+  const relevant_pending_ids2 = state2.pending
+      .filter(lock => [clientId1, clientId2, clientId3].includes(lock.clientId))
+      .map(lock => lock.clientId);
+  assert_array_equals(
+      [clientId3, clientId1, clientId2],
+      relevant_pending_ids2,
+      'Querying the state should return requested locks in the order they were '
+      + 'requested.');
+
+}, 'Requests appear in state in order made.');
+</script>
diff --git a/test/fixtures/wpt/web-locks/query.tentative.https.any.js b/test/fixtures/wpt/web-locks/query.tentative.https.any.js
new file mode 100644
index 00000000000000..14fdeca7a426c4
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/query.tentative.https.any.js
@@ -0,0 +1,227 @@
+// META: title=Web Locks API: navigator.locks.query method
+// META: script=resources/helpers.js
+
+'use strict';
+
+// Returns an array of the modes for the locks with matching name.
+function modes(list, name) {
+  return list.filter(item => item.name === name).map(item => item.mode);
+}
+// Returns an array of the clientIds for the locks with matching name.
+function clients(list, name) {
+  return list.filter(item => item.name === name).map(item => item.clientId);
+}
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  await navigator.locks.request(res, async lock1 => {
+    // Attempt to request this again - should be blocked.
+    let lock2_acquired = false;
+    navigator.locks.request(res, lock2 => { lock2_acquired = true; });
+
+    // Verify that it was blocked.
+    await navigator.locks.request(res, {ifAvailable: true}, async lock3 => {
+      assert_false(lock2_acquired, 'second request should be blocked');
+      assert_equals(lock3, null, 'third request should have failed');
+
+      const state = await navigator.locks.query();
+
+      assert_own_property(state, 'pending', 'State has `pending` property');
+      assert_true(Array.isArray(state.pending),
+                  'State `pending` property is an array');
+      const pending_info = state.pending[0];
+      assert_own_property(pending_info, 'name',
+                          'Pending info dictionary has `name` property');
+      assert_own_property(pending_info, 'mode',
+                          'Pending info dictionary has `mode` property');
+      assert_own_property(pending_info, 'clientId',
+                          'Pending info dictionary has `clientId` property');
+
+      assert_own_property(state, 'held', 'State has `held` property');
+      assert_true(Array.isArray(state.held),
+                  'State `held` property is an array');
+      const held_info = state.held[0];
+      assert_own_property(held_info, 'name',
+                          'Held info dictionary has `name` property');
+      assert_own_property(held_info, 'mode',
+                          'Held info dictionary has `mode` property');
+      assert_own_property(held_info, 'clientId',
+                          'Held info dictionary has `clientId` property');
+    });
+  });
+}, 'query() returns dictionaries with expected properties');
+
+
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  await navigator.locks.request(res, async lock1 => {
+    const state = await navigator.locks.query();
+    assert_array_equals(modes(state.held, res), ['exclusive'],
+                        'Held lock should appear once');
+  });
+
+  await navigator.locks.request(res, {mode: 'shared'}, async lock1 => {
+    const state = await navigator.locks.query();
+    assert_array_equals(modes(state.held, res), ['shared'],
+                        'Held lock should appear once');
+  });
+}, 'query() reports individual held locks');
+
+promise_test(async t => {
+  const res1 = uniqueName(t);
+  const res2 = uniqueName(t);
+
+  await navigator.locks.request(res1, async lock1 => {
+    await navigator.locks.request(res2, {mode: 'shared'}, async lock2 => {
+      const state = await navigator.locks.query();
+      assert_array_equals(modes(state.held, res1), ['exclusive'],
+                          'Held lock should appear once');
+      assert_array_equals(modes(state.held, res2), ['shared'],
+                          'Held lock should appear once');
+    });
+  });
+}, 'query() reports multiple held locks');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  await navigator.locks.request(res, async lock1 => {
+    // Attempt to request this again - should be blocked.
+    let lock2_acquired = false;
+    navigator.locks.request(res, lock2 => { lock2_acquired = true; });
+
+    // Verify that it was blocked.
+    await navigator.locks.request(res, {ifAvailable: true}, async lock3 => {
+      assert_false(lock2_acquired, 'second request should be blocked');
+      assert_equals(lock3, null, 'third request should have failed');
+
+      const state = await navigator.locks.query();
+      assert_array_equals(modes(state.pending, res), ['exclusive'],
+                          'Pending lock should appear once');
+      assert_array_equals(modes(state.held, res), ['exclusive'],
+                          'Held lock should appear once');
+    });
+  });
+}, 'query() reports pending and held locks');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  await navigator.locks.request(res, {mode: 'shared'}, async lock1 => {
+    await navigator.locks.request(res, {mode: 'shared'}, async lock2 => {
+      const state = await navigator.locks.query();
+      assert_array_equals(modes(state.held, res), ['shared', 'shared'],
+                          'Held lock should appear twice');
+    });
+  });
+}, 'query() reports held shared locks with appropriate count');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  await navigator.locks.request(res, async lock1 => {
+    let lock2_acquired = false, lock3_acquired = false;
+    navigator.locks.request(res, {mode: 'shared'},
+                            lock2 => { lock2_acquired = true; });
+    navigator.locks.request(res, {mode: 'shared'},
+                            lock3 => { lock3_acquired = true; });
+
+    await navigator.locks.request(res, {ifAvailable: true}, async lock4 => {
+      assert_equals(lock4, null, 'lock should not be available');
+      assert_false(lock2_acquired, 'second attempt should be blocked');
+      assert_false(lock3_acquired, 'third attempt should be blocked');
+
+      const state = await navigator.locks.query();
+      assert_array_equals(modes(state.held, res), ['exclusive'],
+                          'Held lock should appear once');
+
+      assert_array_equals(modes(state.pending, res), ['shared', 'shared'],
+                          'Pending lock should appear twice');
+    });
+  });
+}, 'query() reports pending shared locks with appropriate count');
+
+promise_test(async t => {
+  const res1 = uniqueName(t);
+  const res2 = uniqueName(t);
+
+  await navigator.locks.request(res1, async lock1 => {
+    await navigator.locks.request(res2, async lock2 => {
+      const state = await navigator.locks.query();
+
+      const res1_clients = clients(state.held, res1);
+      const res2_clients = clients(state.held, res2);
+
+      assert_equals(res1_clients.length, 1, 'Each lock should have one holder');
+      assert_equals(res2_clients.length, 1, 'Each lock should have one holder');
+
+      assert_array_equals(res1_clients, res2_clients,
+                          'Both locks should have same clientId');
+    });
+  });
+}, 'query() reports the same clientId for held locks from the same context');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  const worker = new Worker('resources/worker.js');
+  t.add_cleanup(() => { worker.terminate(); });
+
+  await postToWorkerAndWait(
+    worker, {op: 'request', name: res, mode: 'shared'});
+
+  await navigator.locks.request(res, {mode: 'shared'}, async lock => {
+    const state = await navigator.locks.query();
+    const res_clients = clients(state.held, res);
+    assert_equals(res_clients.length, 2, 'Clients should have same resource');
+    assert_not_equals(res_clients[0], res_clients[1],
+                      'Clients should have different ids');
+  });
+}, 'query() reports different ids for held locks from different contexts');
+
+promise_test(async t => {
+  const res1 = uniqueName(t);
+  const res2 = uniqueName(t);
+
+  const worker = new Worker('resources/worker.js');
+  t.add_cleanup(() => { worker.terminate(); });
+
+  // Acquire 1 in the worker.
+  await postToWorkerAndWait(worker, {op: 'request', name: res1})
+
+  // Acquire 2 here.
+  await new Promise(resolve => {
+    navigator.locks.request(res2, lock => {
+      resolve();
+      return new Promise(() => {}); // Never released.
+    });
+  });
+
+  // Request 2 in the worker.
+  postToWorkerAndWait(worker, {op: 'request', name: res2});
+  assert_true((await postToWorkerAndWait(worker, {
+    op: 'request', name: res2, ifAvailable: true
+  })).failed, 'Lock request should have failed');
+
+  // Request 1 here.
+  navigator.locks.request(
+    res1, t.unreached_func('Lock should not be acquired'));
+
+  // Verify that we're seeing a deadlock.
+  const state = await navigator.locks.query();
+  const res1_held_clients = clients(state.held, res1);
+  const res2_held_clients = clients(state.held, res2);
+  const res1_pending_clients = clients(state.pending, res1);
+  const res2_pending_clients = clients(state.pending, res2);
+
+  assert_equals(res1_held_clients.length, 1);
+  assert_equals(res2_held_clients.length, 1);
+  assert_equals(res1_pending_clients.length, 1);
+  assert_equals(res2_pending_clients.length, 1);
+
+  assert_equals(res1_held_clients[0], res2_pending_clients[0]);
+  assert_equals(res2_held_clients[0], res1_pending_clients[0]);
+}, 'query() can observe a deadlock');
diff --git a/test/fixtures/wpt/web-locks/resource-names.tentative.https.any.js b/test/fixtures/wpt/web-locks/resource-names.tentative.https.any.js
new file mode 100644
index 00000000000000..1031b3f7ba2e34
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/resource-names.tentative.https.any.js
@@ -0,0 +1,56 @@
+// META: title=Web Locks API: Resources DOMString edge cases
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+
+'use strict';
+
+function code_points(s) {
+  return [...s]
+    .map(c => '0x' + c.charCodeAt(0).toString(16).toUpperCase())
+    .join(' ');
+}
+
+[
+  '', // Empty strings
+  'abc\x00def', // Embedded NUL
+  '\uD800', // Unpaired low surrogage
+  '\uDC00', // Unpaired high surrogage
+  '\uDC00\uD800', // Swapped surrogate pair
+  '\uFFFF' // Non-character
+].forEach(string => {
+  promise_test(async t => {
+    await navigator.locks.request(string, lock => {
+      assert_equals(lock.name, string,
+                          'Requested name matches granted name');
+    });
+  }, 'DOMString: ' + code_points(string));
+});
+
+promise_test(async t => {
+  // '\uD800' treated as a USVString would become '\uFFFD'.
+  await navigator.locks.request('\uD800', async lock => {
+    assert_equals(lock.name, '\uD800');
+
+    // |lock| is held for the duration of this name. It
+    // Should not block acquiring |lock2| with a distinct
+    // DOMString.
+    await navigator.locks.request('\uFFFD', lock2 => {
+      assert_equals(lock2.name, '\uFFFD');
+    });
+
+    // If we did not time out, this passed.
+  });
+}, 'Resource names that are not valid UTF-16 are not mangled');
+
+promise_test(async t => {
+  for (const name of ['-', '-foo']) {
+    await promise_rejects_dom(
+      t, 'NotSupportedError',
+      navigator.locks.request(name, lock => {}),
+      'Names starting with "-" should be rejected');
+  }
+  let got_lock = false;
+  await navigator.locks.request('x-anything', lock => {
+    got_lock = true;
+  });
+  assert_true(got_lock, 'Names with embedded "-" should be accepted');
+}, 'Names cannot start with "-"');
diff --git a/test/fixtures/wpt/web-locks/resources/helpers.js b/test/fixtures/wpt/web-locks/resources/helpers.js
new file mode 100644
index 00000000000000..77300582cc52ca
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/resources/helpers.js
@@ -0,0 +1,60 @@
+// Test helpers used by multiple Web Locks API tests.
+(() => {
+
+  // Generate a unique resource identifier, using the script path and
+  // test case name. This is useful to avoid lock interference between
+  // test cases.
+  let res_num = 0;
+  self.uniqueName = (testCase, prefix) => {
+    return `xxx-${prefix}-${testCase.name}-${++res_num}`;
+  };
+
+  // Inject an iframe showing the given url into the page, and resolve
+  // the returned promise when the frame is loaded.
+  self.iframe = url => new Promise(resolve => {
+    const element = document.createElement('iframe');
+    element.addEventListener(
+      'load', () => { resolve(element); }, { once: true });
+    element.src = url;
+    document.documentElement.appendChild(element);
+  });
+
+  // Post a message to the target frame, and resolve the returned
+  // promise when a response comes back. The posted data is annotated
+  // with unique id to track the response. This assumes the use of
+  // 'iframe.html' as the frame, which implements this protocol.
+  let next_request_id = 0;
+  self.postToFrameAndWait = (frame, data) => {
+    const iframe_window = frame.contentWindow;
+    data.rqid = next_request_id++;
+    iframe_window.postMessage(data, '*');
+    return new Promise(resolve => {
+      const listener = event => {
+        if (event.source !== iframe_window || event.data.rqid !== data.rqid)
+          return;
+        self.removeEventListener('message', listener);
+        resolve(event.data);
+      };
+      self.addEventListener('message', listener);
+    });
+  };
+
+  // Post a message to the target worker, and resolve the returned
+  // promise when a response comes back. The posted data is annotated
+  // with unique id to track the response. This assumes the use of
+  // 'worker.js' as the worker, which implements this protocol.
+  self.postToWorkerAndWait = (worker, data) => {
+    return new Promise(resolve => {
+      data.rqid = next_request_id++;
+      worker.postMessage(data);
+      const listener = event => {
+        if (event.data.rqid !== data.rqid)
+          return;
+        worker.removeEventListener('message', listener);
+        resolve(event.data);
+      };
+      worker.addEventListener('message', listener);
+    });
+  };
+
+})();
diff --git a/test/fixtures/wpt/web-locks/resources/iframe.html b/test/fixtures/wpt/web-locks/resources/iframe.html
new file mode 100644
index 00000000000000..ba63c77bae50d7
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/resources/iframe.html
@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<title>Helper IFrame</title>
+<script>
+'use strict';
+
+// Map of lock_id => function that releases a lock.
+
+const held = new Map();
+let next_lock_id = 1;
+
+self.addEventListener('message', e => {
+  function respond(data) {
+    parent.postMessage(Object.assign(data, {rqid: e.data.rqid}), '*');
+  }
+
+  switch (e.data.op) {
+    case 'request':
+      navigator.locks.request(
+        e.data.name, {
+          mode: e.data.mode || 'exclusive',
+          ifAvailable: e.data.ifAvailable || false
+        }, lock => {
+          if (lock === null) {
+            respond({ack: 'request', failed: true});
+            return;
+          }
+          let lock_id = next_lock_id++;
+          let release;
+          const promise = new Promise(r => { release = r; });
+          held.set(lock_id, release);
+          respond({ack: 'request', lock_id: lock_id});
+          return promise
+        });
+      break;
+
+    case 'release':
+      held.get(e.data.lock_id)();
+      held.delete(e.data.lock_id);
+      respond({ack: 'release', lock_id: e.data.lock_id});
+      break;
+
+    case 'client_id':
+      navigator.locks.request(e.data.name, async lock => {
+        const lock_state = await navigator.locks.query();
+        const held_lock =
+            lock_state.held.filter(l => l.name === lock.name)[0];
+        respond({ack: 'client_id', client_id: held_lock.clientId});
+      });
+      break;
+  }
+});
+</script>
diff --git a/test/fixtures/wpt/web-locks/resources/service-worker.js b/test/fixtures/wpt/web-locks/resources/service-worker.js
new file mode 100644
index 00000000000000..027863e33e0457
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/resources/service-worker.js
@@ -0,0 +1,7 @@
+// Responds to '/clientId' with the request's clientId.
+self.addEventListener('fetch', e => {
+  if (new URL(e.request.url).pathname === '/clientId') {
+    e.respondWith(new Response(JSON.stringify({clientId: e.clientId})));
+    return;
+  }
+});
diff --git a/test/fixtures/wpt/web-locks/resources/sw-controlled-iframe.html b/test/fixtures/wpt/web-locks/resources/sw-controlled-iframe.html
new file mode 100644
index 00000000000000..bc5c9bdb838257
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/resources/sw-controlled-iframe.html
@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>iframe used in clientId test</title>
+<script>
+
+self.onmessage = async event => {
+  try {
+    if (event.data === 'get_sw_client_id') {
+      // Use the controlling service worker to determine
+      // this client's id according to the Service Worker.
+      const response = await fetch('/clientId');
+      const data = await response.json();
+      window.parent.postMessage(data.clientId, '*');
+      return;
+    }
+
+    if (event.data === 'get_lock_client_id') {
+      // Grab a lock, then query the lock manager for state to
+      // determine this client's id according to the lock manager.
+      await navigator.locks.request('lock-name', async lock => {
+        const lock_state = await navigator.locks.query();
+        const held_lock = lock_state.held.filter(l => l.name === lock.name)[0];
+        window.parent.postMessage(held_lock.clientId, '*');
+      });
+      return;
+    }
+
+    window.parent.postMessage(`unknown request: ${event.data}`, '*');
+  } catch (ex) {
+    // In case of test failure, don't leave parent window hanging.
+    window.parent.postMessage(`${ex.name}: ${ex.message}`, '*');
+  }
+};
+
+</script>
diff --git a/test/fixtures/wpt/web-locks/resources/worker.js b/test/fixtures/wpt/web-locks/resources/worker.js
new file mode 100644
index 00000000000000..9bb5d3d6aad185
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/resources/worker.js
@@ -0,0 +1,39 @@
+'use strict';
+
+// Map of id => function that releases a lock.
+
+const held = new Map();
+let next_lock_id = 1;
+
+self.addEventListener('message', e => {
+  function respond(data) {
+    self.postMessage(Object.assign(data, {rqid: e.data.rqid}));
+  }
+
+  switch (e.data.op) {
+  case 'request':
+    navigator.locks.request(
+      e.data.name, {
+        mode: e.data.mode || 'exclusive',
+        ifAvailable: e.data.ifAvailable || false
+      }, lock => {
+        if (lock === null) {
+          respond({ack: 'request', failed: true});
+          return;
+        }
+        let lock_id = next_lock_id++;
+        let release;
+        const promise = new Promise(r => { release = r; });
+        held.set(lock_id, release);
+        respond({ack: 'request', lock_id: lock_id});
+        return promise;
+      });
+    break;
+
+  case 'release':
+    held.get(e.data.lock_id)();
+    held.delete(e.data.lock_id);
+    respond({ack: 'release', lock_id: e.data.lock_id});
+    break;
+  }
+});
diff --git a/test/fixtures/wpt/web-locks/secure-context.tentative.https.any.js b/test/fixtures/wpt/web-locks/secure-context.tentative.https.any.js
new file mode 100644
index 00000000000000..29ae7aea475f2d
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/secure-context.tentative.https.any.js
@@ -0,0 +1,14 @@
+// META: title=Web Locks API: API requires secure context
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+
+'use strict';
+
+test(t => {
+  assert_true(self.isSecureContext);
+  assert_idl_attribute(navigator, 'locks',
+                       'navigator.locks exists in secure context');
+  assert_true('LockManager' in self,
+              'LockManager is present in secure contexts');
+  assert_true('Lock' in self,
+              'Lock interface is present in secure contexts');
+}, 'API presence in secure contexts');
diff --git a/test/fixtures/wpt/web-locks/signal.tentative.https.any.js b/test/fixtures/wpt/web-locks/signal.tentative.https.any.js
new file mode 100644
index 00000000000000..6796bfc78f8a48
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/signal.tentative.https.any.js
@@ -0,0 +1,200 @@
+// META: title=Web Locks API: AbortSignal integration
+// META: script=resources/helpers.js
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+
+'use strict';
+
+function makePromiseAndResolveFunc() {
+  let resolve;
+  const promise = new Promise(r => { resolve = r; });
+  return [promise, resolve];
+}
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  // These cases should not work:
+  for (const signal of ['string', 12.34, false, {}, Symbol(), () => {}, self]) {
+    await promise_rejects_js(
+      t, TypeError,
+      navigator.locks.request(
+        res, {signal}, t.unreached_func('callback should not run')),
+      'Bindings should throw if the signal option is a not an AbortSignal');
+  }
+}, 'The signal option must be an AbortSignal');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  const controller = new AbortController();
+  controller.abort();
+
+  await promise_rejects_dom(
+    t, 'AbortError',
+    navigator.locks.request(res, {signal: controller.signal},
+                            t.unreached_func('callback should not run')),
+    'Request should reject with AbortError');
+}, 'Passing an already aborted signal aborts');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  // Grab a lock and hold it until this subtest completes.
+  const never_settled = new Promise(resolve => t.add_cleanup(resolve));
+  navigator.locks.request(res, lock => never_settled);
+
+  const controller = new AbortController();
+
+  const promise =
+    navigator.locks.request(res, {signal: controller.signal},
+                            t.unreached_func('callback should not run'));
+
+  // Verify the request is enqueued:
+  const state = await navigator.locks.query();
+  assert_equals(state.held.filter(lock => lock.name === res).length, 1,
+                'Number of held locks');
+  assert_equals(state.pending.filter(lock => lock.name === res).length, 1,
+                'Number of pending locks');
+
+  const rejected = promise_rejects_dom(
+    t, 'AbortError', promise, 'Request should reject with AbortError');
+
+  controller.abort();
+
+  await rejected;
+
+}, 'An aborted request results in AbortError');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  // Grab a lock and hold it until this subtest completes.
+  const never_settled = new Promise(resolve => t.add_cleanup(resolve));
+  navigator.locks.request(res, lock => never_settled);
+
+  const controller = new AbortController();
+
+  const promise =
+    navigator.locks.request(res, {signal: controller.signal}, lock => {});
+
+  // Verify the request is enqueued:
+  const state = await navigator.locks.query();
+  assert_equals(state.held.filter(lock => lock.name === res).length, 1,
+                'Number of held locks');
+  assert_equals(state.pending.filter(lock => lock.name === res).length, 1,
+                'Number of pending locks');
+
+  const rejected = promise_rejects_dom(
+    t, 'AbortError', promise, 'Request should reject with AbortError');
+
+  let callback_called = false;
+  t.step_timeout(() => {
+    callback_called = true;
+    controller.abort();
+  }, 10);
+
+  await rejected;
+  assert_true(callback_called, 'timeout should have caused the abort');
+
+}, 'Abort after a timeout');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  const controller = new AbortController();
+
+  let got_lock = false;
+  await navigator.locks.request(
+    res, {signal: controller.signal}, async lock => { got_lock = true; });
+
+  assert_true(got_lock, 'Lock should be acquired if abort is not signaled.');
+
+}, 'Signal that is not aborted');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  const controller = new AbortController();
+
+  let got_lock = false;
+  const p = navigator.locks.request(
+    res, {signal: controller.signal}, lock => { got_lock = true; });
+
+  // Even though lock is grantable, this abort should be processed synchronously.
+  controller.abort();
+
+  await promise_rejects_dom(t, 'AbortError', p, 'Request should abort');
+
+  assert_false(got_lock, 'Request should be aborted if signal is synchronous');
+
+  await navigator.locks.request(res, lock => { got_lock = true; });
+  assert_true(got_lock, 'Subsequent request should not be blocked');
+
+}, 'Synchronously signaled abort');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  const controller = new AbortController();
+
+  // Make a promise that resolves when the lock is acquired.
+  const [acquired_promise, acquired_func] = makePromiseAndResolveFunc();
+
+  // Request the lock.
+  let release_func;
+  const released_promise = navigator.locks.request(
+    res, {signal: controller.signal}, lock => {
+      acquired_func();
+
+      // Hold lock until release_func is called.
+      const [waiting_promise, waiting_func] = makePromiseAndResolveFunc();
+      release_func = waiting_func;
+      return waiting_promise;
+    });
+
+  // Wait for the lock to be acquired.
+  await acquired_promise;
+
+  // Signal an abort.
+  controller.abort();
+
+  // Release the lock.
+  release_func('resolved ok');
+
+  assert_equals(await released_promise, 'resolved ok',
+                'Lock released promise should not reject');
+
+}, 'Abort signaled after lock granted');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  const controller = new AbortController();
+
+  // Make a promise that resolves when the lock is acquired.
+  const [acquired_promise, acquired_func] = makePromiseAndResolveFunc();
+
+  // Request the lock.
+  let release_func;
+  const released_promise = navigator.locks.request(
+    res, {signal: controller.signal}, lock => {
+      acquired_func();
+
+      // Hold lock until release_func is called.
+      const [waiting_promise, waiting_func] = makePromiseAndResolveFunc();
+      release_func = waiting_func;
+      return waiting_promise;
+    });
+
+  // Wait for the lock to be acquired.
+  await acquired_promise;
+
+  // Release the lock.
+  release_func('resolved ok');
+
+  // Signal an abort.
+  controller.abort();
+
+  assert_equals(await released_promise, 'resolved ok',
+                'Lock released promise should not reject');
+
+}, 'Abort signaled after lock released');
diff --git a/test/fixtures/wpt/web-locks/steal.tentative.https.any.js b/test/fixtures/wpt/web-locks/steal.tentative.https.any.js
new file mode 100644
index 00000000000000..d165b9d179fb14
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/steal.tentative.https.any.js
@@ -0,0 +1,91 @@
+// META: title=Web Locks API: steal option
+// META: script=resources/helpers.js
+// META: global=window,dedicatedworker,sharedworker,serviceworker
+
+'use strict';
+
+const never_settled = new Promise(resolve => { /* never */ });
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  let callback_called = false;
+  await navigator.locks.request(res, {steal: true}, lock => {
+    callback_called = true;
+    assert_not_equals(lock, null, 'Lock should be granted');
+  });
+  assert_true(callback_called, 'Callback should be called');
+}, 'Lock available');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+  let callback_called = false;
+
+  // Grab and hold the lock.
+  navigator.locks.request(res, lock => never_settled).catch(_ => {});
+
+  // Steal it.
+  await navigator.locks.request(res, {steal: true}, lock => {
+    callback_called = true;
+    assert_not_equals(lock, null, 'Lock should be granted');
+  });
+
+  assert_true(callback_called, 'Callback should be called');
+}, 'Lock not available');
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  // Grab and hold the lock.
+  const promise = navigator.locks.request(res, lock => never_settled);
+  const assertion = promise_rejects_dom(
+    t, 'AbortError', promise, `Initial request's promise should reject`);
+
+  // Steal it.
+  await navigator.locks.request(res, {steal: true}, lock => {});
+
+  await assertion;
+
+}, `Broken lock's release promise rejects`);
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  // Grab and hold the lock.
+  navigator.locks.request(res, lock => never_settled).catch(_ => {});
+
+  // Make a request for it.
+  let request_granted = false;
+  const promise = navigator.locks.request(res, lock => {
+    request_granted = true;
+  });
+
+  // Steal it.
+  await navigator.locks.request(res, {steal: true}, lock => {
+    assert_false(request_granted, 'Steal should override request');
+  });
+
+  await promise;
+  assert_true(request_granted, 'Request should eventually be granted');
+
+}, `Requested lock's release promise is deferred`);
+
+promise_test(async t => {
+  const res = uniqueName(t);
+
+  // Grab and hold the lock.
+  navigator.locks.request(res, lock => never_settled).catch(_ => {});
+
+  // Steal it.
+  let saw_abort = false;
+  const first_steal = navigator.locks.request(
+    res, {steal: true}, lock => never_settled).catch(error => {
+      saw_abort = true;
+    });
+
+  // Steal it again.
+  await navigator.locks.request(res, {steal: true}, lock => {});
+
+  await first_steal;
+  assert_true(saw_abort, 'First steal should have aborted');
+
+}, 'Last caller wins');
diff --git a/test/fixtures/wpt/web-locks/workers.tentative.https.html b/test/fixtures/wpt/web-locks/workers.tentative.https.html
new file mode 100644
index 00000000000000..f1f11c603a4deb
--- /dev/null
+++ b/test/fixtures/wpt/web-locks/workers.tentative.https.html
@@ -0,0 +1,122 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>Web Locks API: Workers</title>
+<link rel=help href="https://wicg.github.io/web-locks/">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="resources/helpers.js"></script>
+<script>
+'use strict';
+
+promise_test(async t => {
+  assert_implements(navigator.locks);
+  const worker = new Worker('resources/worker.js');
+  t.add_cleanup(() => { worker.terminate(); });
+
+  const res = 'shared resource 1';
+
+  const lock_id = (await postToWorkerAndWait(
+    worker, {op: 'request', name: res, mode: 'shared'})).lock_id;
+
+  await navigator.locks.request(res, {mode: 'shared'}, async lock => {
+    await postToWorkerAndWait(worker, {op: 'release', lock_id});
+  });
+
+}, 'Window and Worker - shared mode');
+
+promise_test(async t => {
+  assert_implements(navigator.locks);
+  const worker = new Worker('resources/worker.js');
+  t.add_cleanup(() => { worker.terminate(); });
+
+  const res = 'exclusive resource 1';
+
+  // worker acquires the lock.
+  const lock_id = (await postToWorkerAndWait(
+    worker, {op: 'request', name: res})).lock_id;
+
+  // This request should be blocked.
+  let lock_granted = false;
+  const blocked = navigator.locks.request(
+    res, lock => { lock_granted = true; });
+
+  // Verify we can't get it.
+  let available = undefined;
+  await navigator.locks.request(
+    res, {ifAvailable: true}, lock => { available = lock !== null; });
+  assert_false(available);
+  assert_false(lock_granted);
+
+  // Ask the worker to release it.
+  await postToWorkerAndWait(worker, {op: 'release', lock_id});
+
+  // Now we've got it.
+  const lock2 = await blocked;
+  assert_true(lock_granted);
+
+}, 'Window and Worker - exclusive mode');
+
+promise_test(async t => {
+  assert_implements(navigator.locks);
+  const worker1 = new Worker('resources/worker.js');
+  const worker2 = new Worker('resources/worker.js');
+  t.add_cleanup(() => { worker1.terminate(); worker2.terminate(); });
+
+  const res = 'exclusive resource 2';
+
+  // worker1 acquires the lock.
+  const lock_id = (await postToWorkerAndWait(
+    worker1, {op: 'request', name: res})).lock_id;
+
+  // This request should be blocked.
+  let lock_granted = false;
+  const blocked = postToWorkerAndWait(
+    worker2, {op: 'request', name: res});
+  blocked.then(f => { lock_granted = true; });
+
+  // Verify worker2 can't get it.
+  assert_true((await postToWorkerAndWait(worker2, {
+    op: 'request', name: res, ifAvailable: true
+  })).failed, 'Lock request should have failed');
+  assert_false(lock_granted);
+
+  // Ask worker1 to release it.
+  await postToWorkerAndWait(worker1, {op: 'release', lock_id});
+
+  // Now worker2 can get it.
+  const lock = await blocked;
+  assert_true(lock_granted);
+
+}, 'Worker and Worker - exclusive mode');
+
+promise_test(async t => {
+  assert_implements(navigator.locks);
+  const worker = new Worker('resources/worker.js');
+
+  const res = 'exclusive resource 3';
+
+  // Worker acquires the lock.
+  await postToWorkerAndWait(worker, {op: 'request', name: res});
+
+  // This request should be blocked.
+  let lock_granted = false;
+  const blocked = navigator.locks.request(
+    res, lock => { lock_granted = true; });
+
+  // Verify we can't get it.
+  let available = undefined;
+  await navigator.locks.request(
+    res, {ifAvailable: true}, lock => { available = lock !== null; });
+  assert_false(available);
+  assert_false(lock_granted);
+
+  // Implicitly release it by terminating the worker.
+  worker.terminate();
+
+  // Now we've got it.
+  const lock = await blocked;
+  assert_true(lock_granted);
+
+}, 'Terminated Worker - exclusive mode');
+
+</script>
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
index 0887b8a48362f6..6fffea7eb38d61 100644
--- a/test/parallel/test-bootstrap-modules.js
+++ b/test/parallel/test-bootstrap-modules.js
@@ -130,6 +130,7 @@ if (!common.isMainThread) {
     'NativeModule internal/streams/state',
     'NativeModule internal/worker',
     'NativeModule internal/worker/io',
+    'NativeModule internal/worker/locks',
     'NativeModule stream',
     'NativeModule worker_threads',
   ].forEach(expectedModules.add.bind(expectedModules));
diff --git a/test/parallel/test-worker-locks.js b/test/parallel/test-worker-locks.js
new file mode 100644
index 00000000000000..fdcf99aa8316ac
--- /dev/null
+++ b/test/parallel/test-worker-locks.js
@@ -0,0 +1,199 @@
+'use strict';
+const { mustCall, mustNotCall } = require('../common');
+const assert = require('assert');
+const { locks, Worker } = require('worker_threads');
+const { EventEmitter, once, getEventListeners } = require('events');
+
+const { setImmediate: tick } = require('timers/promises');
+
+(async () => {
+  {
+    // Acquiring a lock and releasing it works.
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+    await locks.request('lock-name', mustCall(async (lock) => {
+      const snapshot = await locks.query();
+      assert.strictEqual(snapshot.pending.length, 0);
+      assert.strictEqual(snapshot.held.length, 1);
+      assert.strictEqual(snapshot.held[0].name, 'lock-name');
+      assert.strictEqual(snapshot.held[0].mode, 'exclusive');
+      assert.strictEqual(lock.name, 'lock-name');
+      assert.strictEqual(lock.mode, 'exclusive');
+    }));
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+  }
+
+  {
+    // Acquiring a lock will make other lock requests for the same name wait.
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+    let firstRequestDone = false;
+    let secondRequest;
+    let secondRequestDone = false;
+    await locks.request('lock-name', mustCall(async (lock) => {
+      secondRequest = locks.request('lock-name', mustCall(async (lock) => {
+        assert(firstRequestDone);
+        secondRequestDone = true;
+        const snapshot = await locks.query();
+        assert.strictEqual(snapshot.pending.length, 0);
+        assert.strictEqual(snapshot.held.length, 1);
+      }));
+      const snapshot = await locks.query();
+      assert.strictEqual(snapshot.pending.length, 1);
+      assert.strictEqual(snapshot.held.length, 1);
+      assert.strictEqual(secondRequestDone, false);
+      await tick();
+      assert.strictEqual(secondRequestDone, false);
+      firstRequestDone = true;
+    }));
+    await secondRequest;
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+  }
+
+  {
+    // Acquiring a shared lock will not make other shared lock requests for the
+    // same name wait.
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+    await locks.request('lock-name', {
+      mode: 'shared'
+    }, mustCall(async (lock) => {
+      await locks.request('lock-name', {
+        mode: 'shared'
+      }, mustCall(async (lock) => {
+        const snapshot = await locks.query();
+        assert.strictEqual(snapshot.pending.length, 0);
+        assert.strictEqual(snapshot.held.length, 2);
+      }));
+    }));
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+  }
+
+  {
+    // Acquiring a shared lock will make exclusive lock requests for the same
+    // name wait.
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+    let firstRequestDone = false;
+    let secondRequest;
+    let secondRequestDone = false;
+    await locks.request('lock-name', {
+      mode: 'shared'
+    }, mustCall(async (lock) => {
+      secondRequest = locks.request('lock-name', mustCall(async (lock) => {
+        assert(firstRequestDone);
+        secondRequestDone = true;
+        const snapshot = await locks.query();
+        assert.strictEqual(snapshot.pending.length, 0);
+        assert.strictEqual(snapshot.held.length, 1);
+      }));
+      const snapshot = await locks.query();
+      assert.strictEqual(snapshot.pending.length, 1);
+      assert.strictEqual(snapshot.held.length, 1);
+      assert.strictEqual(secondRequestDone, false);
+      await tick();
+      assert.strictEqual(secondRequestDone, false);
+      firstRequestDone = true;
+    }));
+    await secondRequest;
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+  }
+
+  {
+    // Lock requests can be aborted.
+    const ee = new EventEmitter();
+    const locked = locks.request('lock-name', mustCall(async (lock) => {
+      await once(ee, 'stop');
+    }));
+    const controller = new AbortController();
+    const cantlock = locks.request('lock-name', {
+      signal: controller.signal
+    }, mustNotCall());
+    await tick();
+    assert.strictEqual((await locks.query()).held.length, 1);
+    assert.strictEqual((await locks.query()).pending.length, 1);
+    controller.abort();
+    await assert.rejects(cantlock, { name: 'AbortError' });
+    ee.emit('stop');
+    await locked;
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+  }
+
+  {
+    // Aborting already-acquired locks has no effect.
+    const controller = new AbortController();
+    await locks.request('lock-name', {
+      signal: controller.signal
+    }, mustCall(async (lock) => {
+      controller.abort();
+    }));
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+    assert.deepStrictEqual(getEventListeners(controller.signal, 'abort'), []);
+  }
+
+  {
+    // ifAvailable will make a second request 'fail'.
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+    await locks.request('lock-name', mustCall(async (lock) => {
+      assert.strictEqual(lock.name, 'lock-name');
+      await locks.request('lock-name', {
+        ifAvailable: true
+      }, mustCall(async (lock) => {
+        assert.strictEqual(lock, null);
+      }));
+    }));
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+  }
+
+  {
+    // Locks are cross-thread.
+    const workerData = new Uint8Array(new SharedArrayBuffer(1));
+    let w;
+    await locks.request('lock-name', mustCall(async (lock) => {
+      w = new Worker(`
+        const { locks, workerData, parentPort } = require('worker_threads');
+        const assert = require('assert');
+        locks.request('lock-name', async (lock) => {
+          assert.strictEqual(lock.name, 'lock-name');
+          Atomics.add(workerData, 0, 1);
+        }).then(() => Atomics.add(workerData, 0, 1));
+        Atomics.add(workerData, 0, 1);
+        parentPort.postMessage('up');
+      `, { eval: true, workerData });
+      await once(w, 'message');
+      assert.strictEqual(workerData[0], 1);
+      await tick();
+      assert.strictEqual(workerData[0], 1);
+    }));
+    await once(w, 'exit');
+    assert.strictEqual(workerData[0], 3);
+  }
+
+  {
+    // Locks held at thread exit do not end up blocking new acquire calls.
+    const w = new Worker(`
+      const { locks, workerData, parentPort } = require('worker_threads');
+      locks.request('lock-name', async() => process.exit(42));
+    `, { eval: true });
+    const [ code ] = await once(w, 'exit');
+    assert.strictEqual(code, 42);
+    await locks.request('lock-name', mustCall(async (lock) => {
+      assert.strictEqual(lock.name, 'lock-name');
+    }));
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+  }
+
+  {
+    // Locks can be stolen.
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+    let inner;
+    const outer = locks.request('lock-name', mustCall(async (lock) => {
+      inner = locks.request('lock-name', {
+        steal: true
+      }, mustCall(async (lock) => {
+        const snapshot = await locks.query();
+        assert.strictEqual(snapshot.pending.length, 0);
+        assert.strictEqual(snapshot.held.length, 1);
+      }));
+    }));
+    await assert.rejects(outer, { name: 'AbortError' });
+    await inner;
+    assert.deepStrictEqual(await locks.query(), { held: [], pending: [] });
+  }
+})().then(mustCall());
diff --git a/test/wpt/status/web-locks.json b/test/wpt/status/web-locks.json
new file mode 100644
index 00000000000000..df775b1d5435fa
--- /dev/null
+++ b/test/wpt/status/web-locks.json
@@ -0,0 +1,26 @@
+{
+  "acquire.tentative.https.any.js": {
+    "skip": "Unexpected global object"
+  },
+  "held.tentative.https.any.js": {
+    "skip": "Error: this uncaught rejection is expected"
+  },
+  "idlharness.tentative.https.any.js": {
+    "skip": "Unexpected global object"
+  },
+  "non-secure-context.tentative.any.js": {
+    "skip": "navigator.locks is only present in secure contexts"
+  },
+  "query.tentative.https.any.js": {
+    "skip": "Uses Web Workers"
+  },
+  "resource-names.tentative.https.any.js": {
+    "skip": "Unexpected global object"
+  },
+  "signal.tentative.https.any.js": {
+    "skip": "Various errors. Process hangs."
+  },
+  "steal.tentative.https.any.js": {
+    "skip": "AbortError: The operation was aborted"
+  }
+}
diff --git a/test/wpt/test-web-locks.js b/test/wpt/test-web-locks.js
new file mode 100644
index 00000000000000..5e706c0449b072
--- /dev/null
+++ b/test/wpt/test-web-locks.js
@@ -0,0 +1,21 @@
+'use strict';
+
+require('../common');
+const { WPTRunner } = require('../common/wpt');
+
+const runner = new WPTRunner('web-locks');
+
+// Needed to access to Lock and LockManager.
+runner.setFlags(['--expose-internals']);
+
+runner.setInitScript(`
+  const { Lock, LockManager } = require('internal/worker/locks');
+  global.isSecureContext = true;
+  global.Lock = Lock;
+  global.LockManager = LockManager;
+  global.navigator = Object.create({
+    locks: require('worker_threads').locks,
+  });
+`);
+
+runner.runJsTests();
diff --git a/tools/doc/type-parser.js b/tools/doc/type-parser.js
index 72a2ec419940de..f9ef7acd49bb77 100644
--- a/tools/doc/type-parser.js
+++ b/tools/doc/type-parser.js
@@ -216,6 +216,8 @@ const customTypesMap = {
   'vm.SourceTextModule': 'vm.html#vm_class_vm_sourcetextmodule',
 
   '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',
 };