Make registerAltDictionaryAndWait more robust and review usages.

Currently, `registerAltDictionaryAndWait()` calls
`waitUntilAvailableDictionaryHeader()` which waits until a request to
`echo-headers2.py` will be sent with an `available-dictionary` header
matching the dictionary hash. This does not properly works if two
calls of `registerAltDictionaryAndWait()` are made in the same
`compression_dictionary_promise_test`, or can lead to flaky behavior
if they are made in the same test file because it can race with
test cleanup's cache clearing. To work around these issues, we instead
force callers to pass distinct dictionary id and watch for the
`Dictionary-ID` header instead. Also improve the documentation are
verify call sites adhere to it.

Bug: 522338661, 40255884
Change-Id: Ib0945969a4093b2e3abd16b222d2f7ebc2450a23

Author: fred-wang

fetch/compression-dictionary/compressed-large-resources-001.tentative.https.html

@@ -20,7 +20,15 @@
   compression_dictionary_promise_test(async t => {
     // Load the non-compressed image to register it as a dictionary for itself.
     await fetchStaticResourceWithUseAsDictionaryHeader(image_dictionary, image_compressed, "image");
-    await registerAltDictionaryAndWait(t);
+
+    // Wait for another dictionary to register to give a chance for the
+    // previous registration to complete. That registration was not done via
+    // register-dictionary.py, so we can't use waitUntilPreviousRequestHeaders.
+    // It also uses a specific match and match-dest, so we cannot use
+    // checkHeaders/checkHeader because echo-headers.py won't use the registered
+    // dictionary (specifically we can't add echo-headers.py as an alternative
+    // to image_compressed, because match does not accept Regexp groups).
+    await registerAltDictionaryAndWait(t, `alt_${token()}`);
 
     // Append the compressed image.
     const img = document.createElement("img");
@@ -43,7 +51,11 @@
   compression_dictionary_promise_test(async t => {
     // Load the non-compressed script to register it as a dictionary for itself.
     await fetchStaticResourceWithUseAsDictionaryHeader(script_dictionary, script_compressed, "script");
-    await registerAltDictionaryAndWait(t);
+
+    // Wait for another dictionary to register to give a chance for the
+    // previous registration to complete. See comment above about why we can't
+    // use waitUntilPreviousRequestHeaders, checkHeaders or checkHeader.
+    await registerAltDictionaryAndWait(t, `alt_${token()}`);
 
     // Append the compressed script.
     const script = document.createElement("script");
@@ -68,7 +80,11 @@
   compression_dictionary_promise_test(async t => {
     // Load the non-compressed style to register it as a dictionary for itself.
     await fetchStaticResourceWithUseAsDictionaryHeader(style_dictionary, style_compressed, "style");
-    await registerAltDictionaryAndWait(t);
+
+    // Wait for another dictionary to register to give a chance for the
+    // previous registration to complete. See comment above about why we can't
+    // use waitUntilPreviousRequestHeaders, checkHeaders or checkHeader.
+    await registerAltDictionaryAndWait(t, `alt_${token()}`);
 
     // Append the compressed style and test div.
     const link = document.createElement("link");

fetch/compression-dictionary/compressed-large-resources-002.tentative.https.html

@@ -23,7 +23,11 @@
     compression_dictionary_promise_test(async t => {
       // Load the non-compressed style to register it as a dictionary for itself.
       await fetchStaticResourceWithUseAsDictionaryHeader(config.subframe_dictionary, config.subframe_compressed, "iframe");
-      await registerAltDictionaryAndWait(t);
+
+      // Wait for another dictionary to register to give a chance for the
+      // previous registration to complete. See comment in the 001 file about
+      // why we can't use waitUntilPreviousRequestHeaders, checkHeaders or checkHeader.
+      await registerAltDictionaryAndWait(t, `alt_${token()}`);
 
       // Append the compressed subframe.
       const iframe = document.createElement("iframe");

fetch/compression-dictionary/dictionary-fetch-no-cors.tentative.https.html

@@ -44,7 +44,7 @@
   try {
     await fetch(redirect_url, {mode: 'no-cors'});
   } catch (e) {}
-  await registerAltDictionaryAndWait(t);
+  await registerAltDictionaryAndWait(t, `alt_${token()}`);
   const headers = await (await fetch(`${CROSS_ORIGIN_RESOURCES_URL}/echo-headers.py`)).json();
   assert_false("available-dictionary" in headers);
 }, 'Opaque responses resulting from cross-origin redirects in no-cors mode do not register dictionary');

fetch/compression-dictionary/dictionary-match.tentative.https.html

@@ -17,7 +17,7 @@
       '/fetch/compression-dictionary/resources/echo-headers.py');
   await fetch(
       `${kRegisterDictionaryPath}?id=id1&match-dest=${match_dest}&match=${pattern}`);
-  await registerAltDictionaryAndWait(t);
+  await registerAltDictionaryAndWait(t, `alt_${token()}`);
   const headers = await (await fetch('./resources/echo-headers.py')).json();
   assert_false("available-dictionary" in headers);
 }, 'Dictionary with unknown match-dest is not used for fetch() API');
@@ -46,7 +46,7 @@
       '/fetch/compression-dictionary/resources/echo-headers.py');
   await fetch(
       `${kRegisterDictionaryPath}?id=id1&match-dest=${match_dest}&match=${pattern}`);
-  await registerAltDictionaryAndWait(t);
+  await registerAltDictionaryAndWait(t, `alt_${token()}`);
   const headers = await (await fetch('./resources/echo-headers.py')).json();
   assert_false("available-dictionary" in headers);
 }, 'Dictionary with non-matching match-dest is not used');

