[shared storage] Implement batchUpdate() for Window and SharedStorage…

…Worklet context This allows developers to perform multiple Shared Storage operations atomically within a single lock, as part of the Web Lock integration proposal: - WICG/shared-storage#199 - WICG/shared-storage#205 How: - Add `batchUpdate(methods, options)` to the `SharedStorage` interface. - Hooks up the `batchUpdate()` method to the `SharedStorageLockManager::SharedStorageBatchUpdate()` API in the browser process. Bug: 373899210 Fuchsia-Binary-Size: Size increase is unavoidable. Change-Id: I0e1b355e3b3d28518396ae4333afe21e6d02e858 Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6069087 Reviewed-by: Ayu Ishii <ayui@chromium.org> Commit-Queue: Yao Xiao <yaoxia@chromium.org> Cr-Commit-Position: refs/heads/main@{#1391933}
web-platform-tests · Dec 4, 2024 · b576b4d · b576b4d
1 parent 79ce401
commit b576b4d
Show file tree

Hide file tree

Showing 4 changed files with 191 additions and 0 deletions.
diff --git a/shared-storage/resources/simple-module.js b/shared-storage/resources/simple-module.js
@@ -155,6 +155,20 @@ class AppendWithLockOptionOperation {
   }
 }
 
+class BatchUpdateWithTwoAppendMethodsWithBatchLockOptionOperation {
+  async run(urls, data) {
+    if (data && data.hasOwnProperty('key') && data.hasOwnProperty('lock_name')
+        && data.hasOwnProperty('append_letter')) {
+      sharedStorage.batchUpdate([
+          new SharedStorageAppendMethod(data['key'], data['append_letter']),
+          new SharedStorageAppendMethod(data['key'], data['append_letter'])
+        ], {withLock: data['lock_name']});
+      return 1;
+    }
+    return -1;
+  }
+}
+
 register('test-url-selection-operation', TestURLSelectionOperation);
 register('test-url-selection-operation-2', TestURLSelectionOperationTwo);
 register('test-slow-url-selection-operation', TestSlowURLSelectionOperation);
@@ -166,3 +180,4 @@ register('verify-interest-groups', VerifyInterestGroups);
 register('get-wait-increment-within-lock', GetWaitIncrementWithinLockOperation);
 register('get-wait-set-within-lock', GetWaitSetWithinLockOperation);
 register('append-with-lock-option', AppendWithLockOptionOperation);
+register('batch-update-with-two-append-methods-with-batch-lock-option', BatchUpdateWithTwoAppendMethodsWithBatchLockOptionOperation);
diff --git a/shared-storage/setters.tentative.https.sub.html b/shared-storage/setters.tentative.https.sub.html
@@ -104,5 +104,22 @@
   let a = new SharedStorageClearMethod();
 }, 'new SharedStorageClearMethod with no arguments');
 
+promise_test(() => {
+  return sharedStorage.batchUpdate([
+    new SharedStorageSetMethod("key0", "value0", {withLock: "lock1"}),
+    new SharedStorageAppendMethod("key1", "value1"),
+    new SharedStorageDeleteMethod("key2"),
+    new SharedStorageClearMethod({withLock: "lock2"})
+  ], {withLock: "lock3"});
+}, 'sharedStorage.batchUpdate');
+
+promise_test(async t => {
+  return promise_rejects_js(t, TypeError, sharedStorage.batchUpdate());
+}, 'sharedStorage.batchUpdate without \'methods\' argument');
+
+promise_test(async t => {
+  return promise_rejects_js(t, TypeError, sharedStorage.batchUpdate(["123"]));
+}, 'sharedStorage.batchUpdate with invalid \'methods\' argument');
+
 </script>
 </body>
