From fbb0aae478a9fee85adabb5b274b0a92bbe82948 Mon Sep 17 00:00:00 2001
From: "Volodymyr Klymenko ext:(%3E)" <klymenkodp@gmail.com>
Date: Fri, 14 Dec 2018 00:44:52 +0000
Subject: [PATCH] Bug 1508825 - Enable ESLint for dom/crypto/ (automatic
 changes) r=Standard8,Ehsan

Differential Revision: https://phabricator.services.mozilla.com/D13693

--HG--
extra : moz-landing-system : lando
---
 dom/crypto/test/file_indexedDB.html           |  10 +-
 dom/crypto/test/test-array.js                 |  40 ++--
 dom/crypto/test/test-vectors.js               |  90 ++++-----
 dom/crypto/test/test-worker.js                |   6 +-
 dom/crypto/test/test_WebCrypto.html           | 172 +++++++++---------
 dom/crypto/test/test_WebCrypto_DH.html        |  32 ++--
 dom/crypto/test/test_WebCrypto_ECDH.html      |  80 ++++----
 dom/crypto/test/test_WebCrypto_ECDSA.html     |  22 +--
 dom/crypto/test/test_WebCrypto_HKDF.html      |  32 ++--
 ...Crypto_Import_Multiple_Identical_Keys.html |  10 +-
 dom/crypto/test/test_WebCrypto_JWK.html       | 142 +++++++--------
 dom/crypto/test/test_WebCrypto_Normalize.html |   6 +-
 dom/crypto/test/test_WebCrypto_PBKDF2.html    |  26 +--
 dom/crypto/test/test_WebCrypto_RSA_OAEP.html  |  42 ++---
 dom/crypto/test/test_WebCrypto_RSA_PSS.html   |  42 ++---
 ...Reject_Generating_Keys_Without_Usages.html |  14 +-
 .../test_WebCrypto_Structured_Cloning.html    |  20 +-
 dom/crypto/test/test_WebCrypto_Workers.html   |  10 +-
 .../test/test_WebCrypto_Wrap_Unwrap.html      |  80 ++++----
 dom/crypto/test/test_indexedDB.html           |   4 +-
 dom/crypto/test/util.js                       |  16 +-
 21 files changed, 448 insertions(+), 448 deletions(-)

diff --git a/dom/crypto/test/file_indexedDB.html b/dom/crypto/test/file_indexedDB.html
index 720a06dcdb6e..390b3f80dbf2 100644
--- a/dom/crypto/test/file_indexedDB.html
+++ b/dom/crypto/test/file_indexedDB.html
@@ -17,7 +17,7 @@
         let request = indexedDB.open("keystore", 1);
 
         request.onerror = err(reject);
-        request.onsuccess = function (event) {
+        request.onsuccess = function(event) {
           db = event.target.result;
           resolve();
         };
@@ -38,11 +38,11 @@
         transaction.onabort = err(reject);
         transaction.onerror = err(reject);
 
-        transaction.oncomplete = function () {
+        transaction.oncomplete = function() {
           resolve(key);
         };
       });
