Add test for Trusted Types that mutation observers receive the default policy value when setAttribute is called

.taskcluster.yml

@@ -57,7 +57,7 @@ tasks:
             owner: ${owner}
             source: ${event.repository.clone_url}
           payload:
-            image: webplatformtests/wpt:0.56
+            image: webplatformtests/wpt:0.57
             maxRunTime: 7200
             artifacts:
               public/results:

IndexedDB/back-forward-cache-open-connection.window.js

@@ -29,7 +29,7 @@ promise_test(async t => {
   await rc2.historyBack();
   // The previous page receiving versionchange event should be evicted with the
   // correct reason.
-  // `kIgnoreEventAndEvict` will be reported as "internal-error".
+  // `kIgnoreEventAndEvict` will be reported as "masked".
   // See `NotRestoredReasonToReportString()`.
-  await assertNotRestoredFromBFCache(rc1, ['internal-error']);
+  await assertNotRestoredFromBFCache(rc1, ['masked']);
 });

IndexedDB/worker-termination-aborts-upgrade.window.js

@@ -0,0 +1,71 @@
+// META: title=Worker Termination Aborts a Pending Upgrade
+// META: script=resources/support-promises.js
+
+// This test verifies that if a Worker's shutdown races an IndexedDB
+// versionchange transaction that is creating a database that the next attempt
+// to open the database results in a versionchange from version 0 and that
+// nothing was in the database.
+//
+// Care has been taken to make this test's behavior well-defined relative to the
+// spec to avoid intermittent failures.  In particular
+// `DedicatedWorkerGlobalScope.close()` is used on the worker after issuing the
+// `IDBFactory.open()` call.  This precludes any further tasks running on the
+// worker by spec, although implementations may potentially have "zones of
+// danger" in the time between the worker transitioning and when any state
+// machines on the parent thread realize what's going on.
+
+async function runAsyncFunctionInWorkerThenClose(funcToStringify) {
+  const script = `// This script was created by runAsyncFunctionInWorkerThenClose
+let testFunc = ${funcToStringify.toString()};
+setTimeout(async () => {
+  await testFunc();
+  postMessage("ran");
+  self.close();
+}, 0);
+`;
+  const scriptBlob = new Blob([script]);
+  const url = URL.createObjectURL(scriptBlob);
+  const w = new Worker(url);
+  await new Promise((resolve) => {
+    w.onmessage = (evt) => {
+      if (evt.data === "ran") {
+        resolve();
+      }
+    };
+  });
+  URL.revokeObjectURL(url);
+}
+
+promise_test(async t => {
+  await runAsyncFunctionInWorkerThenClose(async function() {
+    // Note that this code will actually run on the worker, so anything
+    // lexically captured will be coming from the worker's global scope.
+    const openReq = indexedDB.open("aborted-upgrade-db", 1);
+
+    openReq.onupgradeneeded = (event) => {
+      const db = event.target.result;
+      db.createObjectStore("should-not-be-created");
+    }
+  });
+
+  // At this point we know that the open request was issued on the worker
+  // worker thread.  An ordering concern at this point is that IDB only
+  // specifies that the the connection opening algorithm is run in parallel and
+  // we are not guaranteed that when we go "in parallel" here that our operation
+  // won't run first.  As such, it may be necessary to add some kind of
+  // arbitrary delay in the future if implementations do not effectively
+  // maintain sequential ordering of IPC requests within a process.
+  //
+  // Note that we must NOT use `createNamedDatabase` here because it will
+  // issue a blind call to `deleteDatabase`.  Because the migrate helper does
+  // not perform cleanup, we must add the cleanup deletion now, though.
+  t.add_cleanup(() => { indexedDB.deleteDatabase("aborted-upgrade-db"); });
+  let createdDB = await migrateNamedDatabase(t, "aborted-upgrade-db", 1, (db) => {
+    assert_equals(db.objectStoreNames.length, 0, "DB should have been empty");
+    // Let's make sure the database is not permanently broken / corrupted.
+    db.createObjectStore("should-be-created");
+  });
+
+  assert_equals(createdDB.objectStoreNames.length, 1, "created object store correctly");
+  assert_equals(createdDB.objectStoreNames.item(0), "should-be-created");
+});

WebCryptoAPI/derive_bits_keys/cfrg_curves_bits.js

@@ -6,8 +6,6 @@ function define_tests() {
   // Verify the derive functions perform checks against the all-zero value results,
   // ensuring small-order points are rejected.
   // https://www.rfc-editor.org/rfc/rfc7748#section-6.1
-  // TODO: The spec states that the check must be done on use, but there is discussion about doing it on import.
-  // https://github.com/WICG/webcrypto-secure-curves/pull/13
   Object.keys(kSmallOrderPoint).forEach(function(algorithmName) {
       kSmallOrderPoint[algorithmName].forEach(function(test) {
           promise_test(async() => {
@@ -23,8 +21,8 @@ function define_tests() {
                                                  false, [])
                   derived = await subtle.deriveBits({name: algorithmName, public: publicKey}, privateKey, 8 * sizes[algorithmName]);
               } catch (err) {
-                  assert_false(privateKey === undefined, "Private key should be valid.");
-                  assert_false(publicKey === undefined, "Public key should be valid.");
+                  assert_true(privateKey !== undefined, "Private key should be valid.");
+                  assert_true(publicKey !== undefined, "Public key should be valid.");
                   assert_equals(err.name, "OperationError", "Should throw correct error, not " + err.name + ": " + err.message + ".");
               }
               assert_equals(derived, undefined, "Operation succeeded, but should not have.");

WebCryptoAPI/sign_verify/eddsa.js

@@ -366,6 +366,28 @@ function run_test() {
       }, "Sign and verify using generated " + vector.algorithmName + " keys.");
   });
 
+  // When verifying an Ed25519 or Ed448 signature, if the public key or the first half of the signature (R) is
+  // an invalid or small-order element, return false.
+  Object.keys(kSmallOrderTestCases).forEach(function (algorithmName) {
+      var algorithm = {name: algorithmName};
+      kSmallOrderTestCases[algorithmName].forEach(function(test) {
+          // Test low-order public keys
+          promise_test(async() => {
+              let isVerified = true;
+              let publicKey;
+              try {
+                  publicKey = await subtle.importKey("raw", test.keyData,
+                                                 algorithm,
+                                                 false, ["verify"])
+                  isVerified = await subtle.verify(algorithmName, publicKey, test.signature, test.message);
+              } catch (err) {
+                  assert_equals(isVerified, test.verified, "Signature verification result.");
+                  assert_unreached("The operation shouldn't fail, but it thown this error: " + err.name + ": " + err.message + ".");
+              }
+              assert_false(isVerified, "Signature verification result.");
+          }, algorithmName + " Verification checks with small-order key of order - Test " + test.id);
+      });
+  });
 
   // A test vector has all needed fields for signing and verifying, EXCEPT that the
   // key field may be null. This function replaces that null with the Correct