diff --git a/shared-storage/web-locks-window-batch-update.tentative.https.sub.html b/shared-storage/web-locks-window-batch-update.tentative.https.sub.html
@@ -0,0 +1,74 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/utils.js"></script>
+<script src="/shared-storage/resources/util.js"></script>
+<script src="/fenced-frame/resources/utils.js"></script>
+
+<body>
+<script>
+'use strict';
+
+promise_test(async t => {
+  let worklet = await sharedStorage.createWorklet('resources/simple-module.js');
+
+  const ancestor_key = token();
+  let url0 = generateURL("/shared-storage/resources/frame0.html",
+                         [ancestor_key]);
+  let url1 = generateURL("/shared-storage/resources/frame1.html",
+                         [ancestor_key]);
+
+  // Invoke `selectURL()` to perform the following steps:
+  // 1. Acquires the lock.
+  // 2. Reads the current value at the given key.
+  // 3. Waits for 500ms.
+  // 4. Sets the shared storage value to the read value appended with the given letter.
+  // 5. Releases the lock.
+  //
+  // After 100ms, invoke `sharedStorage.batchUpdate()` that:
+  // - Acquires the same named lock.
+  // - Executes two `append` methods, each appending the same letter.
+  //
+  // Expected behavior: After both of them finish, the value at the given key
+  // should contain the letter repeated three times.
+  //
+  // This demonstrates that:
+  // 1. The `withLock` option is effective, preventing the `batchUpdate()`
+  //    method interfering with the "get and set" operation. If the lock were not
+  //    used, the final value would likely be a single letter.
+  // 2. `batchUpdate()` correctly executes all `append` methods within the
+  //    batch.
+  //
+  // Note: This test remains valid even if the `batchUpdate()` call happens
+  // outside the critical section protected by the lock within the worklet. The
+  // test effectively demonstrates mutual exclusion as long as there's a
+  // reasonable chance for `batchUpdate()` to occur while the worklet is still
+  // running.
+  let select_url_result = await worklet.selectURL(
+      "get-wait-set-within-lock",
+      [{url: url0}, {url: url1}],
+      {data: {'key': 'key',
+              'lock_name': 'lock1',
+              'append_letter': 'a'},
+      resolveToConfig: true});
+
+  // Busy wait for 100ms.
+  const startWaitTime = Date.now();
+  while (Date.now() - startWaitTime < 100) {}
+
+  sharedStorage.batchUpdate([
+      new SharedStorageAppendMethod('key', 'a'),
+      new SharedStorageAppendMethod('key', 'a')
+    ], {withLock: 'lock1'});
+
+  attachFencedFrame(select_url_result, 'opaque-ads');
+  const result = await nextValueFromServer(ancestor_key);
+  assert_equals(result, "frame1_loaded");
+
+  await verifyKeyValueForOrigin('key', 'aaa', location.origin);
+
+  await deleteKeyForOrigin('key', location.origin);
+}, 'Test for batchUpdate() with a batch lock in a Window context');
+
+</script>
+</body>
diff --git a/shared-storage/web-locks-worklet-batch-update.tentative.https.sub.html b/shared-storage/web-locks-worklet-batch-update.tentative.https.sub.html
@@ -0,0 +1,85 @@
+<!doctype html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/utils.js"></script>
+<script src="/shared-storage/resources/util.js"></script>
+<script src="/fenced-frame/resources/utils.js"></script>
+
+<body>
+<script>
+'use strict';
+
+promise_test(async t => {
+  let worklet1 = await sharedStorage.createWorklet('resources/simple-module.js');
+  let worklet2 = await sharedStorage.createWorklet('resources/simple-module.js');
+
+  const ancestor_key1 = token();
+  let url1_0 = generateURL("/shared-storage/resources/frame0.html",
+                         [ancestor_key1]);
+  let url1_1 = generateURL("/shared-storage/resources/frame1.html",
+                         [ancestor_key1]);
+
+  const ancestor_key2 = token();
+  let url2_0 = generateURL("/shared-storage/resources/frame0.html",
+                         [ancestor_key2]);
+  let url2_1 = generateURL("/shared-storage/resources/frame1.html",
+                         [ancestor_key2]);
+
+  // Invoke `selectURL()` to perform the following steps:
+  // 1. Acquires the lock.
+  // 2. Reads the current value at the given key.
+  // 3. Waits for 500ms.
+  // 4. Sets the shared storage value to the read value appended with the given letter.
+  // 5. Releases the lock.
+  //
+  // In parallel, invoke another `selectURL()`, which subsequently invokes
+  // `sharedStorage.batchUpdate()` that:
+  // - Acquires the same named lock.
+  // - Executes two `append` methods, each appending the same letter.
+  //
+  // Expected behavior: After both of them finish, the value at the given key
+  // should contain the letter repeated three times.
+  //
+  // This demonstrates that:
+  // 1. The `withLock` option is effective, preventing the `batchUpdate()`
+  //    method interfering with the "get and set" operation. If the lock were not
+  //    used, the final value would likely be a single letter.
+  // 2. `batchUpdate()` correctly executes all `append` methods within the
+  //    batch.
+  //
+  // Note: This test remains valid even if the `batchUpdate()` call happens
+  // outside the critical section protected by the lock within the worklet. The
+  // test effectively demonstrates mutual exclusion as long as there's a
+  // reasonable chance for `batchUpdate()` to occur while the worklet is still
+  // running.
+  let select_url_result1 = await worklet1.selectURL(
+      "get-wait-set-within-lock",
+      [{url: url1_0}, {url: url1_1}],
+      {data: {'key': 'key',
+              'lock_name': 'lock1',
+              'append_letter': 'a'},
+      resolveToConfig: true});
+
+  let select_url_result2 = await worklet2.selectURL(
+      "batch-update-with-two-append-methods-with-batch-lock-option",
+      [{url: url2_0}, {url: url2_1}],
+      {data: {'key': 'key',
+              'lock_name': 'lock1',
+              'append_letter': 'a'},
+      resolveToConfig: true});
+
+  attachFencedFrame(select_url_result1, 'opaque-ads');
+  const result1 = await nextValueFromServer(ancestor_key1);
+  assert_equals(result1, "frame1_loaded");
+
+  attachFencedFrame(select_url_result2, 'opaque-ads');
+  const result2 = await nextValueFromServer(ancestor_key2);
+  assert_equals(result2, "frame1_loaded");
+
+  await verifyKeyValueForOrigin('key', 'aaa', location.origin);
+
+  await deleteKeyForOrigin('key', location.origin);
+}, 'Test for batchUpdate() with a batch lock in a SharedStorageWorklet context');
+
+</script>
+</body>