fetch/compression-dictionary/dictionary-registration.tentative.https.html

@@ -101,8 +101,9 @@
       '/fetch/compression-dictionary/resources/echo-headers.py');
   await fetch(
       `${kRegisterDictionaryPath}?id=id1&age=7200&max-age=3600&match=${pattern}`);
-  await registerAltDictionaryAndWait(t);
-  assert_equals((await checkHeaders({use_alt_path: true}))['dictionary-id'], '"id2"');
+  const dictionary_id = `alt_${token()}`;
+  await registerAltDictionaryAndWait(t, dictionary_id);
+  assert_equals((await checkHeaders({use_alt_path: true}))['dictionary-id'], `"${dictionary_id}"`);
   // Make sure the expired dictionary isn't announced as being available.
   const headers = await (await fetch('./resources/echo-headers.py')).json();
   assert_false("available-dictionary" in headers);
@@ -111,15 +112,15 @@
 compression_dictionary_promise_test(async (t) => {
   const pattern = "%7B";
   await fetch(`${kRegisterDictionaryPath}?id=id1&match=${pattern}`);
-  await registerAltDictionaryAndWait(t);
+  await registerAltDictionaryAndWait(t, `alt_${token()}`);
   const headers = await (await fetch('./resources/echo-headers.py')).json();
   assert_false("available-dictionary" in headers);
 }, 'Dictionary with invalid match string is not registered');
 
 compression_dictionary_promise_test(async (t) => {
   const pattern = encodeURIComponent(`${CROSS_ORIGIN_RESOURCES_URL}/echo-headers.py`);
   await fetch(`${kRegisterDictionaryPath}?id=id1&match=${pattern}`);
-  await registerAltDictionaryAndWait(t);
+  await registerAltDictionaryAndWait(t, `alt_${token()}`);
   const headers = await (await fetch('./resources/echo-headers.py')).json();
   assert_false("available-dictionary" in headers);
 }, 'Dictionary with match string for a different origin is not registered');
@@ -129,7 +130,7 @@
       '/fetch/compression-dictionary/resources/echo-headers.py');
   await fetch(
       `${kRegisterDictionaryPath}?id=id1&type=bogus&match=${pattern}`);
-  await registerAltDictionaryAndWait(t);
+  await registerAltDictionaryAndWait(t, `alt_${token()}`);
   const headers = await (await fetch('./resources/echo-headers.py')).json();
   assert_false("available-dictionary" in headers);
 }, 'Dictionary with unsupported type is not registered');
