Skip to content

Commit

Permalink
Bug 1935267 [wpt PR 49533] - [shared storage] Implement batchUpdate()…
Browse files Browse the repository at this point in the history
… for Window and SharedStorageWorklet context, a=testonly

Automatic update from web-platform-tests
[shared storage] Implement batchUpdate() for Window and SharedStorageWorklet 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}

--

wpt-commits: d54d933593b96018172d332ece95dcec9839a059
wpt-pr: 49533
  • Loading branch information
yaoxiachromium authored and moz-wptsync-bot committed Dec 10, 2024
1 parent 865c646 commit df1d7ed
Show file tree
Hide file tree
Showing 4 changed files with 191 additions and 0 deletions.
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand All @@ -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);
Original file line number Diff line number Diff line change
Expand Up @@ -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>
Original file line number Diff line number Diff line change
@@ -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>
Original file line number Diff line number Diff line change
@@ -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>

0 comments on commit df1d7ed

Please sign in to comment.