Switch to refcounted locks, add shared locks for writable streams

This CL changes the scope of the WriteLockManager, making it responsible
for the creation of locks, instead of owning access handle and file
writer receivers. This simplifies error handling and avoids unnecessary
IO operations when taking a lock is not possible. This new locks are
refcounted, when there are no more references to them, their
destructor releases the lock on the URL.

Creating access handles requires an exclusive lock, which prevent any
other lock from being taken on the URL. Creating writable streams
requires a shared lock, which prevent the taking of exclusive locks, but
allow the taking of shared ones.

Bug: 1218431
Change-Id: I9c21b901ed0f5f331682c8a6b75db5e28674e5a3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3100189
Commit-Queue: Emanuel Krivoy <[email protected]>
Reviewed-by: Austin Sullivan <[email protected]>
Cr-Commit-Position: refs/heads/main@{#918766}

Author: fivedots

file-system-access/sandboxed_FileSystemFileHandle-sync-access-handle-lock.https.tentative.worker.js

@@ -0,0 +1,88 @@
+importScripts('/resources/testharness.js');
+importScripts('resources/sandboxed-fs-test-helpers.js');
+
+'use strict';
+
+directory_test(async (t, root_dir) =>  {
+  const fileHandle = await root_dir.getFileHandle('OPFS.test', {create: true});
+
+  const syncHandle1 = await fileHandle.createSyncAccessHandle();
+  await promise_rejects_dom(
+      t, 'InvalidStateError', fileHandle.createSyncAccessHandle());
+
+  await syncHandle1.close();
+  const syncHandle2 = await fileHandle.createSyncAccessHandle();
+  await syncHandle2.close();
+}, 'There can only be one open access handle at any given time');
+
+directory_test(async (t, root_dir) =>  {
+  const fooFileHandle = await root_dir.getFileHandle('foo.test', {create: true});
+  const barFileHandle = await root_dir.getFileHandle('bar.test', {create: true});
+
+  const fooSyncHandle = await fooFileHandle.createSyncAccessHandle();
+  t.add_cleanup(() => fooSyncHandle.close());
+
+  const barSyncHandle1 = await barFileHandle.createSyncAccessHandle();
+  await promise_rejects_dom(
+      t, 'InvalidStateError', barFileHandle.createSyncAccessHandle());
+
+  await barSyncHandle1.close();
+  const barSyncHandle2 = await barFileHandle.createSyncAccessHandle();
+  await barSyncHandle2.close();
+}, 'An access handle from one file does not interfere with the creation of an' +
+     ' access handle on another file');
+
+directory_test(async (t, root_dir) =>  {
+  const fooFileHandle = await root_dir.getFileHandle('foo.test', {create: true});
+  const barFileHandle = await root_dir.getFileHandle('bar.test', {create: true});
+
+  const fooWritable = await fooFileHandle.createWritable();
+  t.add_cleanup(() => fooWritable.close());
+
+  const barSyncHandle = await barFileHandle.createSyncAccessHandle();
+  t.add_cleanup(() => barSyncHandle.close());
+}, 'A writable stream from one file does not interfere with the creation of an' +
+     ' access handle on another file');
+
+directory_test(async (t, root_dir) =>  {
+  const fooFileHandle = await root_dir.getFileHandle('foo.test', {create: true});
+  const barFileHandle = await root_dir.getFileHandle('bar.test', {create: true});
+
+  const fooSyncHandle = await fooFileHandle.createSyncAccessHandle();
+  t.add_cleanup(() => fooSyncHandle.close());
+
+  const barWritable = await barFileHandle.createWritable();
+  t.add_cleanup(() => barWritable.close());
+}, 'An access handle from one file does not interfere with the creation of a' +
+     ' writable stream on another file');
+
+directory_test(async (t, root_dir) =>  {
+  const fileHandle = await root_dir.getFileHandle('OPFS.test', {create: true});
+
+  const syncHandle = await fileHandle.createSyncAccessHandle();
+  await promise_rejects_dom(
+      t, 'InvalidStateError', fileHandle.createWritable());
+
+  await syncHandle.close();
+  const writable = await fileHandle.createWritable();
+  await writable.close();
+}, 'Writable streams cannot be created if there is an open access handle');
+
+directory_test(async (t, root_dir) =>  {
+  const fileHandle = await root_dir.getFileHandle('OPFS.test', {create: true});
+
+  const writable1 = await fileHandle.createWritable();
+  const writable2 = await fileHandle.createWritable();
+  await promise_rejects_dom(
+      t, 'InvalidStateError', fileHandle.createSyncAccessHandle());
+
+  await writable1.close();
+  await promise_rejects_dom(
+      t, 'InvalidStateError', fileHandle.createSyncAccessHandle());
+
+  await writable2.close();
+  const syncHandle = await fileHandle.createSyncAccessHandle();
+  await syncHandle.close();
+}, 'Access handles cannot be created if there are open Writable streams');
+
+done();