From 4e08670585697b861e936d5046eaf6430a72f31b Mon Sep 17 00:00:00 2001
From: Hiroshige Hayashizaki <hiroshige@chromium.org>
Date: Thu, 26 May 2022 19:54:03 -0700
Subject: [PATCH] [WPT] BFCache: storage events

Expectation:
When localStorage is modified when a page is in BFCache,
storage events should NOT be fired for the page
even after the page becomes active.

Results:
Firefox/Safari: Pass.
Chromium: Fail (events are fired, https://crbug.com/1328939).

Bug: 1328939, 1107415, https://github.com/whatwg/storage/issues/119
Change-Id: I53c92b2d5f8f4791a43c2c702a441029fdbc7101
---
 .../back-forward-cache/storage-events.html    | 98 +++++++++++++++++++
 1 file changed, 98 insertions(+)
 create mode 100644 html/browsers/browsing-the-web/back-forward-cache/storage-events.html
diff --git a/html/browsers/browsing-the-web/back-forward-cache/storage-events.html b/html/browsers/browsing-the-web/back-forward-cache/storage-events.html
new file mode 100644
index 00000000000000..f3561e6da3ab8f
--- /dev/null
+++ b/html/browsers/browsing-the-web/back-forward-cache/storage-events.html
@@ -0,0 +1,98 @@
+<!DOCTYPE HTML>
+<meta name="timeout" content="long">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/utils.js"></script>
+<script src="/common/dispatcher/dispatcher.js"></script>
+<script src="resources/helper.sub.js"></script>
+<script>
+// When localStorage (`key1`) is modified when a page (`pageA`) is in BFCache,
+// storage events should not be fired for the page after becoming active.
+// https://github.com/whatwg/storage/issues/119#issuecomment-1115844532
+promise_test(async t => {
+  const pageA = new RemoteContext(token());
+  const pageB = new RemoteContext(token());
+  const pageC = new RemoteContext(token());
+
+  const urlA = executorPath + pageA.context_id + '&events=pagehide,pageshow,load';
+  const urlB = originCrossSite + executorPath + pageB.context_id;
+  const urlC = executorPath + pageC.context_id + '&events=pagehide,pageshow,load';
+
+  // localStorage keys set while pageA is active/inactive.
+  const key1 = token();
+  const key2 = token();
+
+  const startRecordingStorageEvent = (key1, key2) => {
+    window.key1EventFired = new Promise(resolve => {
+      window.addEventListener('storage', e => {
+        if (e.key === key1) {
+          recordEvent('storage1');
+          resolve();
+        }
+      });
+    });
+    window.key2EventFired = new Promise(resolve => {
+      window.addEventListener('storage', e => {
+        if (e.key === key2) {
+          recordEvent('storage2');
+          resolve();
+        }
+      });
+    });
+  };
+
+  window.open(urlA, '_blank', 'noopener');
+  await pageA.execute_script(waitForPageShow);
+  await pageA.execute_script(startRecordingStorageEvent, [key1, key2]);
+
+  // Window C is kept open without navigation, to confirm that storage events are
+  // fired as expected in non-BFCache-related scenario and not blocked due to
+  // non-BFCache-related reasons.
+  window.open(urlC, '_blank');
+  await pageC.execute_script(waitForPageShow);
+  await pageC.execute_script(startRecordingStorageEvent, [key1, key2]);
+
+  // Navigate A to B.
+  await pageA.execute_script((url) => {
+    prepareNavigation(() => {
+      location.href = url;
+    });
+  }, [urlB]);
+  await pageB.execute_script(waitForPageShow);
+
+  // Update `key1` while pageA is in BFCache.
+  localStorage.setItem(key1, 'value');
+
+  // Wait for a storage event is fired on PageC and a while,
+  // to prevent race conditions between event processing
+  // triggered by `setItem()` and the following operations.
+  await pageC.execute_script(() => window.key1EventFired);
+  await new Promise(resolve => t.step_timeout(resolve, 1000));
+
+  // Back navigate to pageA, to be restored from BFCache.
+  await pageB.execute_script(
+    () => {
+      prepareNavigation(() => { history.back(); });
+    }
+  );
+  await pageA.execute_script(waitForPageShow);
+  await assert_bfcached(pageA);
+
+  // Update `key2` after pageA is restored from BFCache.
+  localStorage.setItem(key2, 'value');
+
+  // Wait for a storage event is fired on PageA.
+  await pageA.execute_script(() => window.key2EventFired);
+  assert_array_equals(
+    await pageA.execute_script(() => getRecordedEvents()),
+    [
+      'window.load',
+      'window.pageshow',
+      'window.pagehide.persisted',
+      'window.pageshow.persisted',
+      'storage2',
+    ],
+    'pageA should not receive storage events for updates while in BFCache');
+
+}, 'Storage events should be fired for BFCached pages after becoming active');
+</script>