@@ -149,7 +150,7 @@
       '/fetch/compression-dictionary/resources/echo-headers.py');
   await fetch(
       `${kRegisterDictionaryPath}?id=${dictionary_id}&match=${pattern}`);
-  await registerAltDictionaryAndWait(t);
+  await registerAltDictionaryAndWait(t, `alt_${token()}`);
   const headers = await (await fetch('./resources/echo-headers.py')).json();
   assert_false("available-dictionary" in headers);
 }, 'Dictionary with 1025 character dictionary ID is not registered');
@@ -165,14 +166,14 @@
 
 compression_dictionary_promise_test(async (t) => {
   await fetch(`${kRegisterDictionaryPath}?id=id1&use-as-dictionary=%3F0`);
-  await registerAltDictionaryAndWait(t);
+  await registerAltDictionaryAndWait(t, `alt_${token()}`);
   const headers = await (await fetch('./resources/echo-headers.py')).json();
   assert_false("available-dictionary" in headers);
 }, 'Dictionary with malformed structured header is not registered');
 
 compression_dictionary_promise_test(async (t) => {
   await fetch(`${kRegisterDictionaryPath}?id=id1&max-age=0`);
-  await registerAltDictionaryAndWait(t);
+  await registerAltDictionaryAndWait(t, `alt_${token()}`);
   const headers = await (await fetch('./resources/echo-headers.py')).json();
   assert_false("available-dictionary" in headers);
 }, 'Dictionary with max-age=0 is not registered');
@@ -196,7 +197,7 @@
   const pattern = encodeURIComponent(
       '/fetch/compression-dictionary/resources/echo-headers.py');
   await fetch(`${kRegisterDictionaryPath}?id=${encodeURIComponent("€")}&match=${pattern}`);
-  await registerAltDictionaryAndWait(t);
+  await registerAltDictionaryAndWait(t, `alt_${token()}`);
   const headers = await (await fetch('./resources/echo-headers.py')).json();
   assert_false("available-dictionary" in headers);
 }, 'Dictionary with invalid character in dictionary ID is not registered');

fetch/compression-dictionary/resources/compression-dictionary-util.sub.js

@@ -148,14 +148,23 @@ function compression_dictionary_promise_test(func, name, properties) {
 }
 
 // Registers an alternative dictionary and waits for its registration to
-// complete. This is used in tests to confirm that another dictionary's
-// registration process has fully finished.
-async function registerAltDictionaryAndWait(t) {
+// complete. This is used to wait for another dictionary's registration process.
+// If that registration process is expected to succeed, please consider using
+// waitUntilPreviousRequestHeaders (if the dictionary is register-dictionary
+// with some save_header) or checkHeaders/checkHeader (if match includes
+// echo-headers) to obtain more reliable wait time.
+// To ensure registerAltDictionaryAndWait() does not resolve immediately due
+// to a previous call, pass a different dictionary_id for each call.
+async function registerAltDictionaryAndWait(t, dictionary_id) {
+  assert_true(typeof dictionary_id === 'string' && dictionary_id.length > 0,
+              'registerAltDictionaryAndWait requires a valid dictionary_id');
   const pattern = encodeURIComponent("/fetch/compression-dictionary/resources/echo-headers2.py");
-  await fetch(`${kRegisterDictionaryPath}?id=id2&match=${pattern}`);
-  assert_equals(
-      await waitUntilAvailableDictionaryHeader(t, {use_alt_path: true}),
-      kDefaultDictionaryHashBase64);
+  await fetch(
+      `${kRegisterDictionaryPath}?id=${dictionary_id}&match=${pattern}`);
+  const result = await waitUntilHeader(
+      t, 'dictionary-id',
+      {expected_header: `"${dictionary_id}"`, use_alt_path: true});
+  assert_equals(result, `"${dictionary_id}"`);
 }
 
 function navigateToTestWithCompressionDictionaryEarlyHints(test_url, dictionary_url) {