-    };
+    }
 
     function retrieveKey() {
       return new Promise((resolve, reject) => {
@@ -52,7 +52,7 @@
         cursor.onerror = err(reject);
         cursor.onabort = err(reject);
 
-        cursor.onsuccess = function (event) {
+        cursor.onsuccess = function(event) {
           try {
             let result = event.target.result;
             resolve(result && result.value);
@@ -68,7 +68,7 @@
         name: "RSASSA-PKCS1-v1_5",
         hash: "SHA-256",
         modulusLength: 1024,
-        publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
       };
 
       return crypto.subtle.generateKey(algorithm, true, ["sign", "verify"]);
diff --git a/dom/crypto/test/test-array.js b/dom/crypto/test/test-array.js
index 1297f8eb8945..5dbe6bea50ae 100644
--- a/dom/crypto/test/test-array.js
+++ b/dom/crypto/test/test-array.js
@@ -62,7 +62,7 @@ function Test(name, test) {
     if (this.name) {
       this.row[0].innerHTML = this.name;
       var that = this;
-      this.row[0].onclick = function() { that.run(); }
+      this.row[0].onclick = function() { that.run(); };
     } else {
       this.row[0] = "";
     }
@@ -75,12 +75,12 @@ function Test(name, test) {
       this.row[1].className = "fail";
       this.row[1].innerHTML = "FAIL";
     } else {
-      //this.row[1].innerHTML = "";
+      // this.row[1].innerHTML = "";
       this.row[1].innerHTML = this.result;
     }
 
     // Print the elapsed time, if known
-    if (this.startTime &&  this.endTime) {
+    if (this.startTime && this.endTime) {
       this.row[2].innerHTML = (this.endTime - this.startTime) + " ms";
     } else {
       this.row[2].innerHTML = "";
@@ -128,7 +128,7 @@ var TestArray = {
   currTest: 0,
   worker: new Worker("test-worker.js"),
 
-  addTest: function(name, testFn) {
+  addTest(name, testFn) {
     // Give it a reference to the array
     var test = new Test(name, testFn);
     test.ta = this;
@@ -140,19 +140,19 @@ var TestArray = {
     this.tests.push(new WorkerTest(this.worker, name, testFn));
   },
 
-  updateSummary: function() {
+  updateSummary() {
     this.pass = this.fail = this.pending = 0;
-    for (var i=0; i<this.tests.length; ++i) {
-      if (this.tests[i].result == true)  this.pass++;
+    for (var i = 0; i < this.tests.length; ++i) {
+      if (this.tests[i].result == true) this.pass++;
       if (this.tests[i].result == false) this.fail++;
-      if (this.tests[i].result == null)  this.pending++;
+      if (this.tests[i].result == null) this.pending++;
     }
     this.passSpan.innerHTML = this.pass;
     this.failSpan.innerHTML = this.fail;
     this.pendingSpan.innerHTML = this.pending;
   },
 
-  load: function() {
+  load() {
     // Grab reference to table and summary numbers
     this.table = document.getElementById("results");
     this.passSpan = document.getElementById("passN");
@@ -161,7 +161,7 @@ var TestArray = {
 
     // Populate everything initially
     this.updateSummary();
-    for (var i=0; i<this.tests.length; ++i) {
+    for (var i = 0; i < this.tests.length; ++i) {
       var tr = document.createElement("tr");
       tr.id = "test" + i;
       tr.appendChild(document.createElement("td"));
@@ -173,12 +173,12 @@ var TestArray = {
     }
   },
 
-  run: function() {
+  run() {
     this.currTest = 0;
     this.runNextTest();
   },
 
-  runNextTest: function() {
+  runNextTest() {
     this.updateSummary();
     var i = this.currTest++;
     if (i >= this.tests.length) {
@@ -189,10 +189,10 @@ var TestArray = {
     var self = this;
     this.tests[i].oncomplete = function() {
       self.runNextTest();
-    }
+    };
     this.tests[i].run();
-  }
-}
+  },
+};
 
 if (window.addEventListener) {
   window.addEventListener("load", function() { TestArray.load(); } );
@@ -218,25 +218,25 @@ function error(test) {
     console.log("ERROR :: " + x);
     test.complete(false);
     throw x;
-  }
+  };
 }
 
 function complete(test, valid) {
   return function(x) {
-    console.log("COMPLETE")
+    console.log("COMPLETE");
     console.log(x);
     if (valid) {
       test.complete(valid(x));
     } else {
       test.complete(true);
     }
-  }
+  };
 }
 
 function memcmp_complete(test, value) {
   return function(x) {
-    console.log("COMPLETE")
+    console.log("COMPLETE");
     console.log(x);
     test.memcmp_complete(value, x);
-  }
+  };
 }
diff --git a/dom/crypto/test/test-vectors.js b/dom/crypto/test/test-vectors.js
index cabef4c734ea..ac4187e8490a 100644
--- a/dom/crypto/test/test-vectors.js
+++ b/dom/crypto/test/test-vectors.js
@@ -105,7 +105,7 @@ tv = {
                       "feffe9928665731c6d6a8f9467308308"),
     key_jwk: {
       kty: "oct",
-      k: "_v_pkoZlcxxtao-UZzCDCP7_6ZKGZXMcbWqPlGcwgwg"
+      k: "_v_pkoZlcxxtao-UZzCDCP7_6ZKGZXMcbWqPlGcwgwg",
     },
     iv: util.hex2abv("9313225df88406e555909c5aff5269aa" +
                      "6a7a9538534f7da1e4c303d2a318a728" +
@@ -295,7 +295,7 @@ tv = {
       dq: "Gos485j6cSBJiY1_t57gp3ZoeRKZzfoJ78DlB6yyHtdDAe9b_Ui-RV6utuFng" +
           "lWCdYCo5OjhQVHRUQqCo_LnKQ",
       qi: "JxVqukEm0kqB86Uoy_sn9WiG-ECp9uhuF6RLlP6TGVhLjiL93h5aLjvYqluo2" +
-          "FhBlOshkKz4MrhH8To9JKefTQ"
+          "FhBlOshkKz4MrhH8To9JKefTQ",
     },
     spki: util.hex2abv(
       "30819f300d06092a864886f70d010101050003818d0030818902818100a56e4a" +
@@ -516,7 +516,7 @@ tv = {
       "8442e03da015b136e543f7ab07c0c13e4225b8de8cce25d4f6eb8400f81f7e18" +
       "33b7ee6e334d370964ca79fdb872b4d75223b5eeb08101591fb532d155a6de87"
     ),
-    saltLength: 20
+    saltLength: 20,
   },
 
   // [SigVerPSS_186-3.rsp] from
@@ -541,7 +541,7 @@ tv = {
       "d2ab24f789b3464c5c43a256bbc1d692cf7f04801dac5bb401a4a03ab7d5728a" +
       "860c19e1a4dc797ca542c8203cec2e601eb0c51f567f2eda022b0b9ebddeeefa"
     ),
-    saltLength: 10
+    saltLength: 10,
   },
 
   // [SigVerPSS_186-3.rsp] from
@@ -566,7 +566,7 @@ tv = {
       "9b41cdbd530c69d17cdbc84bc6b9830fc7dc8e1b2412cfe06dcf8c1a0cc3453f" +
       "93f25ebf10cb0c90334fac573f449138616e1a194c67f44efac34cc07a526267"
     ),
-    saltLength: 10
+    saltLength: 10,
   },
 
   // [SigVerPSS_186-3.rsp] from
@@ -591,7 +591,7 @@ tv = {
       "6551cdf93197e9f8fb048044473ab41a801e9f7fc983c62b324361dade9f71a6" +
       "5952bd35c59faaa4d6ff462f68a6c4ec0b428aa47336f2178aeb276136563b7d"
     ),
-    saltLength: 10
+    saltLength: 10,
   },
 
   key_wrap_known_answer: {
@@ -599,7 +599,7 @@ tv = {
     wrapping_key: util.hex2abv("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"),
     wrapping_iv:  util.hex2abv("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c"),
     wrapped_key:  util.hex2abv("9ed0283a9a2b7e4292ebc5135e6342cc" +
-                               "8a7f65802a1f6fd41bd3251c4da0c138")
+                               "8a7f65802a1f6fd41bd3251c4da0c138"),
   },
 
   // AES Key Wrap
@@ -609,14 +609,14 @@ tv = {
     wrapping_key: {
       kty: "oct",
       alg: "A256KW",
-      k:   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8"
+      k:   "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8",
     },
     key: {
       kty: "oct",
-      k:   "ABEiM0RVZneImaq7zN3u_w"
+      k:   "ABEiM0RVZneImaq7zN3u_w",
     },
-    wrapped_key: util.hex2abv("64e8c3f9ce0f5ba263e9777905818a2a"+
-                              "93c8191e7d6e8ae7")
+    wrapped_key: util.hex2abv("64e8c3f9ce0f5ba263e9777905818a2a" +
+                              "93c8191e7d6e8ae7"),
   },
 
   // RFC 6070 <http://tools.ietf.org/html/rfc6070>
@@ -632,8 +632,8 @@ tv = {
 
     jwk: {
       kty: "oct",
-      k: "cGFzc3dvcmRQQVNTV09SRHBhc3N3b3Jk"
-    }
+      k: "cGFzc3dvcmRQQVNTV09SRHBhc3N3b3Jk",
+    },
   },
 
   // https://stackoverflow.com/questions/5130513/pbkdf2-hmac-sha2-test-vectors
@@ -646,7 +646,7 @@ tv = {
     derived: util.hex2abv(
       "348c89dbcbd32b2f32d814b8116e84cf2b17347ebc1800181c4e2a1fb8dd53e1" +
       "c635518c7dac47e9"
-    )
+    ),
   },
 
   pbkdf2_sha256_no_salt: {
@@ -656,7 +656,7 @@ tv = {
     iterations: 1,
 
     derived: util.hex2abv(
-      "ef29dd382fa66a83a95be7ccfb71f1ccfee494977855a4c260d90c2f8c91e062")
+      "ef29dd382fa66a83a95be7ccfb71f1ccfee494977855a4c260d90c2f8c91e062"),
   },
 
   pbkdf2_sha256_no_pwd: {
@@ -666,7 +666,7 @@ tv = {
     iterations: 1,
 
     derived: util.hex2abv(
-      "1635fa0f0542cc84f51207ff6cad5284aee3b0264faa55868eca95a7efd2335c")
+      "1635fa0f0542cc84f51207ff6cad5284aee3b0264faa55868eca95a7efd2335c"),
   },
 
   broken_pkcs8: {
@@ -684,7 +684,7 @@ tv = {
       "fd6d95e9cefcb0745763cddf564c87bcf4ba7928e74fd6a3080481f588d535e4" +
       "c026b58a21e1e5ec412ff241b436043e29173f1dc6cb943c09742de989547288" +
       "0416021442c6ee70beb7465928a1efe692d2281b8f7b53d6"
-    )
+    ),
   },
 
   // KASValidityTest_ECCEphemeralUnified_NOKC_ZZOnly_init.fax [EC]
@@ -694,7 +694,7 @@ tv = {
       kty: "EC",
       crv: "P-256",
       x: "XOe4bjsyZgQD5jcS7wmY3q4QJ_rsPBvp92-TTf61jpg",
-      y: "9M8HWzlAXdHxresJAQftz7K0ljc52HZ54wVssFV9Ct8"
+      y: "9M8HWzlAXdHxresJAQftz7K0ljc52HZ54wVssFV9Ct8",
     },
 
     jwk_priv: {
@@ -702,7 +702,7 @@ tv = {
       crv: "P-256",
       d: "qq_LEzeJpR00KM5DQvL2MNtJcbi0KcGVcoPIHNnwm2A",
       x: "FNwJHA-FwnSx5tKXFV_iLN408gbKUHRV06WnQlzTdN4",
-      y: "is9pWAaneK4RdxmdLfsq5IwizDmUS2w8OGS99sKm3ek"
+      y: "is9pWAaneK4RdxmdLfsq5IwizDmUS2w8OGS99sKm3ek",
     },
 
     // vector with algorithm = id-ecDH
@@ -726,7 +726,7 @@ tv = {
 
     secret: util.hex2abv(
       "35669cd5c244ba6c1ea89b8802c3d1db815cd769979072e6556eb98548c65f7d"
-    )
+    ),
   },
 
   // KASValidityTest_ECCEphemeralUnified_NOKC_ZZOnly_init.fax [ED]
@@ -736,7 +736,7 @@ tv = {
       kty: "EC",
       crv: "P-384",
       x: "YoV6fhCph4kyt7sUkqiZOtbRs0rF6etPqlnrn1nzSB95NElaw4uTK7Pn2nlFFqqH",
-      y: "bf3tRz6icq3-W6hhmoqDTBKjdOQUJ5xHr5kX4X-h5MZk_P_nCrG3IUVl1SAbhWDw"
+      y: "bf3tRz6icq3-W6hhmoqDTBKjdOQUJ5xHr5kX4X-h5MZk_P_nCrG3IUVl1SAbhWDw",
     },
 
     jwk_priv: {
@@ -744,13 +744,13 @@ tv = {
       crv: "P-384",
       d: "RT8f0pRw4CL1Tgk4rwuNnNbFoQBNTTBkr7WVLLm4fDA3boYZpNB_t-rbMVLx0CRp",
       x: "_XwhXRnOzEfCsWIRCz3QLClaDkigQFvXmqYNdh_7vJdADykPbfGi1VgAu3XJdXoD",
-      y: "S1P_FBCXYGE-5VPvTCRnFT7bPIPmUPV9qKTM24TQFYEUgIDfzCLsyGCWK-rhP6jU"
+      y: "S1P_FBCXYGE-5VPvTCRnFT7bPIPmUPV9qKTM24TQFYEUgIDfzCLsyGCWK-rhP6jU",
     },
 
     secret: util.hex2abv(
       "a3d28aa18f905a48a5f166b4ddbf5f6b499e43858ccdd80b869946aba2c5d461" +
       "db6a1e5b1137687801878ff0f8d9a7b3"
-    )
+    ),
   },
 
   // KASValidityTest_ECCEphemeralUnified_NOKC_ZZOnly_init.fax [EE]
@@ -762,7 +762,7 @@ tv = {
       x: "AeCLgRZ-BPqfhq4jt409-E26VHW5l29q74cHbIbQiS_-Gcqdo-087jHdPXUksGpr" +
          "Nyp_RcTZd94t3peXzQziQIqo",
       y: "AZIAp8QVnU9hBOkLScv0dy540uGtBWHkWj4DGh-Exh4iWZ0E-YBS8-HVx2eB-nfG" +
-         "AGEy4-BzfpFFlfidOS1Tg77J"
+         "AGEy4-BzfpFFlfidOS1Tg77J",
     },
 
     jwk_priv: {
@@ -773,14 +773,14 @@ tv = {
       x: "AcD_6Eb4A-8QdUM70c6F0WthN1kvV4fohS8QHbod6B4y1ZDU54mQuCR-3IBjcV1c" +
          "oh18uxbyUn5szMuCgjZUiD0y",
       y: "AU3WKJffztkhAQetBXaLvUSIHa87HMn8vZFB04lWipH-SrsrAu_4N-6iam0OD4EJ" +
-         "0kOMH8iEh7yuivaKsFRzm2-m"
+         "0kOMH8iEh7yuivaKsFRzm2-m",
     },
 
     secret: util.hex2abv(
       "00561eb17d856552c21b8cbe7d3d60d1ea0db738b77d4050fa2dbd0773edc395" +
       "09854d9e30e843964ed3fd303339e338f31289120a38f94e9dc9ff7d4b3ea8f2" +
       "5e01"
-    )
+    ),
   },
 
   // Some test vectors that we should fail to import.
@@ -790,21 +790,21 @@ tv = {
       kty: "EC",
       crv: "P-123",
       x: "XOe4bjsyZgQD5jcS7wmY3q4QJ_rsPBvp92-TTf61jpg",
-      y: "9M8HWzlAXdHxresJAQftz7K0ljc52HZ54wVssFV9Ct8"
+      y: "9M8HWzlAXdHxresJAQftz7K0ljc52HZ54wVssFV9Ct8",
     },
 
     // The crv parameter is missing.
     jwk_missing_crv: {
       kty: "EC",
       x: "XOe4bjsyZgQD5jcS7wmY3q4QJ_rsPBvp92-TTf61jpg",
-      y: "9M8HWzlAXdHxresJAQftz7K0ljc52HZ54wVssFV9Ct8"
+      y: "9M8HWzlAXdHxresJAQftz7K0ljc52HZ54wVssFV9Ct8",
     },
 
     // The X coordinate is missing.
     jwk_missing_x: {
       kty: "EC",
       crv: "P-256",
-      y: "9M8HWzlAXdHxresJAQftz7K0ljc52HZ54wVssFV9Ct8"
+      y: "9M8HWzlAXdHxresJAQftz7K0ljc52HZ54wVssFV9Ct8",
     },
 
     // The Y coordinate is missing.
@@ -836,7 +836,7 @@ tv = {
     raw_compressed: util.hex2abv(
       "025ce7b86e3b32660403e63712ef0998deae1027faec3c1be9f76f934dfeb58e" +
       "98f4cf075b39405dd1f1adeb090107edcfb2b4963739d87679e3056cb0557d0adf"
-    )
+    ),
   },
 
   // NIST ECDSA test vectors
@@ -882,7 +882,7 @@ tv = {
             "99e4bc72fd79d28a380f8d4b4c919ac290d248c37983ba05aea42e2dd79fdd33e8" +
             "0087488c859a96fea266ea13bf6d114c429b163be97a57559086edb64aed4a1859" +
             "4b46fb9efc7fd25d8b2de8f09ca0587f54bd287299f47b2ff124aac56600000000"
-          )
+          ),
   },
 
   ecdsa_bad: {
@@ -892,8 +892,8 @@ tv = {
       "x": "BhOH_WuVkU6IX5Eu37tfsnRlUCfyFsQJHKg-GTNnQP2B" +
            "rt_gR_UbQr32gWESEBPg1VsRehTkMD-SbI3rt3p_2q0B",
       "y": "AUNouOdGgHsraPNhXNeNdhpGTd15GPyN9R0iWWL98ePc" +
-           "JD4mUQD/DsEzNZ4zLkTdSa/Y5fOP6GEzVzQy0zwC+goD"
-    }
+           "JD4mUQD/DsEzNZ4zLkTdSa/Y5fOP6GEzVzQy0zwC+goD",
+    },
   },
 
   // RFC 2409 <http://tools.ietf.org/html/rfc2409#section-6.2>
@@ -952,7 +952,7 @@ tv = {
       "7a08b0c7c509110b9e7c6dbc961ca4360362d3dbcffc5bf2bb7207e0a5922f77" +
       "cf5464b316aa49fb62b338ebcdb30bf573d07b663bb7777b69d6317df0a4f636" +
       "ba3d9acbf9e8ac"
-    )
+    ),
   },
 
   // Taken from appendix A of RFC 5869.
@@ -969,8 +969,8 @@ tv = {
       ),
       jwk: {
         kty: "oct",
-        k: "CwsLCwsLCwsLCwsLCwsLCwsLCwsLCw"
-      }
+        k: "CwsLCwsLCwsLCwsLCwsLCwsLCwsLCw",
+      },
     },
     {
       prf: "SHA-256",
@@ -993,7 +993,7 @@ tv = {
         "b11e398dc80327a1c8e7f78c596a49344f012eda2d4efad8a050cc4c19afa97c" +
         "59045a99cac7827271cb41c65e590e09da3275600c2f09b8367793a9aca3db71" +
         "cc30c58179ec3e87c14c01d5c1f3434f1d87"
-      )
+      ),
     },
     {
       prf: "SHA-256",
@@ -1003,7 +1003,7 @@ tv = {
       data: util.hex2abv(
         "8da4e775a563c18f715f802a063c5a31b8a11f5c5ee1879ec3454e5f3c738d2d" +
         "9d201395faa4b61a96c8"
-      )
+      ),
     },
     {
       prf: "SHA-1",
@@ -1013,7 +1013,7 @@ tv = {
       data: util.hex2abv(
         "085a01ea1b10f36933068b56efa5ad81a4f14b822f5b091568a9cdd4f155fda2" +
         "c22e422478d305f3f896"
-      )
+      ),
     },
     {
       prf: "SHA-1",
@@ -1036,7 +1036,7 @@ tv = {
         "0bd770a74d1160f7c9f12cd5912a06ebff6adcae899d92191fe4305673ba2ffe" +
         "8fa3f1a4e5ad79f3f334b3b202b2173c486ea37ce3d397ed034c7f9dfeb15c5e" +
         "927336d0441f4c4300e2cff0d0900b52d3b4"
-      )
+      ),
     },
     {
       prf: "SHA-1",
@@ -1046,7 +1046,7 @@ tv = {
       data: util.hex2abv(
         "0ac1af7002b3d761d1e55298da9d0506b9ae52057220a306e07b6b87e8df21d0" +
         "ea00033de03984d34918"
-      )
+      ),
     },
     {
       prf: "SHA-1",
@@ -1056,7 +1056,7 @@ tv = {
       data: util.hex2abv(
         "2c91117204d745f3500d636a62f64f0ab3bae548aa53d423b0d1f27ebba6f5e5" +
         "673a081d70cce7acfc48"
-      )
-    }
-  ]
-}
+      ),
+    },
+  ],
+};
diff --git a/dom/crypto/test/test-worker.js b/dom/crypto/test/test-worker.js
index 02f248fae74e..65edf0329a68 100644
--- a/dom/crypto/test/test-worker.js
+++ b/dom/crypto/test/test-worker.js
@@ -22,18 +22,18 @@ function complete(test, valid) {
 }
 
 function memcmp_complete(test, value) {
-  return function (x) {
+  return function(x) {
     finish(util.memcmp(x, value));
   };
 }
 
 function error(test) {
-  return function (x) {
+  return function(x) {
     throw x;
   };
 }
 
-onmessage = function (msg) {
+onmessage = function(msg) {
   var test = eval("(" + msg.data + ")");
 
   try {
diff --git a/dom/crypto/test/test_WebCrypto.html b/dom/crypto/test/test_WebCrypto.html
index aff04f20acfd..7d95ee6796f6 100644
--- a/dom/crypto/test/test_WebCrypto.html
+++ b/dom/crypto/test/test_WebCrypto.html
@@ -19,7 +19,7 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // -----------------------------------------------------------------------------
@@ -51,7 +51,7 @@ TestArray.addTest(
     var alg = {
       get name() {
         throw "Oh no, no name!";
-      }
+      },
     };
 
     crypto.subtle.importKey("raw", tv.raw, alg, true, ["encrypt"])
@@ -60,7 +60,7 @@ TestArray.addTest(
         complete(that, function(x) { return true; })
       );
   }
-)
+);
 
 // -----------------------------------------------------------------------------
 TestArray.addTest(
@@ -77,7 +77,7 @@ TestArray.addTest(
         (x.type != "secret") ||
         (!x.extractable) ||
         (x.usages.length != 1) ||
-        (x.usages[0] != 'encrypt')){
+        (x.usages[0] != "encrypt")) {
         throw "Invalid key: incorrect key data";
       }
       return crypto.subtle.exportKey("raw", x);
@@ -116,7 +116,7 @@ TestArray.addTest(
                              0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
                              0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f]);
     var u32 = new Uint32Array(u8.buffer, 8, 4);
-    var out = u8.subarray(8, 24)
+    var out = u8.subarray(8, 24);
 
     function doExport(x) {
       return crypto.subtle.exportKey("raw", x);
@@ -145,7 +145,7 @@ TestArray.addTest(
         (x.type != "private") ||
         (!x.extractable) ||
         (x.usages.length != 1) ||
-        (x.usages[0] != 'sign')){
+        (x.usages[0] != "sign")) {
         throw "Invalid key: incorrect key data";
       }
       return crypto.subtle.exportKey("pkcs8", x);
@@ -179,7 +179,7 @@ TestArray.addTest(
     var that = this;
     var alg = {
       name: "RSASSA-PKCS1-v1_5",
-      hash: "SHA-256"
+      hash: "SHA-256",
     };
 
     function doExport(x) {
@@ -191,7 +191,7 @@ TestArray.addTest(
         (x.type != "public") ||
         (!x.extractable) ||
         (x.usages.length != 1) ||
-        (x.usages[0] != 'verify')){
+        (x.usages[0] != "verify")) {
         throw "Invalid key: incorrect key data";
       }
       return crypto.subtle.exportKey("spki", x);
@@ -213,7 +213,7 @@ TestArray.addTest(
     var that = this;
     var alg = {
       name: "RSASSA-PKCS1-v1_5",
-      hash: "SHA-256"
+      hash: "SHA-256",
     };
 
     crypto.subtle.importKey("spki", tv.negative_spki, alg, true, ["encrypt"])
@@ -267,7 +267,7 @@ TestArray.addTest(
       req.onupgradeneeded = function(e) {
         db = e.target.result;
         db.createObjectStore(dbstore, {keyPath: "id"});
-      }
+      };
 
       req.onsuccess = doPut;
     }
@@ -291,7 +291,7 @@ TestArray.addTest(
       });
     }
 
-    crypto.subtle.importKey("raw", tv.raw, alg, false, ['encrypt'])
+    crypto.subtle.importKey("raw", tv.raw, alg, false, ["encrypt"])
       .then(doIndexedDB, error(that));
   }
 );
@@ -391,7 +391,7 @@ TestArray.addTest(
       name: "RSASSA-PKCS1-v1_5",
       hash: "SHA-256",
       modulusLength: 1024,
-      publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
     };
     crypto.subtle.generateKey(alg, false, ["sign", "verify"]).then(
       complete(that, function(x) {
@@ -424,7 +424,7 @@ TestArray.addTest(
       name: "RSASSA-PKCS1-v1_5",
       hash: "SHA-256",
       modulusLength: 2299, // NSS does not like this key length
-      publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
     };
 
     crypto.subtle.generateKey(alg, false, ["sign"])
@@ -459,7 +459,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-CBC encrypt",
-  function () {
+  function() {
     var that = this;
 
     function doEncrypt(x) {
@@ -468,7 +468,7 @@ TestArray.addTest(
         x, tv.aes_cbc_enc.data);
     }
 
-    crypto.subtle.importKey("raw", tv.aes_cbc_enc.key, "AES-CBC", false, ['encrypt'])
+    crypto.subtle.importKey("raw", tv.aes_cbc_enc.key, "AES-CBC", false, ["encrypt"])
       .then(doEncrypt)
       .then(
         memcmp_complete(that, tv.aes_cbc_enc.result),
@@ -480,21 +480,21 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-CBC encrypt with wrong IV size",
-  function () {
+  function() {
     var that = this;
 
     function encrypt(x, iv) {
       return crypto.subtle.encrypt(
-        { name: "AES-CBC", iv: iv },
+        { name: "AES-CBC", iv },
         x, tv.aes_cbc_enc.data);
     }
 
     function doEncrypt(x) {
       return encrypt(x, new Uint8Array(15))
-        .catch(function () { return encrypt(new Uint8Array(17)); });
+        .catch(function() { return encrypt(new Uint8Array(17)); });
     }
 
-    crypto.subtle.importKey("raw", tv.aes_cbc_enc.key, "AES-CBC", false, ['encrypt'])
+    crypto.subtle.importKey("raw", tv.aes_cbc_enc.key, "AES-CBC", false, ["encrypt"])
       .then(doEncrypt)
       .then(
         error(that),
@@ -506,7 +506,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-CBC decrypt",
-  function () {
+  function() {
     var that = this;
 
     function doDecrypt(x) {
@@ -515,7 +515,7 @@ TestArray.addTest(
         x, tv.aes_cbc_dec.data);
     }
 
-    crypto.subtle.importKey("raw", tv.aes_cbc_dec.key, "AES-CBC", false, ['decrypt'])
+    crypto.subtle.importKey("raw", tv.aes_cbc_dec.key, "AES-CBC", false, ["decrypt"])
       .then(doDecrypt)
       .then(
         memcmp_complete(that, tv.aes_cbc_dec.result),
@@ -527,21 +527,21 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-CBC decrypt with wrong IV size",
-  function () {
+  function() {
     var that = this;
 
     function decrypt(x, iv) {
       return crypto.subtle.decrypt(
-        { name: "AES-CBC", iv: iv },
+        { name: "AES-CBC", iv },
         x, tv.aes_cbc_dec.data);
     }
 
     function doDecrypt(x) {
       return decrypt(x, new Uint8Array(15))
-        .catch(function () { return decrypt(x, new Uint8Array(17)); });
+        .catch(function() { return decrypt(x, new Uint8Array(17)); });
     }
 
-    crypto.subtle.importKey("raw", tv.aes_cbc_dec.key, "AES-CBC", false, ['decrypt'])
+    crypto.subtle.importKey("raw", tv.aes_cbc_dec.key, "AES-CBC", false, ["decrypt"])
       .then(doDecrypt)
       .then(
         error(that),
@@ -553,7 +553,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-CTR encryption",
-  function () {
+  function() {
     var that = this;
 
     function doEncrypt(x) {
@@ -562,7 +562,7 @@ TestArray.addTest(
         x, tv.aes_ctr_enc.data);
     }
 
-    crypto.subtle.importKey("raw", tv.aes_ctr_enc.key, "AES-CTR", false, ['encrypt'])
+    crypto.subtle.importKey("raw", tv.aes_ctr_enc.key, "AES-CTR", false, ["encrypt"])
       .then(doEncrypt)
       .then(
         memcmp_complete(that, tv.aes_ctr_enc.result),
@@ -574,7 +574,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-CTR encryption with wrong IV size",
-  function () {
+  function() {
     var that = this;
 
     function encrypt(x, iv) {
@@ -585,10 +585,10 @@ TestArray.addTest(
 
     function doEncrypt(x) {
       return encrypt(x, new Uint8Array(15))
-        .catch(function () { return encrypt(x, new Uint8Array(17)); });
+        .catch(function() { return encrypt(x, new Uint8Array(17)); });
     }
 
-    crypto.subtle.importKey("raw", tv.aes_ctr_enc.key, "AES-CTR", false, ['encrypt'])
+    crypto.subtle.importKey("raw", tv.aes_ctr_enc.key, "AES-CTR", false, ["encrypt"])
       .then(doEncrypt)
       .then(
         error(that),
@@ -600,7 +600,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-CTR decryption",
-  function () {
+  function() {
     var that = this;
 
     function doDecrypt(x) {
@@ -609,7 +609,7 @@ TestArray.addTest(
         x, tv.aes_ctr_dec.data);
     }
 
-    crypto.subtle.importKey("raw", tv.aes_ctr_dec.key, "AES-CTR", false, ['decrypt'])
+    crypto.subtle.importKey("raw", tv.aes_ctr_dec.key, "AES-CTR", false, ["decrypt"])
       .then(doDecrypt)
       .then(
         memcmp_complete(that, tv.aes_ctr_dec.result),
@@ -621,7 +621,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-CTR decryption with wrong IV size",
-  function () {
+  function() {
     var that = this;
 
     function doDecrypt(x, iv) {
@@ -632,10 +632,10 @@ TestArray.addTest(
 
     function decrypt(x) {
       return decrypt(x, new Uint8Array(15))
-        .catch(function () { return decrypt(x, new Uint8Array(17)); });
+        .catch(function() { return decrypt(x, new Uint8Array(17)); });
     }
 
-    crypto.subtle.importKey("raw", tv.aes_ctr_dec.key, "AES-CTR", false, ['decrypt'])
+    crypto.subtle.importKey("raw", tv.aes_ctr_dec.key, "AES-CTR", false, ["decrypt"])
       .then(doDecrypt)
       .then(
         error(that),
@@ -647,7 +647,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-GCM encryption",
-  function () {
+  function() {
     var that = this;
 
     function doEncrypt(x) {
@@ -656,12 +656,12 @@ TestArray.addTest(
           name: "AES-GCM",
           iv: tv.aes_gcm_enc.iv,
           additionalData: tv.aes_gcm_enc.adata,
-          tagLength: 128
+          tagLength: 128,
         },
         x, tv.aes_gcm_enc.data);
     }
 
-    crypto.subtle.importKey("raw", tv.aes_gcm_enc.key, "AES-GCM", false, ['encrypt'])
+    crypto.subtle.importKey("raw", tv.aes_gcm_enc.key, "AES-GCM", false, ["encrypt"])
       .then(doEncrypt)
       .then(
         memcmp_complete(that, tv.aes_gcm_enc.result),
@@ -673,7 +673,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-GCM decryption",
-  function () {
+  function() {
     var that = this;
 
     function doDecrypt(x) {
@@ -682,12 +682,12 @@ TestArray.addTest(
           name: "AES-GCM",
           iv: tv.aes_gcm_dec.iv,
           additionalData: tv.aes_gcm_dec.adata,
-          tagLength: 128
+          tagLength: 128,
         },
         x, tv.aes_gcm_dec.data);
     }
 
-    crypto.subtle.importKey("raw", tv.aes_gcm_dec.key, "AES-GCM", false, ['decrypt'])
+    crypto.subtle.importKey("raw", tv.aes_gcm_dec.key, "AES-GCM", false, ["decrypt"])
       .then(doDecrypt)
       .then(
         memcmp_complete(that, tv.aes_gcm_dec.result),
@@ -699,7 +699,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-GCM decryption, failing authentication check",
-  function () {
+  function() {
     var that = this;
 
     function doDecrypt(x) {
@@ -708,12 +708,12 @@ TestArray.addTest(
           name: "AES-GCM",
           iv: tv.aes_gcm_dec_fail.iv,
           additionalData: tv.aes_gcm_dec_fail.adata,
-          tagLength: 128
+          tagLength: 128,
         },
         x, tv.aes_gcm_dec_fail.data);
     }
 
-    crypto.subtle.importKey("raw", tv.aes_gcm_dec_fail.key, "AES-GCM", false, ['decrypt'])
+    crypto.subtle.importKey("raw", tv.aes_gcm_dec_fail.key, "AES-GCM", false, ["decrypt"])
       .then(doDecrypt)
       .then(
         error(that),
@@ -725,20 +725,20 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-GCM encryption, fail with a zero-length IV",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "AES-GCM",
       iv: new Uint8Array(),
       additionalData: tv.aes_gcm_enc.adata,
-      tagLength: 128
+      tagLength: 128,
     };
 
     function doEncrypt(x) {
       return crypto.subtle.encrypt(alg, x, tv.aes_gcm_enc.data);
     }
 
-    crypto.subtle.importKey("raw", tv.aes_gcm_enc.key, "AES-GCM", false, ['encrypt'])
+    crypto.subtle.importKey("raw", tv.aes_gcm_enc.key, "AES-GCM", false, ["encrypt"])
       .then(doEncrypt)
       .then(error(that), complete(that));
   }
@@ -747,20 +747,20 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-GCM encryption, accept an all-zero IV (1 byte)",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "AES-GCM",
       iv: new Uint8Array(1),
       additionalData: tv.aes_gcm_enc.adata,
-      tagLength: 128
+      tagLength: 128,
     };
 
     function doEncrypt(x) {
       return crypto.subtle.encrypt(alg, x, tv.aes_gcm_enc.data);
     }
 
-    crypto.subtle.importKey("raw", tv.aes_gcm_enc.key, "AES-GCM", false, ['encrypt'])
+    crypto.subtle.importKey("raw", tv.aes_gcm_enc.key, "AES-GCM", false, ["encrypt"])
       .then(doEncrypt)
       .then(complete(that), error(that));
   }
@@ -769,20 +769,20 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-GCM encryption, accept an all-zero IV (12 bytes)",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "AES-GCM",
       iv: new Uint8Array(12),
       additionalData: tv.aes_gcm_enc.adata,
-      tagLength: 128
+      tagLength: 128,
     };
 
     function doEncrypt(x) {
       return crypto.subtle.encrypt(alg, x, tv.aes_gcm_enc.data);
     }
 
-    crypto.subtle.importKey("raw", tv.aes_gcm_enc.key, "AES-GCM", false, ['encrypt'])
+    crypto.subtle.importKey("raw", tv.aes_gcm_enc.key, "AES-GCM", false, ["encrypt"])
       .then(doEncrypt)
       .then(complete(that), error(that));
   }
@@ -791,20 +791,20 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-GCM encryption, accept an all-zero IV (16 bytes)",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "AES-GCM",
       iv: new Uint8Array(16),
       additionalData: tv.aes_gcm_enc.adata,
-      tagLength: 128
+      tagLength: 128,
     };
 
     function doEncrypt(x) {
       return crypto.subtle.encrypt(alg, x, tv.aes_gcm_enc.data);
     }
 
-    crypto.subtle.importKey("raw", tv.aes_gcm_enc.key, "AES-GCM", false, ['encrypt'])
+    crypto.subtle.importKey("raw", tv.aes_gcm_enc.key, "AES-GCM", false, ["encrypt"])
       .then(doEncrypt)
       .then(complete(that), error(that));
   }
@@ -817,14 +817,14 @@ TestArray.addTest(
     var that = this;
     var alg = {
       name: "HMAC",
-      hash: "SHA-256"
-    }
+      hash: "SHA-256",
+    };
 
     function doSign(x) {
       return crypto.subtle.sign("HMAC", x, tv.hmac_sign.data);
     }
 
-    crypto.subtle.importKey("raw", tv.hmac_sign.key, alg, false, ['sign'])
+    crypto.subtle.importKey("raw", tv.hmac_sign.key, alg, false, ["sign"])
       .then(doSign)
       .then(
         memcmp_complete(that, tv.hmac_sign.result),
@@ -840,14 +840,14 @@ TestArray.addTest(
     var that = this;
     var alg = {
       name: "HMAC",
-      hash: "SHA-256"
-    }
+      hash: "SHA-256",
+    };
 
     function doVerify(x) {
       return crypto.subtle.verify("HMAC", x, tv.hmac_verify.sig, tv.hmac_verify.data);
     }
 
-    crypto.subtle.importKey("raw", tv.hmac_verify.key, alg, false, ['verify'])
+    crypto.subtle.importKey("raw", tv.hmac_verify.key, alg, false, ["verify"])
       .then(doVerify)
       .then(
         complete(that, function(x) { return !!x; }),
@@ -863,15 +863,15 @@ TestArray.addTest(
     var that = this;
     var alg = {
       name: "HMAC",
-      hash: "SHA-256"
-    }
+      hash: "SHA-256",
+    };
 
     function doVerify(x) {
       return crypto.subtle.verify("HMAC", x, tv.hmac_verify.sig_fail,
                                              tv.hmac_verify.data);
     }
 
-    crypto.subtle.importKey("raw", tv.hmac_verify.key, alg, false, ['verify'])
+    crypto.subtle.importKey("raw", tv.hmac_verify.key, alg, false, ["verify"])
       .then(doVerify)
       .then(
         complete(that, function(x) { return !x; }),
@@ -887,15 +887,15 @@ TestArray.addTest(
     var that = this;
     var alg = {
       name: "HMAC",
-      hash: "SHA-256"
-    }
+      hash: "SHA-256",
+    };
 
     function doVerify(x) {
       return crypto.subtle.verify("HMAC", x, tv.hmac_verify.sig,
                                              tv.hmac_verify.data);
     }
 
-    crypto.subtle.importKey("raw", tv.hmac_verify.key, alg, false, ['encrypt'])
+    crypto.subtle.importKey("raw", tv.hmac_verify.key, alg, false, ["encrypt"])
       .then(doVerify)
       .then(
         error(that),
@@ -907,7 +907,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSASSA/SHA-1 signature",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "RSASSA-PKCS1-v1_5", hash: "SHA-1" };
 
@@ -915,7 +915,7 @@ TestArray.addTest(
       return crypto.subtle.sign(alg.name, x, tv.rsassa.data);
     }
 
-    crypto.subtle.importKey("pkcs8", tv.rsassa.pkcs8, alg, false, ['sign'])
+    crypto.subtle.importKey("pkcs8", tv.rsassa.pkcs8, alg, false, ["sign"])
       .then( doSign )
       .then( memcmp_complete(that, tv.rsassa.sig1), error(that) );
   }
@@ -924,7 +924,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSASSA verification (SHA-1)",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "RSASSA-PKCS1-v1_5", hash: "SHA-1" };
 
@@ -932,7 +932,7 @@ TestArray.addTest(
       return crypto.subtle.verify(alg.name, x, tv.rsassa.sig1, tv.rsassa.data);
     }
 
-    crypto.subtle.importKey("spki", tv.rsassa.spki, alg, false, ['verify'])
+    crypto.subtle.importKey("spki", tv.rsassa.spki, alg, false, ["verify"])
       .then( doVerify )
       .then(
         complete(that, function(x) { return x; }),
@@ -944,7 +944,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSASSA verification (SHA-1), failing verification",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "RSASSA-PKCS1-v1_5", hash: "SHA-1" };
 
@@ -952,7 +952,7 @@ TestArray.addTest(
       return crypto.subtle.verify(alg.name, x, tv.rsassa.sig_fail, tv.rsassa.data);
     }
 
-    crypto.subtle.importKey("spki", tv.rsassa.spki, alg, false, ['verify'])
+    crypto.subtle.importKey("spki", tv.rsassa.spki, alg, false, ["verify"])
       .then( doVerify )
       .then(
         complete(that, function(x) { return !x; }),
@@ -964,7 +964,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSASSA/SHA-256 signature",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" };
 
@@ -972,7 +972,7 @@ TestArray.addTest(
       return crypto.subtle.sign(alg.name, x, tv.rsassa.data);
     }
 
-    crypto.subtle.importKey("pkcs8", tv.rsassa.pkcs8, alg, false, ['sign'])
+    crypto.subtle.importKey("pkcs8", tv.rsassa.pkcs8, alg, false, ["sign"])
       .then( doSign )
       .then( memcmp_complete(that, tv.rsassa.sig256), error(that) );
   }
@@ -981,7 +981,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSASSA verification (SHA-256)",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" };
 
@@ -989,7 +989,7 @@ TestArray.addTest(
       return crypto.subtle.verify(alg.name, x, tv.rsassa.sig256, tv.rsassa.data);
     }
 
-    crypto.subtle.importKey("spki", tv.rsassa.spki, alg, false, ['verify'])
+    crypto.subtle.importKey("spki", tv.rsassa.spki, alg, false, ["verify"])
       .then( doVerify )
       .then(
         complete(that, function(x) { return x; }),
@@ -1001,16 +1001,16 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSASSA verification (SHA-256), failing verification",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" };
-    var use = ['sign', 'verify'];
+    var use = ["sign", "verify"];
 
     function doVerify(x) {
       return crypto.subtle.verify(alg.name, x, tv.rsassa.sig_fail, tv.rsassa.data);
     }
 
-    crypto.subtle.importKey("spki", tv.rsassa.spki, alg, false, ['verify'])
+    crypto.subtle.importKey("spki", tv.rsassa.spki, alg, false, ["verify"])
       .then( doVerify )
       .then(
         complete(that, function(x) { return !x; }),
@@ -1026,7 +1026,7 @@ TestArray.addTest(
     var that = this;
 
     crypto.subtle.digest("SHA-256", tv.sha256.data)
-      .then(complete(that, function (x) {
+      .then(complete(that, function(x) {
         return x instanceof ArrayBuffer;
       }), error(that));
   }
@@ -1035,7 +1035,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Ensure that importing an invalid key doesn't crash",
-  function () {
+  function() {
     var that = this;
     // TODO Change the algorithm to "DH" once we support it.
     var alg = {name: "RSA-OAEP", hash: "SHA-1"};
@@ -1082,12 +1082,12 @@ TestArray.addTest(
       name: "RSA-PSS",
       hash: "SHA-1",
       modulusLength: 1024,
-      publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
     };
 
     function checkPrototypes(obj, type) {
       return obj.__proto__ != window[type].prototype &&
-             obj.__proto__ == frames[0][type].prototype
+             obj.__proto__ == frames[0][type].prototype;
     }
 
     var p1 = crypto.subtle.importKey.call(
@@ -1115,7 +1115,7 @@ TestArray.addTest(
     }), error(that));
   }
 );
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_DH.html b/dom/crypto/test/test_WebCrypto_DH.html
index 55d83e15ca13..d6bc48710c04 100644
--- a/dom/crypto/test/test_WebCrypto_DH.html
+++ b/dom/crypto/test/test_WebCrypto_DH.html
@@ -19,7 +19,7 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // -----------------------------------------------------------------------------
@@ -30,7 +30,7 @@ TestArray.addTest(
     var alg = {
       name: "DH",
       prime: tv.dh.prime,
-      generator: new Uint8Array([0x02])
+      generator: new Uint8Array([0x02]),
     };
     crypto.subtle.generateKey(alg, false, ["deriveKey", "deriveBits"]).then(
       complete(that, function(x) {
@@ -64,20 +64,20 @@ TestArray.addTest(
     var alg = {
       name: "DH",
       prime: tv.dh.prime,
-      generator: new Uint8Array([0x02])
+      generator: new Uint8Array([0x02]),
     };
 
     function doDerive(x) {
       var alg = {
         name: "DH",
-        public: x.publicKey
+        public: x.publicKey,
       };
       return crypto.subtle.deriveBits(alg, x.privateKey, 128);
     }
 
     crypto.subtle.generateKey(alg, false, ["deriveBits"])
       .then(doDerive, error(that))
-      .then(complete(that, function (x) {
+      .then(complete(that, function(x) {
         return x.byteLength == 16;
       }), error(that));
   }
@@ -96,7 +96,7 @@ TestArray.addTest(
       var alg = {
         name: "DH",
         prime: tv.dh.prime,
-        generator: new Uint8Array([0x02])
+        generator: new Uint8Array([0x02]),
       };
       return crypto.subtle.generateKey(alg, false, ["deriveBits"]);
     }
@@ -106,9 +106,9 @@ TestArray.addTest(
         name: "RSA-OAEP",
         hash: "SHA-256",
         modulusLength: 2048,
-        publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
       };
-      return crypto.subtle.generateKey(alg, false, ["encrypt"])
+      return crypto.subtle.generateKey(alg, false, ["encrypt"]);
     }
 
     function doDerive() {
@@ -138,7 +138,7 @@ TestArray.addTest(
       var alg = {
         name: "DH",
         prime: tv.dh.prime,
-        generator: new Uint8Array([0x02])
+        generator: new Uint8Array([0x02]),
       };
       return crypto.subtle.generateKey(alg, false, ["deriveBits"]);
     }
@@ -147,7 +147,7 @@ TestArray.addTest(
       var alg = {
         name: "DH",
         prime: tv.dh.prime2,
-        generator: new Uint8Array([0x02])
+        generator: new Uint8Array([0x02]),
       };
       return crypto.subtle.generateKey(alg, false, ["deriveBits"]);
     }
@@ -156,7 +156,7 @@ TestArray.addTest(
       var alg = {
         name: "DH",
         prime: tv.dh.prime,
-        generator: new Uint8Array([0x03])
+        generator: new Uint8Array([0x03]),
       };
       return crypto.subtle.generateKey(alg, false, ["deriveBits"]);
     }
@@ -181,12 +181,12 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Raw import/export of a public DH key",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "DH",
       prime: tv.dh_nist.prime,
-      generator: tv.dh_nist.gen
+      generator: tv.dh_nist.gen,
     };
 
     function doExport(x) {
@@ -207,7 +207,7 @@ TestArray.addTest(
     var alg = {
       name: "DH",
       prime: tv.dh_nist.prime,
-      generator: tv.dh_nist.gen
+      generator: tv.dh_nist.gen,
     };
 
     var privKey;
@@ -226,7 +226,7 @@ TestArray.addTest(
       .then(setPriv, error(that))
       .then(doImport, error(that))
       .then(doDerive, error(that))
-      .then(complete(that, function (x) {
+      .then(complete(that, function(x) {
         return x.byteLength == 16;
       }), error(that));
   }
@@ -247,7 +247,7 @@ TestArray.addTest(
       .then(memcmp_complete(that, tv.dh_nist.spki), error(that));
   }
 );
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_ECDH.html b/dom/crypto/test/test_WebCrypto_ECDH.html
index 671c7c693a1b..32fe28f27e52 100644
--- a/dom/crypto/test/test_WebCrypto_ECDH.html
+++ b/dom/crypto/test/test_WebCrypto_ECDH.html
@@ -19,7 +19,7 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // -----------------------------------------------------------------------------
@@ -61,16 +61,16 @@ TestArray.addTest(
     function setKeyPair(x) { pair = x; }
 
     function doDerive(n) {
-      return function (x) {
+      return function(x) {
         var alg = { name: "ECDH", public: pair.publicKey };
         return crypto.subtle.deriveBits(alg, pair.privateKey, n * 8);
-      }
+      };
     }
 
     crypto.subtle.generateKey(alg, false, ["deriveBits"])
       .then(setKeyPair, error(that))
       .then(doDerive(2), error(that))
-      .then(function (x) {
+      .then(function(x) {
         // Deriving less bytes works.
         if (x.byteLength != 2) {
           throw "should have derived two bytes";
@@ -101,9 +101,9 @@ TestArray.addTest(
         name: "RSA-OAEP",
         hash: "SHA-256",
         modulusLength: 2048,
-        publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
       };
-      return crypto.subtle.generateKey(alg, false, ["encrypt", "decrypt"])
+      return crypto.subtle.generateKey(alg, false, ["encrypt", "decrypt"]);
     }
 
     function doDerive() {
@@ -156,7 +156,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import an ECDH public and private key and derive bits (P-256)",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH" };
 
@@ -173,7 +173,7 @@ TestArray.addTest(
       crypto.subtle.importKey("jwk", tv.ecdh_p256.jwk_priv, alg, false, ["deriveBits"])
         .then(setPriv, error(that)),
       crypto.subtle.importKey("jwk", tv.ecdh_p256.jwk_pub, alg, false, ["deriveBits"])
-        .then(setPub, error(that))
+        .then(setPub, error(that)),
     ]).then(doDerive, error(that))
       .then(memcmp_complete(that, tv.ecdh_p256.secret), error(that));
   }
@@ -182,7 +182,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import an ECDH public and private key and derive bits (P-384)",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH" };
 
@@ -199,7 +199,7 @@ TestArray.addTest(
       crypto.subtle.importKey("jwk", tv.ecdh_p384.jwk_priv, alg, false, ["deriveBits"])
         .then(setPriv, error(that)),
       crypto.subtle.importKey("jwk", tv.ecdh_p384.jwk_pub, alg, false, ["deriveBits"])
-        .then(setPub, error(that))
+        .then(setPub, error(that)),
     ]).then(doDerive, error(that))
       .then(memcmp_complete(that, tv.ecdh_p384.secret), error(that));
   }
@@ -208,7 +208,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import an ECDH public and private key and derive bits (P-521)",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH" };
 
@@ -225,7 +225,7 @@ TestArray.addTest(
       crypto.subtle.importKey("jwk", tv.ecdh_p521.jwk_priv, alg, false, ["deriveBits"])
         .then(setPriv, error(that)),
       crypto.subtle.importKey("jwk", tv.ecdh_p521.jwk_pub, alg, false, ["deriveBits"])
-        .then(setPub, error(that))
+        .then(setPub, error(that)),
     ]).then(doDerive, error(that))
       .then(memcmp_complete(that, tv.ecdh_p521.secret), error(that));
   }
@@ -234,7 +234,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import/export roundtrip with ECDH (P-256)",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH" };
 
@@ -253,9 +253,9 @@ TestArray.addTest(
       crypto.subtle.importKey("jwk", tv.ecdh_p256.jwk_priv, alg, true, ["deriveBits"])
         .then(setPriv, error(that)),
       crypto.subtle.importKey("jwk", tv.ecdh_p256.jwk_pub, alg, true, ["deriveBits"])
-        .then(setPub, error(that))
+        .then(setPub, error(that)),
     ]).then(doExportPub, error(that))
-      .then(function (x) {
+      .then(function(x) {
         var tp = tv.ecdh_p256.jwk_pub;
         if ((tp.kty != x.kty) &&
             (tp.crv != x.crv) &&
@@ -265,7 +265,7 @@ TestArray.addTest(
         }
       }, error(that))
       .then(doExportPriv, error(that))
-      .then(complete(that, function (x) {
+      .then(complete(that, function(x) {
         var tp = tv.ecdh_p256.jwk_priv;
         return (tp.kty == x.kty) &&
                (tp.crv == x.crv) &&
@@ -279,15 +279,15 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Test that importing bad JWKs fails",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH" };
     var tvs = tv.ecdh_p256_negative;
 
     function doTryImport(jwk) {
-      return function () {
+      return function() {
         return crypto.subtle.importKey("jwk", jwk, alg, false, ["deriveBits"]);
-      }
+      };
     }
 
     doTryImport(tvs.jwk_bad_crv)()
@@ -301,13 +301,13 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK export of a newly generated ECDH private key",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH", namedCurve: "P-256" };
     var reBase64URL = /^[a-zA-Z0-9_-]+$/;
 
     function doExportToJWK(x) {
-      return crypto.subtle.exportKey("jwk", x.privateKey)
+      return crypto.subtle.exportKey("jwk", x.privateKey);
     }
 
     crypto.subtle.generateKey(alg, true, ["deriveKey", "deriveBits"])
@@ -315,14 +315,14 @@ TestArray.addTest(
       .then(
         complete(that, function(x) {
           return x.ext &&
-                 x.kty == 'EC' &&
-                 x.crv == 'P-256' &&
+                 x.kty == "EC" &&
+                 x.crv == "P-256" &&
                  reBase64URL.test(x.x) &&
                  reBase64URL.test(x.y) &&
                  reBase64URL.test(x.d) &&
                  x.x.length == 43 && // 32 octets, base64-encoded
                  x.y.length == 43 && // 32 octets, base64-encoded
-                 shallowArrayEquals(x.key_ops, ['deriveKey', 'deriveBits']);
+                 shallowArrayEquals(x.key_ops, ["deriveKey", "deriveBits"]);
           }),
         error(that)
       );
@@ -344,7 +344,7 @@ TestArray.addTest(
     function doDerive() {
       var alg = { name: "ECDH", public: pubKey };
       return crypto.subtle.deriveKey(alg, privKey, algDerived, false, ["sign", "verify"])
-        .then(function (x) {
+        .then(function(x) {
           if (!hasKeyFields(x)) {
             throw "Invalid key; missing field(s)";
           }
@@ -361,7 +361,7 @@ TestArray.addTest(
     function doSignAndVerify(x) {
       var data = crypto.getRandomValues(new Uint8Array(1024));
       return crypto.subtle.sign("HMAC", x, data)
-        .then(function (sig) {
+        .then(function(sig) {
           return crypto.subtle.verify("HMAC", x, sig, data);
         });
     }
@@ -370,7 +370,7 @@ TestArray.addTest(
       crypto.subtle.importKey("jwk", tv.ecdh_p521.jwk_priv, alg, false, ["deriveKey"])
         .then(setPriv),
       crypto.subtle.importKey("jwk", tv.ecdh_p521.jwk_pub, alg, false, ["deriveKey"])
-        .then(setPub)
+        .then(setPub),
     ]).then(doDerive)
       .then(doSignAndVerify)
       .then(complete(that, x => x), error(that));
@@ -380,7 +380,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "SPKI import/export of public ECDH keys (P-256)",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH" };
     var keys = ["spki", "spki_id_ecpk"];
@@ -398,7 +398,7 @@ TestArray.addTest(
       var imported = doImport(key);
       var derived = imported.then(doExport);
 
-      return derived.then(function (x) {
+      return derived.then(function(x) {
         if (!util.memcmp(x, tv.ecdh_p256.spki)) {
           throw "exported key is invalid";
         }
@@ -416,7 +416,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "SPKI/JWK import ECDH keys (P-256) and derive a known secret",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH" };
 
@@ -433,7 +433,7 @@ TestArray.addTest(
       crypto.subtle.importKey("spki", tv.ecdh_p256.spki, alg, false, ["deriveBits"])
         .then(setPub),
       crypto.subtle.importKey("jwk", tv.ecdh_p256.jwk_priv, alg, false, ["deriveBits"])
-        .then(setPriv)
+        .then(setPriv),
     ]).then(doDerive)
       .then(memcmp_complete(that, tv.ecdh_p256.secret), error(that));
   }
@@ -442,7 +442,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Raw import/export of a public ECDH key (P-256)",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH", namedCurve: "P-256" };
 
@@ -459,7 +459,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Test that importing bad raw ECDH keys fails",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH", namedCurve: "P-256" };
     var tvs = tv.ecdh_p256_negative.raw_bad;
@@ -472,7 +472,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Test that importing ECDH keys with an unknown format fails",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH", namedCurve: "P-256" };
     var tvs = tv.ecdh_p256.raw;
@@ -485,7 +485,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Test that importing too short raw ECDH keys fails",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH", namedCurve: "P-256" };
     var tvs = tv.ecdh_p256_negative.raw_short;
@@ -498,7 +498,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Test that importing too long raw ECDH keys fails",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH", namedCurve: "P-256" };
     var tvs = tv.ecdh_p256_negative.raw_long;
@@ -511,7 +511,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Test that importing compressed raw ECDH keys fails",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH", namedCurve: "P-256" };
     var tvs = tv.ecdh_p256_negative.raw_compressed;
@@ -524,7 +524,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RAW/JWK import ECDH keys (P-256) and derive a known secret",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDH", namedCurve: "P-256" };
 
@@ -541,12 +541,12 @@ TestArray.addTest(
       crypto.subtle.importKey("raw", tv.ecdh_p256.raw, alg, false, ["deriveBits"])
         .then(setPub),
       crypto.subtle.importKey("jwk", tv.ecdh_p256.jwk_priv, alg, false, ["deriveBits"])
-        .then(setPriv)
+        .then(setPriv),
     ]).then(doDerive)
       .then(memcmp_complete(that, tv.ecdh_p256.secret), error(that));
   }
 );
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_ECDSA.html b/dom/crypto/test/test_WebCrypto_ECDSA.html
index bc9bf1a3f7c5..f4ff95bcf400 100644
--- a/dom/crypto/test/test_WebCrypto_ECDSA.html
+++ b/dom/crypto/test/test_WebCrypto_ECDSA.html
@@ -19,7 +19,7 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // -----------------------------------------------------------------------------
@@ -43,7 +43,7 @@ TestArray.addTest(
                (x.privateKey.type == "private") &&
                !x.privateKey.extractable &&
                (x.privateKey.usages.length == 1) &&
-               (x.privateKey.usages[0] == "sign")
+               (x.privateKey.usages[0] == "sign");
       }),
       error(that)
     );
@@ -63,7 +63,7 @@ TestArray.addTest(
 
     crypto.subtle.importKey("jwk", tv.ecdsa_verify.pub_jwk, alg, true, ["verify"])
       .then(doVerify)
-      .then(complete(that, x => x), error(that))
+      .then(complete(that, x => x), error(that));
   }
 );
 
@@ -79,10 +79,10 @@ TestArray.addTest(
       .then(pair => Promise.all([
           crypto.subtle.sign(alg, pair.privateKey, msg),
           crypto.subtle.exportKey("spki", pair.publicKey)
-            .then(spki => crypto.subtle.importKey("spki", spki, alg, false, ["verify"]))
+            .then(spki => crypto.subtle.importKey("spki", spki, alg, false, ["verify"])),
       ]))
       .then(sigAndKey => crypto.subtle.verify(alg, sigAndKey[1], sigAndKey[0], msg))
-      .then(complete(that, x => x), error(that))
+      .then(complete(that, x => x), error(that));
   }
 );
 
@@ -100,7 +100,7 @@ TestArray.addTest(
 
     crypto.subtle.importKey("jwk", tv.ecdsa_verify.pub_jwk, alg, true, ["verify"])
       .then(doVerify)
-      .then(complete(that, x => !x), error(that))
+      .then(complete(that, x => !x), error(that));
   }
 );
 
@@ -124,7 +124,7 @@ TestArray.addTest(
     crypto.subtle.generateKey(alg, true, ["sign", "verify"])
       .then(doSign)
       .then(doVerify)
-      .then(complete(that, x => x), error(that))
+      .then(complete(that, x => x), error(that));
   }
 );
 
@@ -140,14 +140,14 @@ TestArray.addTest(
     }
 
     crypto.subtle.importKey("jwk", tv.ecdsa_bad.pub_jwk, alg, true, ["verify"])
-      .then(error(that), complete(that))
+      .then(error(that), complete(that));
   }
 );
 
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Raw import/export of a public ECDSA key (P-521)",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "ECDSA", namedCurve: "P-521", hash: "SHA-512" };
 
@@ -174,11 +174,11 @@ TestArray.addTest(
 
     crypto.subtle.importKey("raw", tv.ecdsa_verify.raw, alg, true, ["verify"])
       .then(doVerify)
-      .then(complete(that, x => x), error(that))
+      .then(complete(that, x => x), error(that));
   }
 );
 
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_HKDF.html b/dom/crypto/test/test_WebCrypto_HKDF.html
index dcc871ffad21..e9ae9a4b37ba 100644
--- a/dom/crypto/test/test_WebCrypto_HKDF.html
+++ b/dom/crypto/test/test_WebCrypto_HKDF.html
@@ -19,7 +19,7 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // -----------------------------------------------------------------------------
@@ -33,7 +33,7 @@ TestArray.addTest(
       name: "HKDF",
       hash: "SHA-256",
       salt: new Uint8Array(),
-      info: new Uint8Array()
+      info: new Uint8Array(),
     };
 
     crypto.subtle.importKey("raw", key, "HKDF", false, ["deriveBits"])
@@ -53,7 +53,7 @@ TestArray.addTest(
       name: "HKDF",
       hash: "SHA-256",
       salt: new Uint8Array(),
-      info: new Uint8Array()
+      info: new Uint8Array(),
     };
 
     crypto.subtle.importKey("raw", key, "HKDF", false, ["deriveBits"])
@@ -75,7 +75,7 @@ TestArray.addTest(
       name: "HKDF",
       hash: "SHA-256",
       salt: new Uint8Array(),
-      info: new Uint8Array()
+      info: new Uint8Array(),
     };
 
     function deriveBits(x) {
@@ -103,7 +103,7 @@ TestArray.addTest(
       name: "HKDF",
       hash: "HMAC",
       salt: new Uint8Array(),
-      info: new Uint8Array()
+      info: new Uint8Array(),
     };
 
     function deriveBits(x) {
@@ -126,7 +126,7 @@ TestArray.addTest(
       name: "HKDF",
       hash: "HMAC",
       salt: new Uint8Array(),
-      info: new Uint8Array()
+      info: new Uint8Array(),
     };
 
     function deriveBits(x) {
@@ -156,15 +156,15 @@ TestArray.addTest(
       var {key, data} = test;
 
       return crypto.subtle.importKey("raw", key, "HKDF", false, ["deriveBits"])
-        .then(function (key) {
+        .then(function(key) {
           return crypto.subtle.deriveBits({
             name: "HKDF",
             hash: test.prf,
             salt: test.salt,
-            info: test.info
+            info: test.info,
           }, key, test.data.byteLength * 8);
         })
-        .then(function (data) {
+        .then(function(data) {
           if (!util.memcmp(data, test.data)) {
             throw new Error("derived bits don't match expected value");
           }
@@ -188,7 +188,7 @@ TestArray.addTest(
       name: "HKDF",
       hash: test.prf,
       salt: test.salt,
-      info: test.info
+      info: test.info,
     };
 
     crypto.subtle.importKey("jwk", test.jwk, "HKDF", false, ["deriveBits"])
@@ -219,7 +219,7 @@ TestArray.addTest(
             name: "HKDF",
             hash: "SHA-256",
             salt: new Uint8Array(),
-            info: new Uint8Array()
+            info: new Uint8Array(),
           }, rawKey, 4);
         })
         .then(derivedBits => {
@@ -276,7 +276,7 @@ TestArray.addTest(
       name: "HKDF",
       hash: "SHA-256",
       salt: new Uint8Array(),
-      info: new Uint8Array()
+      info: new Uint8Array(),
     };
 
     function deriveKey(x) {
@@ -286,7 +286,7 @@ TestArray.addTest(
 
     crypto.subtle.importKey("raw", key, "HKDF", false, ["deriveKey"])
       .then(deriveKey)
-      .then(complete(that), error(that))
+      .then(complete(that), error(that));
   }
 );
 
@@ -301,7 +301,7 @@ TestArray.addTest(
       name: "HKDF",
       hash: "SHA-256",
       salt: new Uint8Array(),
-      info: new Uint8Array()
+      info: new Uint8Array(),
     };
 
     function deriveKey(x) {
@@ -310,11 +310,11 @@ TestArray.addTest(
 
     crypto.subtle.importKey("raw", key, "HKDF", false, ["deriveKey"])
       .then(deriveKey)
-      .then(error(that), complete(that))
+      .then(error(that), complete(that));
   }
 );
 
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_Import_Multiple_Identical_Keys.html b/dom/crypto/test/test_WebCrypto_Import_Multiple_Identical_Keys.html
index 6913bb78e34b..22c198d62a3c 100644
--- a/dom/crypto/test/test_WebCrypto_Import_Multiple_Identical_Keys.html
+++ b/dom/crypto/test/test_WebCrypto_Import_Multiple_Identical_Keys.html
@@ -10,13 +10,13 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Import the same ECDSA key multiple times and ensure that it can be used.",
-  function () {
+  function() {
     var alg = { name: "ECDSA", namedCurve: "P-256", hash: "SHA-256" };
     crypto.subtle.generateKey(alg, true, ["sign", "verify"])
     .then(function(keyPair) {
@@ -50,12 +50,12 @@ TestArray.addTest(
 // means we can't factor out common code here.
 TestArray.addTest(
   "Import the same RSA key multiple times and ensure that it can be used.",
-  function () {
+  function() {
     var alg = {
       name: "RSASSA-PKCS1-v1_5",
       modulusLength: 2048,
       publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-      hash: "SHA-256"
+      hash: "SHA-256",
     };
     crypto.subtle.generateKey(alg, true, ["sign", "verify"])
     .then(function(keyPair) {
@@ -82,7 +82,7 @@ TestArray.addTest(
     }), error(this));
   }
 );
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_JWK.html b/dom/crypto/test/test_WebCrypto_JWK.html
index f9916f5f2dce..6e83a73d8d59 100644
--- a/dom/crypto/test/test_WebCrypto_JWK.html
+++ b/dom/crypto/test/test_WebCrypto_JWK.html
@@ -19,13 +19,13 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import and use of an AES-GCM key",
-  function () {
+  function() {
     var that = this;
 
     function doEncrypt(x) {
@@ -34,12 +34,12 @@ TestArray.addTest(
           name: "AES-GCM",
           iv: tv.aes_gcm_enc.iv,
           additionalData: tv.aes_gcm_enc.adata,
-          tagLength: 128
+          tagLength: 128,
         },
         x, tv.aes_gcm_enc.data);
     }
 
-    crypto.subtle.importKey("jwk", tv.aes_gcm_enc.key_jwk, "AES-GCM", false, ['encrypt'])
+    crypto.subtle.importKey("jwk", tv.aes_gcm_enc.key_jwk, "AES-GCM", false, ["encrypt"])
       .then(doEncrypt)
       .then(
         memcmp_complete(that, tv.aes_gcm_enc.result),
@@ -51,7 +51,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import and use of an RSASSA-PKCS1-v1_5 private key",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" };
 
@@ -60,7 +60,7 @@ TestArray.addTest(
     }
     function fail(x) { console.log(x); error(that); }
 
-    crypto.subtle.importKey("jwk", tv.rsassa.jwk_priv, alg, false, ['sign'])
+    crypto.subtle.importKey("jwk", tv.rsassa.jwk_priv, alg, false, ["sign"])
       .then( doSign, fail )
       .then( memcmp_complete(that, tv.rsassa.sig256), fail );
   }
@@ -69,7 +69,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import and use of an RSASSA-PKCS1-v1_5 public key",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" };
 
@@ -78,7 +78,7 @@ TestArray.addTest(
     }
     function fail(x) { error(that); }
 
-    crypto.subtle.importKey("jwk", tv.rsassa.jwk_pub, alg, false, ['verify'])
+    crypto.subtle.importKey("jwk", tv.rsassa.jwk_pub, alg, false, ["verify"])
       .then( doVerify, fail )
       .then(
         complete(that, function(x) { return x; }),
@@ -89,7 +89,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import failure on incomplete RSA private key (missing 'qi')",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "RSA-OAEP", hash: "SHA-256" };
     var jwk = {
@@ -103,7 +103,7 @@ TestArray.addTest(
       dq: tv.rsassa.jwk_priv.dq,
     };
 
-    crypto.subtle.importKey("jwk", jwk, alg, true, ['encrypt', 'decrypt'])
+    crypto.subtle.importKey("jwk", jwk, alg, true, ["encrypt", "decrypt"])
       .then( error(that), complete(that) );
   }
 );
@@ -111,12 +111,12 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import failure on algorithm mismatch",
-  function () {
+  function() {
     var that = this;
     var alg = "AES-GCM";
     var jwk = { k: "c2l4dGVlbiBieXRlIGtleQ", alg: "A256GCM" };
 
-    crypto.subtle.importKey("jwk", jwk, alg, true, ['encrypt', 'decrypt'])
+    crypto.subtle.importKey("jwk", jwk, alg, true, ["encrypt", "decrypt"])
       .then( error(that), complete(that) );
   }
 );
@@ -124,12 +124,12 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import failure on usages mismatch",
-  function () {
+  function() {
     var that = this;
     var alg = "AES-GCM";
-    var jwk = { k: "c2l4dGVlbiBieXRlIGtleQ", key_ops: ['encrypt'] };
+    var jwk = { k: "c2l4dGVlbiBieXRlIGtleQ", key_ops: ["encrypt"] };
 
-    crypto.subtle.importKey("jwk", jwk, alg, true, ['encrypt', 'decrypt'])
+    crypto.subtle.importKey("jwk", jwk, alg, true, ["encrypt", "decrypt"])
       .then( error(that), complete(that) );
   }
 );
@@ -137,12 +137,12 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import failure on extractable mismatch",
-  function () {
+  function() {
     var that = this;
     var alg = "AES-GCM";
     var jwk = { k: "c2l4dGVlbiBieXRlIGtleQ", ext: false };
 
-    crypto.subtle.importKey("jwk", jwk, alg, true, ['encrypt'])
+    crypto.subtle.importKey("jwk", jwk, alg, true, ["encrypt"])
       .then( error(that), complete(that) );
   }
 );
@@ -150,7 +150,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK export of a symmetric key",
-  function () {
+  function() {
     var that = this;
     var alg = "AES-GCM";
     var jwk = { k: "c2l4dGVlbiBieXRlIGtleQ", kty: "oct" };
@@ -159,17 +159,17 @@ TestArray.addTest(
       return crypto.subtle.exportKey("jwk", k);
     }
 
-    crypto.subtle.importKey("jwk", jwk, alg, true, ['encrypt', 'decrypt'])
+    crypto.subtle.importKey("jwk", jwk, alg, true, ["encrypt", "decrypt"])
       .then(doExport)
       .then(
         complete(that, function(x) {
           return hasBaseJwkFields(x) &&
-                 hasFields(x, ['k']) &&
-                 x.kty == 'oct' &&
-                 x.alg == 'A128GCM' &&
+                 hasFields(x, ["k"]) &&
+                 x.kty == "oct" &&
+                 x.alg == "A128GCM" &&
                  x.ext &&
-                 shallowArrayEquals(x.key_ops, ['encrypt','decrypt']) &&
-                 x.k == jwk.k
+                 shallowArrayEquals(x.key_ops, ["encrypt", "decrypt"]) &&
+                 x.k == jwk.k;
         }),
         error(that)
       );
@@ -179,7 +179,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import/export of an RSA private key",
-  function () {
+  function() {
     var jwk = tv.rsassa.jwk_priv;
 
     var that = this;
@@ -189,21 +189,21 @@ TestArray.addTest(
       return crypto.subtle.exportKey("jwk", k);
     }
 
-    crypto.subtle.importKey("jwk", jwk, alg, true, ['sign'])
+    crypto.subtle.importKey("jwk", jwk, alg, true, ["sign"])
       .then(doExport)
       .then(
         complete(that, function(x) {
           return hasBaseJwkFields(x) &&
-                 hasFields(x, ['n', 'e', 'd', 'p', 'q', 'dp', 'dq', 'qi']) &&
-                 x.kty == 'RSA' &&
-                 x.alg == 'RS256' &&
+                 hasFields(x, ["n", "e", "d", "p", "q", "dp", "dq", "qi"]) &&
+                 x.kty == "RSA" &&
+                 x.alg == "RS256" &&
                  x.ext &&
-                 shallowArrayEquals(x.key_ops, ['sign']) &&
-                 x.n  == jwk.n  &&
-                 x.e  == jwk.e  &&
-                 x.d  == jwk.d  &&
-                 x.p  == jwk.p  &&
-                 x.q  == jwk.q  &&
+                 shallowArrayEquals(x.key_ops, ["sign"]) &&
+                 x.n == jwk.n &&
+                 x.e == jwk.e &&
+                 x.d == jwk.d &&
+                 x.p == jwk.p &&
+                 x.q == jwk.q &&
                  x.dp == jwk.dp &&
                  x.dq == jwk.dq &&
                  x.qi == jwk.qi;
@@ -216,7 +216,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK import/export of an RSA private key where p < q",
-  function () {
+  function() {
     var jwk = tv.rsassa.jwk_priv_pLTq;
 
     var that = this;
@@ -226,21 +226,21 @@ TestArray.addTest(
       return crypto.subtle.exportKey("jwk", k);
     }
 
-    crypto.subtle.importKey("jwk", jwk, alg, true, ['sign'])
+    crypto.subtle.importKey("jwk", jwk, alg, true, ["sign"])
       .then(doExport)
       .then(
         complete(that, function(x) {
           return hasBaseJwkFields(x) &&
-                 hasFields(x, ['n', 'e', 'd', 'p', 'q', 'dp', 'dq', 'qi']) &&
-                 x.kty == 'RSA' &&
-                 x.alg == 'RS256' &&
+                 hasFields(x, ["n", "e", "d", "p", "q", "dp", "dq", "qi"]) &&
+                 x.kty == "RSA" &&
+                 x.alg == "RS256" &&
                  x.ext &&
-                 shallowArrayEquals(x.key_ops, ['sign']) &&
-                 x.n  == jwk.n  &&
-                 x.e  == jwk.e  &&
-                 x.d  == jwk.d  &&
-                 x.p  == jwk.p  &&
-                 x.q  == jwk.q  &&
+                 shallowArrayEquals(x.key_ops, ["sign"]) &&
+                 x.n == jwk.n &&
+                 x.e == jwk.e &&
+                 x.d == jwk.d &&
+                 x.p == jwk.p &&
+                 x.q == jwk.q &&
                  x.dp == jwk.dp &&
                  x.dq == jwk.dq &&
                  x.qi == jwk.qi;
@@ -253,7 +253,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK export of an RSA public key",
-  function () {
+  function() {
     var that = this;
     var alg = { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" };
     var jwk = tv.rsassa.jwk_pub;
@@ -262,19 +262,19 @@ TestArray.addTest(
       return crypto.subtle.exportKey("jwk", k);
     }
 
-    crypto.subtle.importKey("jwk", jwk, alg, true, ['verify'])
+    crypto.subtle.importKey("jwk", jwk, alg, true, ["verify"])
       .then(doExport)
       .then(
         complete(that, function(x) {
           window.jwk_pub = x;
           return hasBaseJwkFields(x) &&
-                 hasFields(x, ['n', 'e']) &&
-                 x.kty == 'RSA' &&
-                 x.alg == 'RS256' &&
+                 hasFields(x, ["n", "e"]) &&
+                 x.kty == "RSA" &&
+                 x.alg == "RS256" &&
                  x.ext &&
-                 shallowArrayEquals(x.key_ops, ['verify']) &&
-                 x.n  == jwk.n  &&
-                 x.e  == jwk.e;
+                 shallowArrayEquals(x.key_ops, ["verify"]) &&
+                 x.n == jwk.n &&
+                 x.e == jwk.e;
           }),
         error(that)
       );
@@ -285,30 +285,30 @@ TestArray.addTest(
 TestArray.addTest(
   "Check JWK parameters on generated ECDSA key pair",
   function() {
-    crypto.subtle.generateKey({name: 'ECDSA', namedCurve: 'P-256'}, true, ['sign', 'verify'])
+    crypto.subtle.generateKey({name: "ECDSA", namedCurve: "P-256"}, true, ["sign", "verify"])
       .then(pair => Promise.all([
-         crypto.subtle.exportKey('jwk', pair.privateKey),
-         crypto.subtle.exportKey('jwk', pair.publicKey)
+         crypto.subtle.exportKey("jwk", pair.privateKey),
+         crypto.subtle.exportKey("jwk", pair.publicKey),
       ]))
       .then(
         complete(this, function(x) {
           var priv = x[0];
           var pub = x[1];
           var pubIsSubsetOfPriv = Object.keys(pub)
-            .filter(k => k !== 'key_ops') // key_ops is the only complex attr
+            .filter(k => k !== "key_ops") // key_ops is the only complex attr
             .reduce((all, k) => all && pub[k] === priv[k], true);
           // Can't use hasBaseJwkFields() because EC keys don't get "alg":
           // "alg" matches curve to hash, but WebCrypto keys are more flexible.
-          return hasFields(pub, ['kty', 'crv', 'key_ops', 'ext']) &&
-            pub.kty === 'EC' &&
-            pub.crv === 'P-256' &&
+          return hasFields(pub, ["kty", "crv", "key_ops", "ext"]) &&
+            pub.kty === "EC" &&
+            pub.crv === "P-256" &&
             pub.ext &&
-            typeof(pub.x) === 'string' &&
-            typeof(pub.y) === 'string' &&
-            shallowArrayEquals(pub.key_ops, ['verify']) &&
+            typeof(pub.x) === "string" &&
+            typeof(pub.y) === "string" &&
+            shallowArrayEquals(pub.key_ops, ["verify"]) &&
             pubIsSubsetOfPriv &&
-            shallowArrayEquals(priv.key_ops, ['sign']) &&
-            typeof(priv.d) === 'string';
+            shallowArrayEquals(priv.key_ops, ["sign"]) &&
+            typeof(priv.d) === "string";
         }),
         error(this));
   }
@@ -319,20 +319,20 @@ TestArray.addTest(
   "Check key_ops parameter on an unusable RSA public key",
   function() {
     var parameters = {
-      name: 'RSASSA-PKCS1-v1_5',
+      name: "RSASSA-PKCS1-v1_5",
       modulusLength: 1024,
       publicExponent: new Uint8Array([1, 0, 1]),
-      hash: 'SHA-256'
+      hash: "SHA-256",
     };
     // The public key generated here will have no usages and will therefore
     // have an empty key_ops list.
-    crypto.subtle.generateKey(parameters, true, ['sign'])
-      .then(pair => crypto.subtle.exportKey('jwk', pair.publicKey))
+    crypto.subtle.generateKey(parameters, true, ["sign"])
+      .then(pair => crypto.subtle.exportKey("jwk", pair.publicKey))
       .then(complete(this, x => x.key_ops.length === 0),
             error(this));
   }
 );
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_Normalize.html b/dom/crypto/test/test_WebCrypto_Normalize.html
index f293c09808c5..eb5c7d071311 100644
--- a/dom/crypto/test/test_WebCrypto_Normalize.html
+++ b/dom/crypto/test/test_WebCrypto_Normalize.html
@@ -19,7 +19,7 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 TestArray.addTest(
@@ -38,7 +38,7 @@ TestArray.addTest(
         name: "rsa-OAEP",
         hash: "sha-1",
         modulusLength: 2048,
-        publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
       };
       return crypto.subtle.generateKey(alg, false, ["encrypt", "decrypt"]);
     }
@@ -56,7 +56,7 @@ TestArray.addTest(
   }
 );
 
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_PBKDF2.html b/dom/crypto/test/test_WebCrypto_PBKDF2.html
index 0e3cdd088b65..6e7823d82691 100644
--- a/dom/crypto/test/test_WebCrypto_PBKDF2.html
+++ b/dom/crypto/test/test_WebCrypto_PBKDF2.html
@@ -19,7 +19,7 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // -----------------------------------------------------------------------------
@@ -80,7 +80,7 @@ TestArray.addTest(
         name: "PBKDF2",
         hash: "SHA-1",
         salt: tv.pbkdf2_sha1.salt,
-        iterations: tv.pbkdf2_sha1.iterations
+        iterations: tv.pbkdf2_sha1.iterations,
       };
       return crypto.subtle.deriveBits(alg, x, tv.pbkdf2_sha1.length);
     }
@@ -108,7 +108,7 @@ TestArray.addTest(
         name: "PBKDF2",
         hash: "SHA-1",
         salt: tv.pbkdf2_sha1.salt,
-        iterations: tv.pbkdf2_sha1.iterations
+        iterations: tv.pbkdf2_sha1.iterations,
       };
       return crypto.subtle.deriveBits(alg, x, tv.pbkdf2_sha1.length);
     }
@@ -137,16 +137,16 @@ TestArray.addTest(
         name: "PBKDF2",
         hash: "SHA-1",
         salt: tv.pbkdf2_sha1.salt,
-        iterations: tv.pbkdf2_sha1.iterations
+        iterations: tv.pbkdf2_sha1.iterations,
       };
 
       var algDerived = {
         name: "HMAC",
-        hash: {name: "SHA-1"}
+        hash: {name: "SHA-1"},
       };
 
       return crypto.subtle.deriveKey(alg, x, algDerived, false, ["sign", "verify"])
-        .then(function (x) {
+        .then(function(x) {
           if (!hasKeyFields(x)) {
             throw "Invalid key; missing field(s)";
           }
@@ -163,7 +163,7 @@ TestArray.addTest(
       var data = new Uint8Array(1024);
 
       return crypto.subtle.sign("HMAC", x, data)
-        .then(function (sig) {
+        .then(function(sig) {
           return crypto.subtle.verify("HMAC", x, sig, data);
         });
     }
@@ -188,7 +188,7 @@ TestArray.addTest(
         name: "PBKDF2",
         hash: "SHA-1",
         salt: tv.pbkdf2_sha1.salt,
-        iterations: tv.pbkdf2_sha1.iterations
+        iterations: tv.pbkdf2_sha1.iterations,
       };
 
       var algDerived = {name: "HMAC", hash: "SHA-1", length: 128};
@@ -198,7 +198,7 @@ TestArray.addTest(
     var password = crypto.getRandomValues(new Uint8Array(8));
     crypto.subtle.importKey("raw", password, "PBKDF2", false, ["deriveKey"])
       .then(doDerive)
-      .then(complete(that, function (x) {
+      .then(complete(that, function(x) {
         return hasKeyFields(x) && x.algorithm.length == 128;
       }), error(that));
   }
@@ -221,7 +221,7 @@ TestArray.addTest(
         name: "PBKDF2",
         hash: "SHA-256",
         salt: tv.pbkdf2_sha256.salt,
-        iterations: tv.pbkdf2_sha256.iterations
+        iterations: tv.pbkdf2_sha256.iterations,
       };
       return crypto.subtle.deriveBits(alg, x, tv.pbkdf2_sha256.length);
     }
@@ -250,7 +250,7 @@ TestArray.addTest(
         name: "PBKDF2",
         hash: "SHA-256",
         salt: tv.pbkdf2_sha256_no_pwd.salt,
-        iterations: tv.pbkdf2_sha256_no_pwd.iterations
+        iterations: tv.pbkdf2_sha256_no_pwd.iterations,
       };
       return crypto.subtle.deriveBits(alg, x, tv.pbkdf2_sha256_no_pwd.length);
     }
@@ -279,7 +279,7 @@ TestArray.addTest(
         name: "PBKDF2",
         hash: "SHA-256",
         salt: new Uint8Array(0),
-        iterations: tv.pbkdf2_sha256_no_salt.iterations
+        iterations: tv.pbkdf2_sha256_no_salt.iterations,
       };
       return crypto.subtle.deriveBits(deriveAlg, x, tv.pbkdf2_sha256_no_salt.length);
     }
@@ -290,7 +290,7 @@ TestArray.addTest(
       .then( memcmp_complete(that, tv.pbkdf2_sha256_no_salt.derived), fail );
   }
 );
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_RSA_OAEP.html b/dom/crypto/test/test_WebCrypto_RSA_OAEP.html
index d2a49caf2c91..e54694ac69b0 100644
--- a/dom/crypto/test/test_WebCrypto_RSA_OAEP.html
+++ b/dom/crypto/test/test_WebCrypto_RSA_OAEP.html
@@ -19,7 +19,7 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // Generating 2048-bit keys takes some time.
@@ -28,7 +28,7 @@ SimpleTest.requestLongerTimeout(2);
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-OAEP encrypt/decrypt round-trip",
-  function () {
+  function() {
     var that = this;
     var privKey, pubKey;
     var alg = {name: "RSA-OAEP", hash: "SHA-1"};
@@ -44,10 +44,10 @@ TestArray.addTest(
     }
 
     Promise.all([
-      crypto.subtle.importKey("pkcs8", tv.rsaoaep.pkcs8, alg, false, ['decrypt'])
+      crypto.subtle.importKey("pkcs8", tv.rsaoaep.pkcs8, alg, false, ["decrypt"])
           .then(setPriv, error(that)),
-      crypto.subtle.importKey("spki", tv.rsaoaep.spki, alg, false, ['encrypt'])
-          .then(setPub, error(that))
+      crypto.subtle.importKey("spki", tv.rsaoaep.spki, alg, false, ["encrypt"])
+          .then(setPub, error(that)),
     ]).then(doEncrypt, error(that))
       .then(doDecrypt, error(that))
       .then(
@@ -60,13 +60,13 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-OAEP key generation and encrypt/decrypt round-trip (SHA-256)",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "RSA-OAEP",
       hash: "SHA-256",
       modulusLength: 2048,
-      publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
     };
 
     var privKey, pubKey, data = crypto.getRandomValues(new Uint8Array(128));
@@ -78,7 +78,7 @@ TestArray.addTest(
       return crypto.subtle.decrypt(alg, privKey, x);
     }
 
-    crypto.subtle.generateKey(alg, false, ['encrypt', 'decrypt'])
+    crypto.subtle.generateKey(alg, false, ["encrypt", "decrypt"])
       .then(setKey, error(that))
       .then(doEncrypt, error(that))
       .then(doDecrypt, error(that))
@@ -92,7 +92,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-OAEP decryption known answer",
-  function () {
+  function() {
     var that = this;
     var alg = {name: "RSA-OAEP", hash: "SHA-1"};
 
@@ -101,7 +101,7 @@ TestArray.addTest(
     }
     function fail() { error(that); }
 
-    crypto.subtle.importKey("pkcs8", tv.rsaoaep.pkcs8, alg, false, ['decrypt'])
+    crypto.subtle.importKey("pkcs8", tv.rsaoaep.pkcs8, alg, false, ["decrypt"])
       .then( doDecrypt, fail )
       .then( memcmp_complete(that, tv.rsaoaep.data), fail );
   }
@@ -110,26 +110,26 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-OAEP input data length checks (2048-bit key)",
-  function () {
+  function() {
     var that = this;
     var privKey, pubKey;
     var alg = {
       name: "RSA-OAEP",
       hash: "SHA-1",
       modulusLength: 2048,
-      publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
     };
 
     var privKey, pubKey;
     function setKey(x) { pubKey = x.publicKey; privKey = x.privateKey; }
     function doEncrypt(n) {
-      console.log("entered encrypt("+ n +")");
-      return function () {
+      console.log("entered encrypt(" + n + ")");
+      return function() {
         return crypto.subtle.encrypt(alg, pubKey, new Uint8Array(n));
-      }
+      };
     }
 
-    crypto.subtle.generateKey(alg, false, ['encrypt', 'decrypt'])
+    crypto.subtle.generateKey(alg, false, ["encrypt", "decrypt"])
       .then(setKey, error(that))
       .then(doEncrypt(214), error(that))
       .then(doEncrypt(215), error(that))
@@ -140,11 +140,11 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-OAEP key import with invalid hash",
-  function () {
+  function() {
     var that = this;
     var alg = {name: "RSA-OAEP", hash: "SHA-123"};
 
-    crypto.subtle.importKey("pkcs8", tv.rsaoaep.pkcs8, alg, false, ['decrypt'])
+    crypto.subtle.importKey("pkcs8", tv.rsaoaep.pkcs8, alg, false, ["decrypt"])
       .then(error(that), complete(that));
   }
 );
@@ -152,13 +152,13 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Test that RSA-OAEP encrypt/decrypt accepts strings as AlgorithmIdentifiers",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "RSA-OAEP",
       hash: "SHA-256",
       modulusLength: 2048,
-      publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
     };
 
     var privKey, pubKey, data = crypto.getRandomValues(new Uint8Array(128));
@@ -177,7 +177,7 @@ TestArray.addTest(
       .then(memcmp_complete(that, data), error(that));
   }
 );
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_RSA_PSS.html b/dom/crypto/test/test_WebCrypto_RSA_PSS.html
index 5c3975140a52..7cce4fd1add5 100644
--- a/dom/crypto/test/test_WebCrypto_RSA_PSS.html
+++ b/dom/crypto/test/test_WebCrypto_RSA_PSS.html
@@ -19,7 +19,7 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // Generating 2048-bit keys takes some time.
@@ -28,13 +28,13 @@ SimpleTest.requestLongerTimeout(2);
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-PSS key generation (SHA-1, 1024-bit)",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "RSA-PSS",
       hash: "SHA-1",
       modulusLength: 1024,
-      publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
     };
 
     crypto.subtle.generateKey(alg, false, ["sign", "verify"])
@@ -45,13 +45,13 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-PSS key generation and sign/verify round-trip (SHA-256, 2048-bit)",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "RSA-PSS",
       hash: "SHA-256",
       modulusLength: 2048,
-      publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
     };
 
     var privKey, pubKey;
@@ -70,14 +70,14 @@ TestArray.addTest(
       .then(setKey, error(that))
       .then(doSign, error(that))
       .then(doVerify, error(that))
-      .then(complete(that, x => x), error(that))
+      .then(complete(that, x => x), error(that));
   }
 );
 
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-PSS verify known signature (SHA-1, 1024-bit)",
-  function () {
+  function() {
     var that = this;
     var alg = {name: "RSA-PSS", hash: "SHA-1"};
     var vec = tv.rsapss;
@@ -96,7 +96,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Test invalid RSA-PSS signatures",
-  function () {
+  function() {
     var that = this;
     var alg = {name: "RSA-PSS", hash: "SHA-1"};
     var vec = tv.rsapss;
@@ -126,7 +126,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-PSS verify known signature (SHA-1, 1024-bit, JWK)",
-  function () {
+  function() {
     var that = this;
     var alg = {name: "RSA-PSS", hash: "SHA-1"};
 
@@ -144,7 +144,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-PSS verify known signatures (SHA-1 to SHA-512, 1024-bit)",
-  function () {
+  function() {
     var that = this;
 
     function verifyCase(hash, tv) {
@@ -165,7 +165,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-PSS import SPKI/PKCS#8 keys and sign/verify (SHA-1, 1024-bit)",
-  function () {
+  function() {
     var that = this;
     var alg = {name: "RSA-PSS", hash: "SHA-1"};
 
@@ -196,7 +196,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-PSS import JWK keys and sign/verify (SHA-1, 1024-bit)",
-  function () {
+  function() {
     var that = this;
     var alg = {name: "RSA-PSS", hash: "SHA-1"};
 
@@ -227,7 +227,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-PSS SPKI import/export (SHA-1, 1024-bit)",
-  function () {
+  function() {
     var that = this;
     var alg = {name: "RSA-PSS", hash: "SHA-1"};
 
@@ -244,7 +244,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-PSS PKCS#8 import/export (SHA-1, 1024-bit)",
-  function () {
+  function() {
     var that = this;
     var alg = {name: "RSA-PSS", hash: "SHA-1"};
 
@@ -261,7 +261,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-PSS JWK export a public key",
-  function () {
+  function() {
     var that = this;
     var alg = {name: "RSA-PSS", hash: "SHA-1"};
     var jwk = tv.rsapss.jwk_pub;
@@ -291,7 +291,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "RSA-PSS JWK export a private key",
-  function () {
+  function() {
     var that = this;
     var alg = {name: "RSA-PSS", hash: "SHA-1"};
     var jwk = tv.rsapss.jwk_priv;
@@ -327,13 +327,13 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Deterministic RSA-PSS signatures with saltLength=0 (SHA-256, 2048-bit)",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "RSA-PSS",
       hash: "SHA-256",
       modulusLength: 2048,
-      publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
     };
 
     var privKey, pubKey;
@@ -344,7 +344,7 @@ TestArray.addTest(
       var alg = {name: "RSA-PSS", saltLength: 0};
       return Promise.all([
         crypto.subtle.sign(alg, privKey, data),
-        crypto.subtle.sign(alg, privKey, data)
+        crypto.subtle.sign(alg, privKey, data),
       ]);
     }
 
@@ -364,10 +364,10 @@ TestArray.addTest(
         return sig1;
       }, error(that))
       .then(doVerify, error(that))
-      .then(complete(that, x => x), error(that))
+      .then(complete(that, x => x), error(that));
   }
 );
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_Reject_Generating_Keys_Without_Usages.html b/dom/crypto/test/test_WebCrypto_Reject_Generating_Keys_Without_Usages.html
index d252ed2da0a5..ac046efc63ba 100644
--- a/dom/crypto/test/test_WebCrypto_Reject_Generating_Keys_Without_Usages.html
+++ b/dom/crypto/test/test_WebCrypto_Reject_Generating_Keys_Without_Usages.html
@@ -19,7 +19,7 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // Generating 2048-bit keys takes some time.
@@ -33,23 +33,23 @@ TestArray.addTest(
       name: "RSA-OAEP",
       hash: "SHA-256",
       modulusLength: 2048,
-      publicExponent: new Uint8Array([0x01, 0x00, 0x01])
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
     };
 
     function generateKey(usages) {
       return crypto.subtle.generateKey(alg, false, usages);
     }
 
-    generateKey(["encrypt", "decrypt"]).then(function () {
+    generateKey(["encrypt", "decrypt"]).then(function() {
       return generateKey(["encrypt"]);
-    }).then(function () {
+    }).then(function() {
       return generateKey(["decrypt"]);
-    }).then(function () {
-      return generateKey(["sign"])
+    }).then(function() {
+      return generateKey(["sign"]);
     }, error(that)).then(error(that), complete(that));
   }
 );
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_Structured_Cloning.html b/dom/crypto/test/test_WebCrypto_Structured_Cloning.html
index 3275c546699d..b76f20c828c1 100644
--- a/dom/crypto/test/test_WebCrypto_Structured_Cloning.html
+++ b/dom/crypto/test/test_WebCrypto_Structured_Cloning.html
@@ -19,7 +19,7 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // -----------------------------------------------------------------------------
@@ -113,7 +113,7 @@ TestArray.addTest(
       name: "PBKDF2",
       hash: "SHA-1",
       salt: crypto.getRandomValues(new Uint8Array(8)),
-      iterations: 4096
+      iterations: 4096,
     };
 
     crypto.subtle.importKey("raw", key, "PBKDF2", true, ["deriveBits"])
@@ -134,7 +134,7 @@ TestArray.addTest(
       name: "HKDF",
       hash: "SHA-256",
       salt: new Uint8Array(),
-      info: new Uint8Array()
+      info: new Uint8Array(),
     };
 
     crypto.subtle.importKey("raw", key, "HKDF", false, ["deriveBits"])
@@ -155,7 +155,7 @@ TestArray.addTest(
       name: "RSA-OAEP",
       hash: "SHA-256",
       modulusLength: 2048,
-      publicExponent: new Uint8Array([1, 0, 1])
+      publicExponent: new Uint8Array([1, 0, 1]),
     };
 
     crypto.subtle.generateKey(alg, true, ["encrypt", "decrypt"])
@@ -179,7 +179,7 @@ TestArray.addTest(
       name: "RSASSA-PKCS1-v1_5",
       hash: "SHA-256",
       modulusLength: 2048,
-      publicExponent: new Uint8Array([1, 0, 1])
+      publicExponent: new Uint8Array([1, 0, 1]),
     };
 
     crypto.subtle.generateKey(alg, true, ["sign", "verify"])
@@ -204,7 +204,7 @@ TestArray.addTest(
       hash: "SHA-256",
       modulusLength: 2048,
       publicExponent: new Uint8Array([1, 0, 1]),
-      saltLength: 20
+      saltLength: 20,
     };
 
     crypto.subtle.generateKey(alg, true, ["sign", "verify"])
@@ -218,7 +218,7 @@ TestArray.addTest(
 );
 
 // -----------------------------------------------------------------------------
-/*TestArray.addTest(
+/* TestArray.addTest(
   "Structured Cloning: DH",
   function() {
     var that = this;
@@ -235,7 +235,7 @@ TestArray.addTest(
 );*/
 
 // -----------------------------------------------------------------------------
-/*TestArray.addTest(
+/* TestArray.addTest(
   "Structured Cloning: ECDH",
   function() {
     var that = this;
@@ -252,7 +252,7 @@ TestArray.addTest(
 );*/
 
 // -----------------------------------------------------------------------------
-/*TestArray.addTest(
+/* TestArray.addTest(
   "Structured Cloning: ECDSA",
   function() {
     var that = this;
@@ -268,7 +268,7 @@ TestArray.addTest(
       .then(complete(that), error(that));
   }
 );*/
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_Workers.html b/dom/crypto/test/test_WebCrypto_Workers.html
index d92f6169f23d..15368495f035 100644
--- a/dom/crypto/test/test_WebCrypto_Workers.html
+++ b/dom/crypto/test/test_WebCrypto_Workers.html
@@ -19,13 +19,13 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Send a CryptoKey to a Worker and use it to encrypt data",
-  function () {
+  function() {
     var worker = new Worker(`data:text/plain,
       onmessage = ({data: {key, data, nonce}}) => {
         var alg = { name: "AES-GCM", iv: nonce };
@@ -56,7 +56,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Get a CryptoKey from a Worker and encrypt/decrypt data",
-  function () {
+  function() {
     var worker = new Worker(`data:text/plain,
       var alg = { name: "AES-GCM", length: 128 };
       crypto.subtle.generateKey(alg, false, ["encrypt", "decrypt"])
@@ -83,7 +83,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Web crypto in terminating Worker",
-  function () {
+  function() {
     var worker = new Worker(`data:text/plain,
       function infiniteEncrypt(key, data, nonce) {
         var alg = { name: "AES-GCM", iv: nonce };
@@ -122,7 +122,7 @@ TestArray.addTest(
     });
   }
 );
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_WebCrypto_Wrap_Unwrap.html b/dom/crypto/test/test_WebCrypto_Wrap_Unwrap.html
index c2c7e57e688b..7897347fc227 100644
--- a/dom/crypto/test/test_WebCrypto_Wrap_Unwrap.html
+++ b/dom/crypto/test/test_WebCrypto_Wrap_Unwrap.html
@@ -19,25 +19,25 @@
 <!-- General testing framework -->
 <script src="./test-array.js"></script>
 
-<script>/*<![CDATA[*/
+<script>/* <![CDATA[*/
 "use strict";
 
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Key wrap known answer, using AES-GCM",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "AES-GCM",
       iv: tv.key_wrap_known_answer.wrapping_iv,
-      tagLength: 128
+      tagLength: 128,
     };
     var key, wrappingKey;
 
     function doImport(k) {
       wrappingKey = k;
       return crypto.subtle.importKey("raw", tv.key_wrap_known_answer.key,
-                                     alg, true, ['encrypt', 'decrypt']);
+                                     alg, true, ["encrypt", "decrypt"]);
     }
     function doWrap(k) {
       key = k;
@@ -45,7 +45,7 @@ TestArray.addTest(
     }
 
     crypto.subtle.importKey("raw", tv.key_wrap_known_answer.wrapping_key,
-                            alg, false, ['wrapKey'])
+                            alg, false, ["wrapKey"])
       .then(doImport, error(that))
       .then(doWrap, error(that))
       .then(
@@ -58,19 +58,19 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Key wrap failing on non-extractable key",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "AES-GCM",
       iv: tv.key_wrap_known_answer.wrapping_iv,
-      tagLength: 128
+      tagLength: 128,
     };
     var key, wrappingKey;
 
     function doImport(k) {
       wrappingKey = k;
       return crypto.subtle.importKey("raw", tv.key_wrap_known_answer.key,
-                                     alg, false, ['encrypt', 'decrypt']);
+                                     alg, false, ["encrypt", "decrypt"]);
     }
     function doWrap(k) {
       key = k;
@@ -78,7 +78,7 @@ TestArray.addTest(
     }
 
     crypto.subtle.importKey("raw", tv.key_wrap_known_answer.wrapping_key,
-                            alg, false, ['wrapKey'])
+                            alg, false, ["wrapKey"])
       .then(doImport, error(that))
       .then(doWrap, error(that))
       .then(
@@ -91,12 +91,12 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Key unwrap known answer, using AES-GCM",
-  function () {
+  function() {
     var that = this;
     var alg = {
       name: "AES-GCM",
       iv: tv.key_wrap_known_answer.wrapping_iv,
-      tagLength: 128
+      tagLength: 128,
     };
     var key, wrappingKey;
 
@@ -105,7 +105,7 @@ TestArray.addTest(
       return crypto.subtle.unwrapKey(
                 "raw", tv.key_wrap_known_answer.wrapped_key,
                 wrappingKey, alg,
-                "AES-GCM", true, ['encrypt', 'decrypt']
+                "AES-GCM", true, ["encrypt", "decrypt"]
              );
     }
     function doExport(k) {
@@ -113,7 +113,7 @@ TestArray.addTest(
     }
 
     crypto.subtle.importKey("raw", tv.key_wrap_known_answer.wrapping_key,
-                            alg, false, ['unwrapKey'])
+                            alg, false, ["unwrapKey"])
       .then(doUnwrap, error(that))
       .then(doExport, error(that))
       .then(
@@ -126,17 +126,17 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "Key wrap/unwrap round-trip, using RSA-OAEP",
-  function () {
+  function() {
     var that = this;
     var oaep = {
       name: "RSA-OAEP",
-      hash: "SHA-256"
+      hash: "SHA-256",
     };
     var gcm = {
       name: "AES-GCM",
       iv: tv.aes_gcm_enc.iv,
       additionalData: tv.aes_gcm_enc.adata,
-      tagLength: 128
+      tagLength: 128,
     };
     var unwrapKey;
 
@@ -148,7 +148,7 @@ TestArray.addTest(
     }
     function doUnwrap(wrappedKey) {
       return crypto.subtle.unwrapKey("raw", wrappedKey, unwrapKey, oaep,
-                                     gcm, false, ['encrypt']);
+                                     gcm, false, ["encrypt"]);
     }
     function doEncrypt(aesKey) {
       return crypto.subtle.encrypt(gcm, aesKey, tv.aes_gcm_enc.data);
@@ -163,9 +163,9 @@ TestArray.addTest(
     // 4. Compute HMAC
     // 5. Check HMAC value
     Promise.all([
-      crypto.subtle.importKey("raw", tv.aes_gcm_enc.key, gcm, true, ['encrypt']),
-      crypto.subtle.importKey("spki", tv.rsaoaep.spki, oaep, true, ['wrapKey']),
-      crypto.subtle.importKey("pkcs8", tv.rsaoaep.pkcs8, oaep, false, ['unwrapKey'])
+      crypto.subtle.importKey("raw", tv.aes_gcm_enc.key, gcm, true, ["encrypt"]),
+      crypto.subtle.importKey("spki", tv.rsaoaep.spki, oaep, true, ["wrapKey"]),
+      crypto.subtle.importKey("pkcs8", tv.rsaoaep.pkcs8, oaep, false, ["unwrapKey"]),
     ])
       .then(doWrap, error(that))
       .then(doUnwrap, error(that))
@@ -180,7 +180,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK wrap/unwrap round-trip, with AES-GCM",
-  function () {
+  function() {
     var that = this;
     var genAlg = { name: "HMAC", hash: "SHA-384", length: 512 };
     var wrapAlg = { name: "AES-GCM", iv: tv.aes_gcm_enc.iv };
@@ -195,17 +195,17 @@ TestArray.addTest(
     function doUnwrap(wrappedKey) {
       return crypto.subtle.unwrapKey("jwk", wrappedKey, wrapKey, wrapAlg,
                                      { name: "HMAC", hash: "SHA-384"},
-                                     true, ['sign', 'verify']);
+                                     true, ["sign", "verify"]);
     }
 
     Promise.all([
       crypto.subtle.importKey("jwk", tv.aes_gcm_enc.key_jwk,
-                              "AES-GCM", false, ['wrapKey','unwrapKey'])
+                              "AES-GCM", false, ["wrapKey", "unwrapKey"])
         .then(function(x) { wrapKey = x; }),
-      crypto.subtle.generateKey(genAlg, true, ['sign', 'verify'])
+      crypto.subtle.generateKey(genAlg, true, ["sign", "verify"])
         .then(function(x) { originalKey = x; return x; })
         .then(doExport)
-        .then(function(x) { originalKeyJwk = x; })
+        .then(function(x) { originalKeyJwk = x; }),
     ])
       .then(doWrap)
       .then(doUnwrap)
@@ -222,7 +222,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-KW known answer",
-  function () {
+  function() {
     var that = this;
 
     function doWrap(keys) {
@@ -233,9 +233,9 @@ TestArray.addTest(
 
     Promise.all([
       crypto.subtle.importKey("jwk", tv.aes_kw.wrapping_key,
-                              "AES-KW", false, ['wrapKey']),
+                              "AES-KW", false, ["wrapKey"]),
       crypto.subtle.importKey("jwk", tv.aes_kw.key,
-                              "AES-GCM", true, ['encrypt'])
+                              "AES-GCM", true, ["encrypt"]),
     ])
       .then(doWrap)
       .then(
@@ -249,7 +249,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-KW unwrap failure on tampered key data",
-  function () {
+  function() {
     var that = this;
     var tamperedWrappedKey = new Uint8Array(tv.aes_kw.wrapped_key);
     tamperedWrappedKey[5] ^= 0xFF;
@@ -257,11 +257,11 @@ TestArray.addTest(
     function doUnwrap(wrapKey) {
       return crypto.subtle.unwrapKey("raw", tamperedWrappedKey, wrapKey,
                                      "AES-KW", "AES-GCM",
-                                     true, ['encrypt', 'decrypt']);
+                                     true, ["encrypt", "decrypt"]);
     }
 
     crypto.subtle.importKey("jwk", tv.aes_kw.wrapping_key,
-                              "AES-KW", false, ['unwrapKey'])
+                              "AES-KW", false, ["unwrapKey"])
       .then(doUnwrap)
       .then(error(that), complete(that));
   }
@@ -270,7 +270,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "AES-KW wrap/unwrap round-trip",
-  function () {
+  function() {
     var that = this;
     var genAlg = { name: "HMAC", hash: "SHA-384", length: 512 };
     var wrapKey, originalKey, originalKeyJwk;
@@ -284,17 +284,17 @@ TestArray.addTest(
     function doUnwrap(wrappedKey) {
       return crypto.subtle.unwrapKey("raw", wrappedKey, wrapKey,
                                      "AES-KW", { name: "HMAC", hash: "SHA-384"},
-                                     true, ['sign', 'verify']);
+                                     true, ["sign", "verify"]);
     }
 
     Promise.all([
       crypto.subtle.importKey("jwk", tv.aes_kw.wrapping_key,
-                              "AES-KW", false, ['wrapKey','unwrapKey'])
+                              "AES-KW", false, ["wrapKey", "unwrapKey"])
         .then(function(x) { wrapKey = x; }),
-      crypto.subtle.generateKey(genAlg, true, ['sign'])
+      crypto.subtle.generateKey(genAlg, true, ["sign"])
         .then(function(x) { originalKey = x; return x; })
         .then(doExport)
-        .then(function(x) { originalKeyJwk = x; })
+        .then(function(x) { originalKeyJwk = x; }),
     ])
       .then(doWrap)
       .then(doUnwrap)
@@ -311,7 +311,7 @@ TestArray.addTest(
 // -----------------------------------------------------------------------------
 TestArray.addTest(
   "JWK unwrap attempt on bogus data should error out",
-  function () {
+  function() {
     // Largely cribbed from the "JWK wrap/unwrap round-trip, with AES-GCM" test
     var that = this;
     var wrapAlg = { name: "AES-GCM", iv: tv.aes_gcm_enc.iv };
@@ -324,11 +324,11 @@ TestArray.addTest(
     function doUnwrap(wrappedKey) {
       return crypto.subtle.unwrapKey("jwk", wrappedKey, wrapKey, wrapAlg,
                                      {name: "HMAC", hash: "SHA-384"},
-                                     true, ['sign', 'verify']);
+                                     true, ["sign", "verify"]);
     }
 
     crypto.subtle.importKey("jwk", tv.aes_gcm_enc.key_jwk,
-                            "AES-GCM", false, ['encrypt','unwrapKey'])
+                            "AES-GCM", false, ["encrypt", "unwrapKey"])
       .then(function(x) { wrapKey = x; })
       .then(doBogusWrap, error(that))
       .then(doUnwrap, error(that))
@@ -339,7 +339,7 @@ TestArray.addTest(
   }
 );
 
-/*]]>*/</script>
+/* ]]>*/</script>
 </head>
 
 <body>
diff --git a/dom/crypto/test/test_indexedDB.html b/dom/crypto/test/test_indexedDB.html
index b77495673672..951b03b05f61 100644
--- a/dom/crypto/test/test_indexedDB.html
+++ b/dom/crypto/test/test_indexedDB.html
@@ -47,12 +47,12 @@
       });
     }
 
-    addEventListener("load", function () {
+    addEventListener("load", function() {
       SpecialPowers.addPermission("browser", true, document);
       SpecialPowers.pushPrefEnv({set: [
         ["dom.ipc.browser_frames.oop_by_default", true],
         ["dom.mozBrowserFramesEnabled", true],
-        ["network.disable.ipc.security", true]
+        ["network.disable.ipc.security", true],
       ]}, runTest);
     });
   </script>
diff --git a/dom/crypto/test/util.js b/dom/crypto/test/util.js
index f7b4c260f3aa..7a3b473c0bde 100644
--- a/dom/crypto/test/util.js
+++ b/dom/crypto/test/util.js
@@ -11,7 +11,7 @@ var util = {
     var yb = new Uint8Array(y);
     if (x.byteLength !== y.byteLength) { return false; }
 
-    for (var i=0; i<xb.byteLength; ++i) {
+    for (var i = 0; i < xb.byteLength; ++i) {
       if (xb[i] !== yb[i]) {
         return false;
       }
@@ -23,7 +23,7 @@ var util = {
   abv2hex: function util_abv2hex(abv) {
     var b = new Uint8Array(abv);
     var hex = "";
-    for (var i=0; i <b.length; ++i) {
+    for (var i = 0; i < b.length; ++i) {
       var zeropad = (b[i] < 0x10) ? "0" : "";
       hex += zeropad + b[i].toString(16);
     }
@@ -37,13 +37,13 @@ var util = {
     }
 
     var abv = new Uint8Array(hex.length / 2);
-    for (var i=0; i<abv.length; ++i) {
-      abv[i] = parseInt(hex.substr(2*i, 2), 16);
+    for (var i = 0; i < abv.length; ++i) {
+      abv[i] = parseInt(hex.substr(2 * i, 2), 16);
     }
     return abv;
   },
 
-  clone: function (obj) {
+  clone(obj) {
     return new Promise(resolve => {
       let {port1, port2} = new MessageChannel();
 
@@ -55,7 +55,7 @@ var util = {
     });
   },
 
-  cloneExportCompareKeys: function (key) {
+  cloneExportCompareKeys(key) {
     return util.clone(key).then(clone => {
       var exports = [];
 
@@ -79,7 +79,7 @@ var util = {
         return clone;
       });
     });
-  }
+  },
 };
 
 function exists(x) {
@@ -89,7 +89,7 @@ function exists(x) {
 function hasFields(object, fields) {
   return fields
           .map(x => exists(object[x]))
-          .reduce((x,y) => (x && y));
+          .reduce((x, y) => (x && y));
 }
 
 function hasKeyFields(x) {