--- a/dom/base/test/gtest/TestContentUtils.cpp
+++ b/dom/base/test/gtest/TestContentUtils.cpp
@@ -6,35 +6,33 @@
 
 #include "gtest/gtest.h"
 
 #include "jsapi.h"
 #include "nsContentUtils.h"
 #include "mozilla/CycleCollectedJSContext.h"
 #include "mozilla/dom/SimpleGlobalObject.h"
 
-TEST(DOM_Base_ContentUtils, StringifyJSON_EmptyValue)
-{
-  JSObject* globalObject =
-    mozilla::dom::SimpleGlobalObject::Create(mozilla::dom::SimpleGlobalObject::GlobalType::BindingDetail);
+TEST(DOM_Base_ContentUtils, StringifyJSON_EmptyValue) {
+  JSObject* globalObject = mozilla::dom::SimpleGlobalObject::Create(
+      mozilla::dom::SimpleGlobalObject::GlobalType::BindingDetail);
   mozilla::dom::AutoJSAPI jsAPI;
   ASSERT_TRUE(jsAPI.Init(globalObject));
   JSContext* cx = jsAPI.cx();
   nsAutoString serializedValue;
 
   JS::RootedValue jsValue(cx);
   ASSERT_TRUE(nsContentUtils::StringifyJSON(cx, &jsValue, serializedValue));
 
   ASSERT_TRUE(serializedValue.EqualsLiteral("null"));
 }
 
-TEST(DOM_Base_ContentUtils, StringifyJSON_Object)
-{
-  JSObject* globalObject =
-    mozilla::dom::SimpleGlobalObject::Create(mozilla::dom::SimpleGlobalObject::GlobalType::BindingDetail);
+TEST(DOM_Base_ContentUtils, StringifyJSON_Object) {
+  JSObject* globalObject = mozilla::dom::SimpleGlobalObject::Create(
+      mozilla::dom::SimpleGlobalObject::GlobalType::BindingDetail);
   mozilla::dom::AutoJSAPI jsAPI;
   ASSERT_TRUE(jsAPI.Init(globalObject));
   JSContext* cx = jsAPI.cx();
   nsAutoString serializedValue;
 
   JS::RootedObject jsObj(cx, JS_NewPlainObject(cx));
   JS::RootedString valueStr(cx, JS_NewStringCopyZ(cx, "Hello World!"));
   ASSERT_TRUE(JS_DefineProperty(cx, jsObj, "key1", valueStr, JSPROP_ENUMERATE));

--- a/dom/base/test/gtest/TestMimeType.cpp
+++ b/dom/base/test/gtest/TestMimeType.cpp
@@ -6,721 +6,669 @@
 
 #include "gtest/gtest.h"
 
 #include "MimeType.h"
 #include "nsString.h"
 
 using mozilla::UniquePtr;
 
-TEST(MimeType, EmptyString)
-{
+TEST(MimeType, EmptyString) {
   const auto in = NS_LITERAL_STRING("");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Empty string";
+  ASSERT_FALSE(parsed) << "Empty string";
 }
 
-TEST(MimeType, JustWhitespace)
-{
+TEST(MimeType, JustWhitespace) {
   const auto in = NS_LITERAL_STRING(" \t\r\n ");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Just whitespace";
+  ASSERT_FALSE(parsed) << "Just whitespace";
 }
 
-TEST(MimeType, JustBackslash)
-{
+TEST(MimeType, JustBackslash) {
   const auto in = NS_LITERAL_STRING("\\");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Just backslash";
+  ASSERT_FALSE(parsed) << "Just backslash";
 }
 
-TEST(MimeType, JustForwardslash)
-{
+TEST(MimeType, JustForwardslash) {
   const auto in = NS_LITERAL_STRING("/");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Just forward slash";
+  ASSERT_FALSE(parsed) << "Just forward slash";
 }
 
-TEST(MimeType, MissingType1)
-{
+TEST(MimeType, MissingType1) {
   const auto in = NS_LITERAL_STRING("/bogus");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Missing type #1";
+  ASSERT_FALSE(parsed) << "Missing type #1";
 }
 
-TEST(MimeType, MissingType2)
-{
+TEST(MimeType, MissingType2) {
   const auto in = NS_LITERAL_STRING(" \r\n\t/bogus");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Missing type #2";
+  ASSERT_FALSE(parsed) << "Missing type #2";
 }
 
-TEST(MimeType, MissingSubtype1)
-{
+TEST(MimeType, MissingSubtype1) {
   const auto in = NS_LITERAL_STRING("bogus");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Missing subtype #1";
+  ASSERT_FALSE(parsed) << "Missing subtype #1";
 }
 
-TEST(MimeType, MissingSubType2)
-{
+TEST(MimeType, MissingSubType2) {
   const auto in = NS_LITERAL_STRING("bogus/");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Missing subtype #2";
+  ASSERT_FALSE(parsed) << "Missing subtype #2";
 }
 
-TEST(MimeType, MissingSubType3)
-{
+TEST(MimeType, MissingSubType3) {
   const auto in = NS_LITERAL_STRING("bogus;");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Missing subtype #3";
+  ASSERT_FALSE(parsed) << "Missing subtype #3";
 }
 
-TEST(MimeType, MissingSubType4)
-{
+TEST(MimeType, MissingSubType4) {
   const auto in = NS_LITERAL_STRING("bogus; \r\n\t");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Missing subtype #3";
+  ASSERT_FALSE(parsed) << "Missing subtype #3";
 }
 
-TEST(MimeType, ExtraForwardSlash)
-{
+TEST(MimeType, ExtraForwardSlash) {
   const auto in = NS_LITERAL_STRING("bogus/bogus/;");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Extra forward slash";
+  ASSERT_FALSE(parsed) << "Extra forward slash";
 }
 
-TEST(MimeType, WhitespaceInType)
-{
+TEST(MimeType, WhitespaceInType) {
   const auto in = NS_LITERAL_STRING("t\re\nx\tt /html");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Type with whitespace";
+  ASSERT_FALSE(parsed) << "Type with whitespace";
 }
 
-TEST(MimeType, WhitespaceInSubtype)
-{
+TEST(MimeType, WhitespaceInSubtype) {
   const auto in = NS_LITERAL_STRING("text/ h\rt\nm\tl");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Subtype with whitespace";
+  ASSERT_FALSE(parsed) << "Subtype with whitespace";
 }
 
-TEST(MimeType, NonAlphanumericMediaType1)
-{
+TEST(MimeType, NonAlphanumericMediaType1) {
   const auto in = NS_LITERAL_STRING("</>");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Non-alphanumeric media type #1";
+  ASSERT_FALSE(parsed) << "Non-alphanumeric media type #1";
 }
 
-TEST(MimeType, NonAlphanumericMediaType2)
-{
+TEST(MimeType, NonAlphanumericMediaType2) {
   const auto in = NS_LITERAL_STRING("(/)");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Non-alphanumeric media type #2";
+  ASSERT_FALSE(parsed) << "Non-alphanumeric media type #2";
 }
 
-TEST(MimeType, NonAlphanumericMediaType3)
-{
+TEST(MimeType, NonAlphanumericMediaType3) {
   const auto in = NS_LITERAL_STRING("{/}");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Non-alphanumeric media type #3";
+  ASSERT_FALSE(parsed) << "Non-alphanumeric media type #3";
 }
 
-TEST(MimeType, NonAlphanumericMediaType4)
-{
+TEST(MimeType, NonAlphanumericMediaType4) {
   const auto in = NS_LITERAL_STRING("\"/\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Non-alphanumeric media type #4";
+  ASSERT_FALSE(parsed) << "Non-alphanumeric media type #4";
 }
 
-TEST(MimeType, NonAlphanumericMediaType5)
-{
+TEST(MimeType, NonAlphanumericMediaType5) {
   const auto in = NS_LITERAL_STRING("\0/\0");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Non-alphanumeric media type #5";
+  ASSERT_FALSE(parsed) << "Non-alphanumeric media type #5";
 }
 
-TEST(MimeType, NonAlphanumericMediaType6)
-{
+TEST(MimeType, NonAlphanumericMediaType6) {
   const auto in = NS_LITERAL_STRING("text/html(;doesnot=matter");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Non-alphanumeric media type #6";
+  ASSERT_FALSE(parsed) << "Non-alphanumeric media type #6";
 }
 
-TEST(MimeType, NonLatin1MediaType1)
-{
+TEST(MimeType, NonLatin1MediaType1) {
   const auto in = NS_LITERAL_STRING("ÿ/ÿ");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Non-latin1 media type #1";
+  ASSERT_FALSE(parsed) << "Non-latin1 media type #1";
 }
 
-TEST(MimeType, NonLatin1MediaType2)
-{
+TEST(MimeType, NonLatin1MediaType2) {
   const auto in = NS_LITERAL_STRING(u"\x0100/\x0100");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) <<
-    "Non-latin1 media type #2";
+  ASSERT_FALSE(parsed) << "Non-latin1 media type #2";
 }
 
-TEST(MimeType, MultipleParameters)
-{
-  const auto in = NS_LITERAL_STRING("text/html;charset=gbk;no=1;charset_=gbk_;yes=2");
+TEST(MimeType, MultipleParameters) {
+  const auto in =
+      NS_LITERAL_STRING("text/html;charset=gbk;no=1;charset_=gbk_;yes=2");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(NS_LITERAL_STRING("text/html;charset=gbk;no=1;charset_=gbk_;yes=2"))) <<
-    "Multiple parameters";
+  ASSERT_TRUE(out.Equals(
+      NS_LITERAL_STRING("text/html;charset=gbk;no=1;charset_=gbk_;yes=2")))
+      << "Multiple parameters";
 }
 
-TEST(MimeType, DuplicateParameter1)
-{
-  const auto in = NS_LITERAL_STRING("text/html;charset=gbk;charset=windows-1255");
+TEST(MimeType, DuplicateParameter1) {
+  const auto in =
+      NS_LITERAL_STRING("text/html;charset=gbk;charset=windows-1255");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(NS_LITERAL_STRING("text/html;charset=gbk"))) <<
-    "Duplicate parameter #1";
+  ASSERT_TRUE(out.Equals(NS_LITERAL_STRING("text/html;charset=gbk")))
+      << "Duplicate parameter #1";
 }
 
-TEST(MimeType, DuplicateParameter2)
-{
+TEST(MimeType, DuplicateParameter2) {
   const auto in = NS_LITERAL_STRING("text/html;charset=();charset=GBK");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(NS_LITERAL_STRING("text/html;charset=\"()\""))) <<
-    "Duplicate parameter #2";
+  ASSERT_TRUE(out.Equals(NS_LITERAL_STRING("text/html;charset=\"()\"")))
+      << "Duplicate parameter #2";
 }
 
-TEST(MimeType, CString)
-{
+TEST(MimeType, CString) {
   const auto in = NS_LITERAL_CSTRING("text/html;charset=();charset=GBK");
   UniquePtr<CMimeType> parsed = CMimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsCString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(NS_LITERAL_CSTRING("text/html;charset=\"()\""))) <<
-    "Duplicate parameter #2";
+  ASSERT_TRUE(out.Equals(NS_LITERAL_CSTRING("text/html;charset=\"()\"")))
+      << "Duplicate parameter #2";
 }
 
 #ifdef _MSC_VER
 #pragma warning(push)
-#pragma warning(disable:4819)
+#pragma warning(disable : 4819)
 #endif
-TEST(MimeType, NonAlphanumericParametersAreQuoted)
-{
+TEST(MimeType, NonAlphanumericParametersAreQuoted) {
   const auto in = NS_LITERAL_STRING("text/html;test=\x00FF\\;charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(NS_LITERAL_STRING("text/html;test=\"\x00FF\\\\\";charset=gbk"))) <<
-    "Non-alphanumeric parameters are quoted";
+  ASSERT_TRUE(out.Equals(
+      NS_LITERAL_STRING("text/html;test=\"\x00FF\\\\\";charset=gbk")))
+      << "Non-alphanumeric parameters are quoted";
 }
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
-TEST(MimeType, ParameterQuotedIfHasLeadingWhitespace1)
-{
+TEST(MimeType, ParameterQuotedIfHasLeadingWhitespace1) {
   const auto in = NS_LITERAL_STRING("text/html;charset= g\\\"bk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" g\\\\\\\"bk\"")) <<
-    "Parameter is quoted if has leading whitespace #1";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" g\\\\\\\"bk\""))
+      << "Parameter is quoted if has leading whitespace #1";
 }
 
-TEST(MimeType, ParameterQuotedIfHasLeadingWhitespace2)
-{
+TEST(MimeType, ParameterQuotedIfHasLeadingWhitespace2) {
   const auto in = NS_LITERAL_STRING("text/html;charset= \"g\\bk\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" \\\"g\\\\bk\\\"\"")) <<
-    "Parameter is quoted if has leading whitespace #2";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" \\\"g\\\\bk\\\"\""))
+      << "Parameter is quoted if has leading whitespace #2";
 }
 
-TEST(MimeType, ParameterQuotedIfHasInternalWhitespace)
-{
+TEST(MimeType, ParameterQuotedIfHasInternalWhitespace) {
   const auto in = NS_LITERAL_STRING("text/html;charset=g \\b\"k");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"g \\\\b\\\"k\"")) <<
-    "Parameter is quoted if has internal whitespace";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"g \\\\b\\\"k\""))
+      << "Parameter is quoted if has internal whitespace";
 }
 
-TEST(MimeType, ImproperlyQuotedParameter1)
-{
+TEST(MimeType, ImproperlyQuotedParameter1) {
   const auto in = NS_LITERAL_STRING("x/x;test=\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("x/x;test=\"\"")) <<
-    "Improperly-quoted parameter is handled properly #1";
+  ASSERT_TRUE(out.EqualsLiteral("x/x;test=\"\""))
+      << "Improperly-quoted parameter is handled properly #1";
 }
 
-TEST(MimeType, ImproperlyQuotedParameter2)
-{
+TEST(MimeType, ImproperlyQuotedParameter2) {
   const auto in = NS_LITERAL_STRING("x/x;test=\"\\");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("x/x;test=\"\\\\\"")) <<
-    "Improperly-quoted parameter is handled properly #2";
+  ASSERT_TRUE(out.EqualsLiteral("x/x;test=\"\\\\\""))
+      << "Improperly-quoted parameter is handled properly #2";
 }
 
-TEST(MimeType, NonLatin1ParameterIgnored)
-{
+TEST(MimeType, NonLatin1ParameterIgnored) {
   const auto in = NS_LITERAL_STRING(u"x/x;test=\xFFFD;x=x");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("x/x;x=x")) <<
-    "Non latin-1 parameters are ignored";
+  ASSERT_TRUE(out.EqualsLiteral("x/x;x=x"))
+      << "Non latin-1 parameters are ignored";
 }
 
-TEST(MimeType, ParameterIgnoredIfWhitespaceInName1)
-{
+TEST(MimeType, ParameterIgnoredIfWhitespaceInName1) {
   const auto in = NS_LITERAL_STRING("text/html;charset =gbk;charset=123");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=123")) <<
-    "Parameter ignored if whitespace in name #1";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=123"))
+      << "Parameter ignored if whitespace in name #1";
 }
 
-TEST(MimeType, ParameterIgnoredIfWhitespaceInName2)
-{
+TEST(MimeType, ParameterIgnoredIfWhitespaceInName2) {
   const auto in = NS_LITERAL_STRING("text/html;cha rset =gbk;charset=123");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=123")) <<
-    "Parameter ignored if whitespace in name #2";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=123"))
+      << "Parameter ignored if whitespace in name #2";
 }
 
-TEST(MimeType, WhitespaceTrimmed)
-{
-  const auto in = NS_LITERAL_STRING("\n\r\t  text/plain\n\r\t  ;\n\r\t  charset=123\n\r\t ");
+TEST(MimeType, WhitespaceTrimmed) {
+  const auto in = NS_LITERAL_STRING(
+      "\n\r\t  text/plain\n\r\t  ;\n\r\t  charset=123\n\r\t ");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/plain;charset=123")) <<
-    "Whitespace appropriately ignored";
+  ASSERT_TRUE(out.EqualsLiteral("text/plain;charset=123"))
+      << "Whitespace appropriately ignored";
 }
 
-TEST(MimeType, WhitespaceOnlyParameterIgnored)
-{
+TEST(MimeType, WhitespaceOnlyParameterIgnored) {
   const auto in = NS_LITERAL_STRING("x/x;x= \r\n\t");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("x/x")) <<
-    "Whitespace-only parameter is ignored";
+  ASSERT_TRUE(out.EqualsLiteral("x/x"))
+      << "Whitespace-only parameter is ignored";
 }
 
-TEST(MimeType, IncompleteParameterIgnored1)
-{
+TEST(MimeType, IncompleteParameterIgnored1) {
   const auto in = NS_LITERAL_STRING("x/x;test");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("x/x")) <<
-    "Incomplete parameter is ignored #1";
+  ASSERT_TRUE(out.EqualsLiteral("x/x")) << "Incomplete parameter is ignored #1";
 }
 
-TEST(MimeType, IncompleteParameterIgnored2)
-{
+TEST(MimeType, IncompleteParameterIgnored2) {
   const auto in = NS_LITERAL_STRING("x/x;test=");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("x/x")) <<
-    "Incomplete parameter is ignored #2";
+  ASSERT_TRUE(out.EqualsLiteral("x/x")) << "Incomplete parameter is ignored #2";
 }
 
-TEST(MimeType, IncompleteParameterIgnored3)
-{
+TEST(MimeType, IncompleteParameterIgnored3) {
   const auto in = NS_LITERAL_STRING("x/x;test= \r\n\t");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("x/x")) <<
-    "Incomplete parameter is ignored #3";
+  ASSERT_TRUE(out.EqualsLiteral("x/x")) << "Incomplete parameter is ignored #3";
 }
 
-TEST(MimeType, IncompleteParameterIgnored4)
-{
+TEST(MimeType, IncompleteParameterIgnored4) {
   const auto in = NS_LITERAL_STRING("text/html;test;charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk")) <<
-    "Incomplete parameter is ignored #4";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
+      << "Incomplete parameter is ignored #4";
 }
 
-TEST(MimeType, IncompleteParameterIgnored5)
-{
+TEST(MimeType, IncompleteParameterIgnored5) {
   const auto in = NS_LITERAL_STRING("text/html;test=;charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk")) <<
-    "Incomplete parameter is ignored #5";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
+      << "Incomplete parameter is ignored #5";
 }
 
-TEST(MimeType, EmptyParameterIgnored1)
-{
+TEST(MimeType, EmptyParameterIgnored1) {
   const auto in = NS_LITERAL_STRING("text/html ; ; charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk")) <<
-    "Empty parameter ignored #1";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
+      << "Empty parameter ignored #1";
 }
 
-TEST(MimeType, EmptyParameterIgnored2)
-{
+TEST(MimeType, EmptyParameterIgnored2) {
   const auto in = NS_LITERAL_STRING("text/html;;;;charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk")) <<
-    "Empty parameter ignored #2";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
+      << "Empty parameter ignored #2";
 }
 
-TEST(MimeType, InvalidParameterIgnored1)
-{
+TEST(MimeType, InvalidParameterIgnored1) {
   const auto in = NS_LITERAL_STRING("text/html;';charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk")) <<
-    "Invalid parameter ignored #1";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
+      << "Invalid parameter ignored #1";
 }
 
-TEST(MimeType, InvalidParameterIgnored2)
-{
+TEST(MimeType, InvalidParameterIgnored2) {
   const auto in = NS_LITERAL_STRING("text/html;\";charset=gbk;=123; =321");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk")) <<
-    "Invalid parameter ignored #2";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
+      << "Invalid parameter ignored #2";
 }
 
-TEST(MimeType, InvalidParameterIgnored3)
-{
+TEST(MimeType, InvalidParameterIgnored3) {
   const auto in = NS_LITERAL_STRING("text/html;charset= \"\u007F;charset=GBK");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=GBK")) <<
-    "Invalid parameter ignored #3";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=GBK"))
+      << "Invalid parameter ignored #3";
 }
 
-TEST(MimeType, InvalidParameterIgnored4)
-{
-  const auto in = NS_LITERAL_STRING("text/html;charset=\"\u007F;charset=foo\";charset=GBK;charset=");
+TEST(MimeType, InvalidParameterIgnored4) {
+  const auto in = NS_LITERAL_STRING(
+      "text/html;charset=\"\u007F;charset=foo\";charset=GBK;charset=");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=GBK")) <<
-    "Invalid parameter ignored #4";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=GBK"))
+      << "Invalid parameter ignored #4";
 }
 
-TEST(MimeType, SingleQuotes1)
-{
+TEST(MimeType, SingleQuotes1) {
   const auto in = NS_LITERAL_STRING("text/html;charset='gbk'");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset='gbk'")) <<
-    "Single quotes handled properly #1";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset='gbk'"))
+      << "Single quotes handled properly #1";
 }
 
-TEST(MimeType, SingleQuotes2)
-{
+TEST(MimeType, SingleQuotes2) {
   const auto in = NS_LITERAL_STRING("text/html;charset='gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset='gbk")) <<
-    "Single quotes handled properly #2";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset='gbk"))
+      << "Single quotes handled properly #2";
 }
 
-TEST(MimeType, SingleQuotes3)
-{
+TEST(MimeType, SingleQuotes3) {
   const auto in = NS_LITERAL_STRING("text/html;charset=gbk'");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk'")) <<
-    "Single quotes handled properly #3";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk'"))
+      << "Single quotes handled properly #3";
 }
 
-TEST(MimeType, SingleQuotes4)
-{
+TEST(MimeType, SingleQuotes4) {
   const auto in = NS_LITERAL_STRING("text/html;charset=';charset=GBK");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset='")) <<
-    "Single quotes handled properly #4";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset='"))
+      << "Single quotes handled properly #4";
 }
 
-TEST(MimeType, SingleQuotes5)
-{
+TEST(MimeType, SingleQuotes5) {
   const auto in = NS_LITERAL_STRING("text/html;charset=''';charset=GBK");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset='''")) <<
-    "Single quotes handled properly #5";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset='''"))
+      << "Single quotes handled properly #5";
 }
 
-TEST(MimeType, DoubleQuotes1)
-{
+TEST(MimeType, DoubleQuotes1) {
   const auto in = NS_LITERAL_STRING("text/html;charset=\"gbk\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk")) <<
-    "Double quotes handled properly #1";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
+      << "Double quotes handled properly #1";
 }
 
-TEST(MimeType, DoubleQuotes2)
-{
+TEST(MimeType, DoubleQuotes2) {
   const auto in = NS_LITERAL_STRING("text/html;charset=\"gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk")) <<
-    "Double quotes handled properly #2";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
+      << "Double quotes handled properly #2";
 }
 
-TEST(MimeType, DoubleQuotes3)
-{
+TEST(MimeType, DoubleQuotes3) {
   const auto in = NS_LITERAL_STRING("text/html;charset=gbk\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"gbk\\\"\"")) <<
-    "Double quotes handled properly #3";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"gbk\\\"\""))
+      << "Double quotes handled properly #3";
 }
 
-TEST(MimeType, DoubleQuotes4)
-{
+TEST(MimeType, DoubleQuotes4) {
   const auto in = NS_LITERAL_STRING("text/html;charset=\" gbk\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" gbk\"")) <<
-    "Double quotes handled properly #4";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" gbk\""))
+      << "Double quotes handled properly #4";
 }
 
-TEST(MimeType, DoubleQuotes5)
-{
+TEST(MimeType, DoubleQuotes5) {
   const auto in = NS_LITERAL_STRING("text/html;charset=\"gbk \"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"gbk \"")) <<
-    "Double quotes handled properly #5";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"gbk \""))
+      << "Double quotes handled properly #5";
 }
 
-TEST(MimeType, DoubleQuotes6)
-{
+TEST(MimeType, DoubleQuotes6) {
   const auto in = NS_LITERAL_STRING("text/html;charset=\"\\ gbk\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" gbk\"")) <<
-    "Double quotes handled properly #6";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" gbk\""))
+      << "Double quotes handled properly #6";
 }
 
-TEST(MimeType, DoubleQuotes7)
-{
+TEST(MimeType, DoubleQuotes7) {
   const auto in = NS_LITERAL_STRING("text/html;charset=\"\\g\\b\\k\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk")) <<
-    "Double quotes handled properly #7";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
+      << "Double quotes handled properly #7";
 }
 
-TEST(MimeType, DoubleQuotes8)
-{
+TEST(MimeType, DoubleQuotes8) {
   const auto in = NS_LITERAL_STRING("text/html;charset=\"gbk\"x");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk")) <<
-    "Double quotes handled properly #8";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
+      << "Double quotes handled properly #8";
 }
 
-TEST(MimeType, DoubleQuotes9)
-{
+TEST(MimeType, DoubleQuotes9) {
   const auto in = NS_LITERAL_STRING("text/html;charset=\"\";charset=GBK");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"\"")) <<
-    "Double quotes handled properly #9";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"\""))
+      << "Double quotes handled properly #9";
 }
 
-TEST(MimeType, DoubleQuotes10)
-{
+TEST(MimeType, DoubleQuotes10) {
   const auto in = NS_LITERAL_STRING("text/html;charset=\";charset=GBK");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\";charset=GBK\"")) <<
-    "Double quotes handled properly #10";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\";charset=GBK\""))
+      << "Double quotes handled properly #10";
 }
 
-TEST(MimeType, UnexpectedCodePoints)
-{
+TEST(MimeType, UnexpectedCodePoints) {
   const auto in = NS_LITERAL_STRING("text/html;charset={gbk}");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"{gbk}\"")) <<
-    "Unexpected code points handled properly";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"{gbk}\""))
+      << "Unexpected code points handled properly";
 }
 
-TEST(MimeType, LongTypesSubtypesAccepted)
-{
-  const auto in = NS_LITERAL_STRING("0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789/0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789");
+TEST(MimeType, LongTypesSubtypesAccepted) {
+  const auto in = NS_LITERAL_STRING(
+      "012345678901234567890123456789012345678901234567890123456789012345678901"
+      "2345678901234567890123456789012345678901234567890123456789/"
+      "012345678901234567890123456789012345678901234567890123456789012345678901"
+      "2345678901234567890123456789012345678901234567890123456789");
+  UniquePtr<MimeType> parsed = MimeType::Parse(in);
+  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  nsAutoString out;
+  parsed->Serialize(out);
+  ASSERT_TRUE(out.Equals(in)) << "Long type/subtype accepted";
+}
+
+TEST(MimeType, LongParametersAccepted) {
+  const auto in = NS_LITERAL_STRING(
+      "text/"
+      "html;"
+      "012345678901234567890123456789012345678901234567890123456789012345678901"
+      "2345678901234567890123456789012345678901234567890123456789=x;charset="
+      "gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(in)) <<
-    "Long type/subtype accepted";
+  ASSERT_TRUE(out.Equals(in)) << "Long parameters accepted";
 }
 
-TEST(MimeType, LongParametersAccepted)
-{
-  const auto in = NS_LITERAL_STRING("text/html;0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789=x;charset=gbk");
+TEST(MimeType, AllValidCharactersAccepted1) {
+  const auto in = NS_LITERAL_STRING(
+      u"x/x;x=\"\t "
+      u"!\\\"#$%&'()*+,-./"
+      u"0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`"
+      u"abcdefghijklmnopqrstuvwxyz{|}~"
+      u"\u0080\u0081\u0082\u0083\u0084\u0085\u0086\u0087\u0088\u0089\u008A"
+      u"\u008B\u008C\u008D\u008E\u008F\u0090\u0091\u0092\u0093\u0094\u0095"
+      u"\u0096\u0097\u0098\u0099\u009A\u009B\u009C\u009D\u009E\u009F\u00A0"
+      u"\u00A1\u00A2\u00A3\u00A4\u00A5\u00A6\u00A7\u00A8\u00A9\u00AA\u00AB"
+      u"\u00AC\u00AD\u00AE\u00AF\u00B0\u00B1\u00B2\u00B3\u00B4\u00B5\u00B6"
+      u"\u00B7\u00B8\u00B9\u00BA\u00BB\u00BC\u00BD\u00BE\u00BF\u00C0\u00C1"
+      u"\u00C2\u00C3\u00C4\u00C5\u00C6\u00C7\u00C8\u00C9\u00CA\u00CB\u00CC"
+      u"\u00CD\u00CE\u00CF\u00D0\u00D1\u00D2\u00D3\u00D4\u00D5\u00D6\u00D7"
+      u"\u00D8\u00D9\u00DA\u00DB\u00DC\u00DD\u00DE\u00DF\u00E0\u00E1\u00E2"
+      u"\u00E3\u00E4\u00E5\u00E6\u00E7\u00E8\u00E9\u00EA\u00EB\u00EC\u00ED"
+      u"\u00EE\u00EF\u00F0\u00F1\u00F2\u00F3\u00F4\u00F5\u00F6\u00F7\u00F8"
+      u"\u00F9\u00FA\u00FB\u00FC\u00FD\u00FE\u00FF\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(in)) <<
-    "Long parameters accepted";
+  ASSERT_TRUE(out.Equals(in)) << "All valid characters accepted #1";
 }
 
-TEST(MimeType, AllValidCharactersAccepted1)
-{
-  const auto in = NS_LITERAL_STRING(u"x/x;x=\"\t !\\\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u0080\u0081\u0082\u0083\u0084\u0085\u0086\u0087\u0088\u0089\u008A\u008B\u008C\u008D\u008E\u008F\u0090\u0091\u0092\u0093\u0094\u0095\u0096\u0097\u0098\u0099\u009A\u009B\u009C\u009D\u009E\u009F\u00A0\u00A1\u00A2\u00A3\u00A4\u00A5\u00A6\u00A7\u00A8\u00A9\u00AA\u00AB\u00AC\u00AD\u00AE\u00AF\u00B0\u00B1\u00B2\u00B3\u00B4\u00B5\u00B6\u00B7\u00B8\u00B9\u00BA\u00BB\u00BC\u00BD\u00BE\u00BF\u00C0\u00C1\u00C2\u00C3\u00C4\u00C5\u00C6\u00C7\u00C8\u00C9\u00CA\u00CB\u00CC\u00CD\u00CE\u00CF\u00D0\u00D1\u00D2\u00D3\u00D4\u00D5\u00D6\u00D7\u00D8\u00D9\u00DA\u00DB\u00DC\u00DD\u00DE\u00DF\u00E0\u00E1\u00E2\u00E3\u00E4\u00E5\u00E6\u00E7\u00E8\u00E9\u00EA\u00EB\u00EC\u00ED\u00EE\u00EF\u00F0\u00F1\u00F2\u00F3\u00F4\u00F5\u00F6\u00F7\u00F8\u00F9\u00FA\u00FB\u00FC\u00FD\u00FE\u00FF\"");
-  UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
-  nsAutoString out;
-  parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(in)) <<
-    "All valid characters accepted #1";
-}
-
-TEST(MimeType, CaseNormalization1)
-{
+TEST(MimeType, CaseNormalization1) {
   const auto in = NS_LITERAL_STRING("TEXT/PLAIN;CHARSET=TEST");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/plain;charset=TEST")) <<
-    "Case normalized properly #1";
+  ASSERT_TRUE(out.EqualsLiteral("text/plain;charset=TEST"))
+      << "Case normalized properly #1";
 }
 
-TEST(MimeType, CaseNormalization2)
-{
-  const auto in = NS_LITERAL_STRING("!#$%&'*+-.^_`|~0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/!#$%&'*+-.^_`|~0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz;!#$%&'*+-.^_`|~0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz=!#$%&'*+-.^_`|~0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
+TEST(MimeType, CaseNormalization2) {
+  const auto in = NS_LITERAL_STRING(
+      "!#$%&'*+-.^_`|~"
+      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/"
+      "!#$%&'*+-.^_`|~"
+      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz;!#$%&'*+-"
+      ".^_`|~0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz=!#$"
+      "%&'*+-.^_`|~"
+      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("!#$%&'*+-.^_`|~0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz/!#$%&'*+-.^_`|~0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz;!#$%&'*+-.^_`|~0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz=!#$%&'*+-.^_`|~0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")) <<
-    "Case normalized properly #2";
+  ASSERT_TRUE(out.EqualsLiteral(
+      "!#$%&'*+-.^_`|~"
+      "0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz/"
+      "!#$%&'*+-.^_`|~"
+      "0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz;!#$%&'*+-"
+      ".^_`|~0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz=!#$"
+      "%&'*+-.^_`|~"
+      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"))
+      << "Case normalized properly #2";
 }
 
-TEST(MimeType, LegacyCommentSyntax1)
-{
+TEST(MimeType, LegacyCommentSyntax1) {
   const auto in = NS_LITERAL_STRING("text/html;charset=gbk(");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"gbk(\"")) <<
-    "Legacy comment syntax #1";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"gbk(\""))
+      << "Legacy comment syntax #1";
 }
 
-TEST(MimeType, LegacyCommentSyntax2)
-{
+TEST(MimeType, LegacyCommentSyntax2) {
   const auto in = NS_LITERAL_STRING("text/html;x=(;charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   ASSERT_TRUE(parsed) << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;x=\"(\";charset=gbk")) <<
-    "Legacy comment syntax #2";
+  ASSERT_TRUE(out.EqualsLiteral("text/html;x=\"(\";charset=gbk"))
+      << "Legacy comment syntax #2";
 }

--- a/dom/base/test/gtest/TestPlainTextSerializer.cpp
+++ b/dom/base/test/gtest/TestPlainTextSerializer.cpp
@@ -7,225 +7,201 @@
 #include "gtest/gtest.h"
 
 #include "nsServiceManagerUtils.h"
 #include "nsString.h"
 #include "nsIDocumentEncoder.h"
 #include "nsCRT.h"
 #include "nsIParserUtils.h"
 
-void
-ConvertBufToPlainText(nsString &aConBuf, int aFlag)
-{
+void ConvertBufToPlainText(nsString &aConBuf, int aFlag) {
   nsCOMPtr<nsIParserUtils> utils = do_GetService(NS_PARSERUTILS_CONTRACTID);
   utils->ConvertToPlainText(aConBuf, aFlag, 72, aConBuf);
 }
 
 // Test for ASCII with format=flowed; delsp=yes
-TEST(PlainTextSerializer, ASCIIWithFlowedDelSp)
-{
+TEST(PlainTextSerializer, ASCIIWithFlowedDelSp) {
   nsString test;
   nsString result;
 
-  test.AssignLiteral("<html><body>"
-                     "Firefox Firefox Firefox Firefox "
-                     "Firefox Firefox Firefox Firefox "
-                     "Firefox Firefox Firefox Firefox"
-                     "</body></html>");
+  test.AssignLiteral(
+      "<html><body>"
+      "Firefox Firefox Firefox Firefox "
+      "Firefox Firefox Firefox Firefox "
+      "Firefox Firefox Firefox Firefox"
+      "</body></html>");
 
   ConvertBufToPlainText(test, nsIDocumentEncoder::OutputFormatted |
-                              nsIDocumentEncoder::OutputCRLineBreak |
-                              nsIDocumentEncoder::OutputLFLineBreak |
-                              nsIDocumentEncoder::OutputFormatFlowed |
-                              nsIDocumentEncoder::OutputFormatDelSp);
+                                  nsIDocumentEncoder::OutputCRLineBreak |
+                                  nsIDocumentEncoder::OutputLFLineBreak |
+                                  nsIDocumentEncoder::OutputFormatFlowed |
+                                  nsIDocumentEncoder::OutputFormatDelSp);
 
   // create result case
-  result.AssignLiteral("Firefox Firefox Firefox Firefox "
-                       "Firefox Firefox Firefox Firefox "
-                       "Firefox  \r\nFirefox Firefox Firefox\r\n");
+  result.AssignLiteral(
+      "Firefox Firefox Firefox Firefox "
+      "Firefox Firefox Firefox Firefox "
+      "Firefox  \r\nFirefox Firefox Firefox\r\n");
 
-  ASSERT_TRUE(test.Equals(result)) <<
-    "Wrong HTML to ASCII text serialization with format=flowed; delsp=yes";
+  ASSERT_TRUE(test.Equals(result))
+      << "Wrong HTML to ASCII text serialization with format=flowed; delsp=yes";
 }
 
 // Test for CJK with format=flowed; delsp=yes
-TEST(PlainTextSerializer, CJKWithFlowedDelSp)
-{
+TEST(PlainTextSerializer, CJKWithFlowedDelSp) {
   nsString test;
   nsString result;
 
   test.AssignLiteral("<html><body>");
   for (uint32_t i = 0; i < 40; i++) {
     // Insert Kanji (U+5341)
     test.Append(0x5341);
   }
   test.AppendLiteral("</body></html>");
 
   ConvertBufToPlainText(test, nsIDocumentEncoder::OutputFormatted |
-                              nsIDocumentEncoder::OutputCRLineBreak |
-                              nsIDocumentEncoder::OutputLFLineBreak |
-                              nsIDocumentEncoder::OutputFormatFlowed |
-                              nsIDocumentEncoder::OutputFormatDelSp);
+                                  nsIDocumentEncoder::OutputCRLineBreak |
+                                  nsIDocumentEncoder::OutputLFLineBreak |
+                                  nsIDocumentEncoder::OutputFormatFlowed |
+                                  nsIDocumentEncoder::OutputFormatDelSp);
 
   // create result case
   for (uint32_t i = 0; i < 36; i++) {
     result.Append(0x5341);
   }
   result.AppendLiteral(" \r\n");
   for (uint32_t i = 0; i < 4; i++) {
     result.Append(0x5341);
   }
   result.AppendLiteral("\r\n");
 
-  ASSERT_TRUE(test.Equals(result)) <<
-    "Wrong HTML to CJK text serialization with format=flowed; delsp=yes";
+  ASSERT_TRUE(test.Equals(result))
+      << "Wrong HTML to CJK text serialization with format=flowed; delsp=yes";
 }
 
 // Test for CJK with DisallowLineBreaking
-TEST(PlainTextSerializer, CJKWithDisallowLineBreaking)
-{
+TEST(PlainTextSerializer, CJKWithDisallowLineBreaking) {
   nsString test;
   nsString result;
 
   test.AssignLiteral("<html><body>");
   for (uint32_t i = 0; i < 400; i++) {
     // Insert Kanji (U+5341)
     test.Append(0x5341);
   }
   test.AppendLiteral("</body></html>");
 
-  ConvertBufToPlainText(test, nsIDocumentEncoder::OutputFormatted |
-                              nsIDocumentEncoder::OutputCRLineBreak |
-                              nsIDocumentEncoder::OutputLFLineBreak |
-                              nsIDocumentEncoder::OutputFormatFlowed |
-                              nsIDocumentEncoder::OutputDisallowLineBreaking);
+  ConvertBufToPlainText(test,
+                        nsIDocumentEncoder::OutputFormatted |
+                            nsIDocumentEncoder::OutputCRLineBreak |
+                            nsIDocumentEncoder::OutputLFLineBreak |
+                            nsIDocumentEncoder::OutputFormatFlowed |
+                            nsIDocumentEncoder::OutputDisallowLineBreaking);
 
   // create result case
   for (uint32_t i = 0; i < 400; i++) {
     result.Append(0x5341);
   }
   result.AppendLiteral("\r\n");
 
-  ASSERT_TRUE(test.Equals(result)) <<
-    "Wrong HTML to CJK text serialization with OutputDisallowLineBreaking";
+  ASSERT_TRUE(test.Equals(result))
+      << "Wrong HTML to CJK text serialization with OutputDisallowLineBreaking";
 }
 
 // Test for ASCII with format=flowed; and quoted lines in preformatted span.
-TEST(PlainTextSerializer, PreformatFlowedQuotes)
-{
+TEST(PlainTextSerializer, PreformatFlowedQuotes) {
   nsString test;
   nsString result;
 
-  test.AssignLiteral("<html><body>"
-                     "<span style=\"white-space: pre-wrap;\">"
-                     "&gt; Firefox Firefox Firefox Firefox <br>"
-                     "&gt; Firefox Firefox Firefox Firefox<br>"
-                     "&gt;<br>"
-                     "&gt;&gt; Firefox Firefox Firefox Firefox <br>"
-                     "&gt;&gt; Firefox Firefox Firefox Firefox<br>"
-                     "</span></body></html>");
+  test.AssignLiteral(
+      "<html><body>"
+      "<span style=\"white-space: pre-wrap;\">"
+      "&gt; Firefox Firefox Firefox Firefox <br>"
+      "&gt; Firefox Firefox Firefox Firefox<br>"
+      "&gt;<br>"
+      "&gt;&gt; Firefox Firefox Firefox Firefox <br>"
+      "&gt;&gt; Firefox Firefox Firefox Firefox<br>"
+      "</span></body></html>");
 
   ConvertBufToPlainText(test, nsIDocumentEncoder::OutputFormatted |
-                              nsIDocumentEncoder::OutputCRLineBreak |
-                              nsIDocumentEncoder::OutputLFLineBreak |
-                              nsIDocumentEncoder::OutputFormatFlowed);
+                                  nsIDocumentEncoder::OutputCRLineBreak |
+                                  nsIDocumentEncoder::OutputLFLineBreak |
+                                  nsIDocumentEncoder::OutputFormatFlowed);
 
   // create result case
-  result.AssignLiteral("> Firefox Firefox Firefox Firefox \r\n"
-                       "> Firefox Firefox Firefox Firefox\r\n"
-                       ">\r\n"
-                       ">> Firefox Firefox Firefox Firefox \r\n"
-                       ">> Firefox Firefox Firefox Firefox\r\n");
+  result.AssignLiteral(
+      "> Firefox Firefox Firefox Firefox \r\n"
+      "> Firefox Firefox Firefox Firefox\r\n"
+      ">\r\n"
+      ">> Firefox Firefox Firefox Firefox \r\n"
+      ">> Firefox Firefox Firefox Firefox\r\n");
 
-  ASSERT_TRUE(test.Equals(result)) <<
-    "Wrong HTML to ASCII text serialization with format=flowed; and quoted "
-    "lines";
+  ASSERT_TRUE(test.Equals(result)) << "Wrong HTML to ASCII text serialization "
+                                      "with format=flowed; and quoted "
+                                      "lines";
 }
 
-TEST(PlainTextSerializer, PrettyPrintedHtml)
-{
+TEST(PlainTextSerializer, PrettyPrintedHtml) {
   nsString test;
-  test.AppendLiteral(
-    "<html>" NS_LINEBREAK
-    "<body>" NS_LINEBREAK
-    "  first<br>" NS_LINEBREAK
-    "  second<br>" NS_LINEBREAK
-    "</body>" NS_LINEBREAK "</html>");
+  test.AppendLiteral("<html>" NS_LINEBREAK "<body>" NS_LINEBREAK
+                     "  first<br>" NS_LINEBREAK "  second<br>" NS_LINEBREAK
+                     "</body>" NS_LINEBREAK "</html>");
 
   ConvertBufToPlainText(test, 0);
-  ASSERT_TRUE(test.EqualsLiteral("first" NS_LINEBREAK "second" NS_LINEBREAK)) <<
-    "Wrong prettyprinted html to text serialization";
+  ASSERT_TRUE(test.EqualsLiteral("first" NS_LINEBREAK "second" NS_LINEBREAK))
+      << "Wrong prettyprinted html to text serialization";
 }
 
-TEST(PlainTextSerializer, PreElement)
-{
+TEST(PlainTextSerializer, PreElement) {
   nsString test;
-  test.AppendLiteral(
-    "<html>" NS_LINEBREAK
-    "<body>" NS_LINEBREAK
-    "<pre>" NS_LINEBREAK
-    "  first" NS_LINEBREAK
-    "  second" NS_LINEBREAK
-    "</pre>" NS_LINEBREAK
-    "</body>" NS_LINEBREAK "</html>");
+  test.AppendLiteral("<html>" NS_LINEBREAK "<body>" NS_LINEBREAK
+                     "<pre>" NS_LINEBREAK "  first" NS_LINEBREAK
+                     "  second" NS_LINEBREAK "</pre>" NS_LINEBREAK
+                     "</body>" NS_LINEBREAK "</html>");
 
   ConvertBufToPlainText(test, 0);
   ASSERT_TRUE(test.EqualsLiteral("  first" NS_LINEBREAK
-                                 "  second" NS_LINEBREAK NS_LINEBREAK)) <<
-    "Wrong prettyprinted html to text serialization";
+                                 "  second" NS_LINEBREAK NS_LINEBREAK))
+      << "Wrong prettyprinted html to text serialization";
 }
 
-TEST(PlainTextSerializer, BlockElement)
-{
+TEST(PlainTextSerializer, BlockElement) {
   nsString test;
-  test.AppendLiteral(
-    "<html>" NS_LINEBREAK
-    "<body>" NS_LINEBREAK
-    "<div>" NS_LINEBREAK
-    "  first" NS_LINEBREAK
-    "</div>" NS_LINEBREAK
-    "<div>" NS_LINEBREAK
-    "  second" NS_LINEBREAK
-    "</div>" NS_LINEBREAK
-    "</body>" NS_LINEBREAK "</html>");
+  test.AppendLiteral("<html>" NS_LINEBREAK "<body>" NS_LINEBREAK
+                     "<div>" NS_LINEBREAK "  first" NS_LINEBREAK
+                     "</div>" NS_LINEBREAK "<div>" NS_LINEBREAK
+                     "  second" NS_LINEBREAK "</div>" NS_LINEBREAK
+                     "</body>" NS_LINEBREAK "</html>");
 
   ConvertBufToPlainText(test, 0);
-  ASSERT_TRUE(test.EqualsLiteral("first" NS_LINEBREAK "second" NS_LINEBREAK)) <<
-    "Wrong prettyprinted html to text serialization";
+  ASSERT_TRUE(test.EqualsLiteral("first" NS_LINEBREAK "second" NS_LINEBREAK))
+      << "Wrong prettyprinted html to text serialization";
 }
 
-TEST(PlainTextSerializer, PreWrapElementForThunderbird)
-{
+TEST(PlainTextSerializer, PreWrapElementForThunderbird) {
   // This test examines the magic pre-wrap setup that Thunderbird relies on.
   nsString test;
   test.AppendLiteral(
-    "<html>" NS_LINEBREAK
-    "<body style=\"white-space: pre-wrap; width: 10ch;\">" NS_LINEBREAK
-    "<pre>" NS_LINEBREAK
-    "  first line is too long" NS_LINEBREAK
-    "  second line is even loooonger  " NS_LINEBREAK
-    "</pre>" NS_LINEBREAK
-    "</body>" NS_LINEBREAK "</html>");
+      "<html>" NS_LINEBREAK
+      "<body style=\"white-space: pre-wrap; width: 10ch;\">" NS_LINEBREAK
+      "<pre>" NS_LINEBREAK "  first line is too long" NS_LINEBREAK
+      "  second line is even loooonger  " NS_LINEBREAK "</pre>" NS_LINEBREAK
+      "</body>" NS_LINEBREAK "</html>");
 
   ConvertBufToPlainText(test, nsIDocumentEncoder::OutputWrap);
   // "\n\n  first\nline is\ntoo long\n  second\nline is\neven\nloooonger\n\n\n"
-  ASSERT_TRUE(test.EqualsLiteral(NS_LINEBREAK NS_LINEBREAK
-                                 "  first" NS_LINEBREAK
-                                 "line is" NS_LINEBREAK
-                                 "too long" NS_LINEBREAK
-                                 "  second" NS_LINEBREAK
-                                 "line is" NS_LINEBREAK
-                                 "even" NS_LINEBREAK
-                                 "loooonger" NS_LINEBREAK
-                                 NS_LINEBREAK NS_LINEBREAK)) <<
-    "Wrong prettyprinted html to text serialization";
+  ASSERT_TRUE(test.EqualsLiteral(
+      NS_LINEBREAK NS_LINEBREAK
+      "  first" NS_LINEBREAK "line is" NS_LINEBREAK "too long" NS_LINEBREAK
+      "  second" NS_LINEBREAK "line is" NS_LINEBREAK "even" NS_LINEBREAK
+      "loooonger" NS_LINEBREAK NS_LINEBREAK NS_LINEBREAK))
+      << "Wrong prettyprinted html to text serialization";
 }
 
-TEST(PlainTextSerializer, Simple)
-{
+TEST(PlainTextSerializer, Simple) {
   nsString test;
-  test.AppendLiteral("<html><base>base</base><head><span>span</span></head>"
-                     "<body>body</body></html>");
+  test.AppendLiteral(
+      "<html><base>base</base><head><span>span</span></head>"
+      "<body>body</body></html>");
   ConvertBufToPlainText(test, 0);
-  ASSERT_TRUE(test.EqualsLiteral("basespanbody")) <<
-    "Wrong html to text serialization";
+  ASSERT_TRUE(test.EqualsLiteral("basespanbody"))
+      << "Wrong html to text serialization";
 }
-

--- a/dom/base/test/gtest/TestXPathGenerator.cpp
+++ b/dom/base/test/gtest/TestXPathGenerator.cpp
@@ -3,138 +3,139 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "gtest/gtest.h"
 #include "XPathGenerator.h"
 #include "nsString.h"
 
-TEST(TestXPathGenerator, TestQuoteArgumentWithoutQuote)
-{
+TEST(TestXPathGenerator, TestQuoteArgumentWithoutQuote) {
   nsAutoString arg;
   arg.AssignLiteral(u"testing");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"\'testing\'");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestQuoteArgumentWithSingleQuote)
-{
+TEST(TestXPathGenerator, TestQuoteArgumentWithSingleQuote) {
   nsAutoString arg;
   arg.AssignLiteral(u"\'testing\'");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"\"\'testing\'\"");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestQuoteArgumentWithDoubleQuote)
-{
+TEST(TestXPathGenerator, TestQuoteArgumentWithDoubleQuote) {
   nsAutoString arg;
   arg.AssignLiteral(u"\"testing\"");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"\'\"testing\"\'");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestQuoteArgumentWithSingleAndDoubleQuote)
-{
+TEST(TestXPathGenerator, TestQuoteArgumentWithSingleAndDoubleQuote) {
   nsAutoString arg;
   arg.AssignLiteral(u"\'testing\"");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"concat(\'\',\"\'\",\'testing\"\')");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
-  printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(), NS_ConvertUTF16toUTF8(expectedResult).get());
+  printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(),
+         NS_ConvertUTF16toUTF8(expectedResult).get());
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestQuoteArgumentWithDoubleQuoteAndASequenceOfSingleQuote)
-{
+TEST(TestXPathGenerator,
+     TestQuoteArgumentWithDoubleQuoteAndASequenceOfSingleQuote) {
   nsAutoString arg;
   arg.AssignLiteral(u"\'\'\'\'testing\"");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"concat(\'\',\"\'\'\'\'\",\'testing\"\')");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
-  printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(), NS_ConvertUTF16toUTF8(expectedResult).get());
+  printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(),
+         NS_ConvertUTF16toUTF8(expectedResult).get());
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestQuoteArgumentWithDoubleQuoteAndTwoSequencesOfSingleQuote)
-{
+TEST(TestXPathGenerator,
+     TestQuoteArgumentWithDoubleQuoteAndTwoSequencesOfSingleQuote) {
   nsAutoString arg;
   arg.AssignLiteral(u"\'\'\'\'testing\'\'\'\'\'\'\"");
 
   nsAutoString expectedResult;
-  expectedResult.AssignLiteral(u"concat(\'\',\"\'\'\'\'\",\'testing\',\"\'\'\'\'\'\'\",\'\"\')");
+  expectedResult.AssignLiteral(
+      u"concat(\'\',\"\'\'\'\'\",\'testing\',\"\'\'\'\'\'\'\",\'\"\')");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
-  printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(), NS_ConvertUTF16toUTF8(expectedResult).get());
+  printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(),
+         NS_ConvertUTF16toUTF8(expectedResult).get());
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestQuoteArgumentWithDoubleQuoteAndTwoSequencesOfSingleQuoteInMiddle)
-{
+TEST(TestXPathGenerator,
+     TestQuoteArgumentWithDoubleQuoteAndTwoSequencesOfSingleQuoteInMiddle) {
   nsAutoString arg;
   arg.AssignLiteral(u"t\'\'\'\'estin\'\'\'\'\'\'\"g");
 
   nsAutoString expectedResult;
-  expectedResult.AssignLiteral(u"concat(\'t\',\"\'\'\'\'\",\'estin\',\"\'\'\'\'\'\'\",\'\"g\')");
+  expectedResult.AssignLiteral(
+      u"concat(\'t\',\"\'\'\'\'\",\'estin\',\"\'\'\'\'\'\'\",\'\"g\')");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
-  printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(), NS_ConvertUTF16toUTF8(expectedResult).get());
+  printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(),
+         NS_ConvertUTF16toUTF8(expectedResult).get());
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestEscapeNameWithNormalCharacters)
-{
+TEST(TestXPathGenerator, TestEscapeNameWithNormalCharacters) {
   nsAutoString arg;
   arg.AssignLiteral(u"testing");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"testing");
 
   nsAutoString result;
   XPathGenerator::EscapeName(arg, result);
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestEscapeNameWithSpecialCharacters)
-{
+TEST(TestXPathGenerator, TestEscapeNameWithSpecialCharacters) {
   nsAutoString arg;
   arg.AssignLiteral(u"^testing!");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"*[local-name()=\'^testing!\']");
 
   nsAutoString result;
   XPathGenerator::EscapeName(arg, result);
-  printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(), NS_ConvertUTF16toUTF8(expectedResult).get());
+  printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(),
+         NS_ConvertUTF16toUTF8(expectedResult).get());
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }

--- a/dom/bindings/test/TestBindingHeader.h
+++ b/dom/bindings/test/TestBindingHeader.h
@@ -12,206 +12,203 @@
 #include "mozilla/dom/Date.h"
 #include "mozilla/dom/Record.h"
 #include "mozilla/dom/TypedArray.h"
 #include "mozilla/ErrorResult.h"
 #include "nsCOMPtr.h"
 #include "nsGenericHTMLElement.h"
 #include "nsWrapperCache.h"
 
-// Forward declare this before we include TestCodeGenBinding.h, because that header relies on including
-// this one for it, for ParentDict. Hopefully it won't begin to rely on it in more fundamental ways.
+// Forward declare this before we include TestCodeGenBinding.h, because that
+// header relies on including this one for it, for ParentDict. Hopefully it
+// won't begin to rely on it in more fundamental ways.
 namespace mozilla {
 namespace dom {
 class DocGroup;
 class TestExternalInterface;
 class Promise;
-} // namespace dom
-} // namespace mozilla
+}  // namespace dom
+}  // namespace mozilla
 
 // We don't export TestCodeGenBinding.h, but it's right in our parent dir.
 #ifdef XP_WIN
 // If we're on windows, simulate including windows.h. This step will cause
 // compilation failure if NeedsWindowsUndef is not defined.
 #define NO_ERROR 0x1
 #endif
 #include "../TestCodeGenBinding.h"
 
 extern bool TestFuncControlledMember(JSContext*, JSObject*);
 
 namespace mozilla {
 namespace dom {
 
 // IID for nsRenamedInterface
-#define NS_RENAMED_INTERFACE_IID \
-{ 0xd4b19ef3, 0xe68b, 0x4e3f, \
- { 0x94, 0xbc, 0xc9, 0xde, 0x3a, 0x69, 0xb0, 0xe8 } }
+#define NS_RENAMED_INTERFACE_IID                     \
+  {                                                  \
+    0xd4b19ef3, 0xe68b, 0x4e3f, {                    \
+      0x94, 0xbc, 0xc9, 0xde, 0x3a, 0x69, 0xb0, 0xe8 \
+    }                                                \
+  }
 
-class nsRenamedInterface : public nsISupports,
-                           public nsWrapperCache
-{
-public:
+class nsRenamedInterface : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_RENAMED_INTERFACE_IID)
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsRenamedInterface, NS_RENAMED_INTERFACE_IID)
 
 // IID for the IndirectlyImplementedInterface
-#define NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID \
-{ 0xfed55b69, 0x7012, 0x4849, \
- { 0xaf, 0x56, 0x4b, 0xa9, 0xee, 0x41, 0x30, 0x89 } }
+#define NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID      \
+  {                                                  \
+    0xfed55b69, 0x7012, 0x4849, {                    \
+      0xaf, 0x56, 0x4b, 0xa9, 0xee, 0x41, 0x30, 0x89 \
+    }                                                \
+  }
 
 class IndirectlyImplementedInterface : public nsISupports,
-                                       public nsWrapperCache
-{
-public:
+                                       public nsWrapperCache {
+ public:
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID)
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   bool IndirectlyImplementedProperty();
   void IndirectlyImplementedProperty(bool);
   void IndirectlyImplementedMethod();
 };
 
-NS_DEFINE_STATIC_IID_ACCESSOR(IndirectlyImplementedInterface, NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID)
+NS_DEFINE_STATIC_IID_ACCESSOR(IndirectlyImplementedInterface,
+                              NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID)
 
 // IID for the TestExternalInterface
-#define NS_TEST_EXTERNAL_INTERFACE_IID \
-{ 0xd5ba0c99, 0x9b1d, 0x4e71, \
- { 0x8a, 0x94, 0x56, 0x38, 0x6c, 0xa3, 0xda, 0x3d } }
-class TestExternalInterface : public nsISupports
-{
-public:
+#define NS_TEST_EXTERNAL_INTERFACE_IID               \
+  {                                                  \
+    0xd5ba0c99, 0x9b1d, 0x4e71, {                    \
+      0x8a, 0x94, 0x56, 0x38, 0x6c, 0xa3, 0xda, 0x3d \
+    }                                                \
+  }
+class TestExternalInterface : public nsISupports {
+ public:
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_TEST_EXTERNAL_INTERFACE_IID)
   NS_DECL_ISUPPORTS
 };
 
-NS_DEFINE_STATIC_IID_ACCESSOR(TestExternalInterface, NS_TEST_EXTERNAL_INTERFACE_IID)
+NS_DEFINE_STATIC_IID_ACCESSOR(TestExternalInterface,
+                              NS_TEST_EXTERNAL_INTERFACE_IID)
 
-class TestNonWrapperCacheInterface : public nsISupports
-{
-public:
+class TestNonWrapperCacheInterface : public nsISupports {
+ public:
   NS_DECL_ISUPPORTS
 
-  bool WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
+  bool WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto,
+                  JS::MutableHandle<JSObject*> aReflector);
 };
 
-class OnlyForUseInConstructor : public nsISupports,
-                                public nsWrapperCache
-{
-public:
+class OnlyForUseInConstructor : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 };
 
-class TestInterface : public nsISupports,
-                      public nsWrapperCache
-{
-public:
+class TestInterface : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject and GetDocGroup to make binding codegen happy
   virtual nsISupports* GetParentObject();
   DocGroup* GetDocGroup() const;
 
   // And now our actual WebIDL API
   // Constructors
-  static
-  already_AddRefed<TestInterface>
-    Constructor(const GlobalObject&, ErrorResult&);
-  static
-  already_AddRefed<TestInterface>
-    Constructor(const GlobalObject&, const nsAString&, ErrorResult&);
-  static
-  already_AddRefed<TestInterface>
-    Constructor(const GlobalObject&, uint32_t, const Nullable<bool>&,
-                ErrorResult&);
-  static
-  already_AddRefed<TestInterface>
-    Constructor(const GlobalObject&, TestInterface*, ErrorResult&);
-  static
-  already_AddRefed<TestInterface>
-    Constructor(const GlobalObject&, uint32_t, IndirectlyImplementedInterface&, ErrorResult&);
+  static already_AddRefed<TestInterface> Constructor(const GlobalObject&,
+                                                     ErrorResult&);
+  static already_AddRefed<TestInterface> Constructor(const GlobalObject&,
+                                                     const nsAString&,
+                                                     ErrorResult&);
+  static already_AddRefed<TestInterface> Constructor(const GlobalObject&,
+                                                     uint32_t,
+                                                     const Nullable<bool>&,
+                                                     ErrorResult&);
+  static already_AddRefed<TestInterface> Constructor(const GlobalObject&,
+                                                     TestInterface*,
+                                                     ErrorResult&);
+  static already_AddRefed<TestInterface> Constructor(
+      const GlobalObject&, uint32_t, IndirectlyImplementedInterface&,
+      ErrorResult&);
 
-  static
-  already_AddRefed<TestInterface>
-    Constructor(const GlobalObject&, Date&, ErrorResult&);
-  static
-  already_AddRefed<TestInterface>
-    Constructor(const GlobalObject&, const ArrayBuffer&, ErrorResult&);
-  static
-  already_AddRefed<TestInterface>
-    Constructor(const GlobalObject&, const Uint8Array&, ErrorResult&);
+  static already_AddRefed<TestInterface> Constructor(const GlobalObject&, Date&,
+                                                     ErrorResult&);
+  static already_AddRefed<TestInterface> Constructor(const GlobalObject&,
+                                                     const ArrayBuffer&,
+                                                     ErrorResult&);
+  static already_AddRefed<TestInterface> Constructor(const GlobalObject&,
+                                                     const Uint8Array&,
+                                                     ErrorResult&);
   /*  static
   already_AddRefed<TestInterface>
     Constructor(const GlobalObject&, uint32_t, uint32_t,
                 const TestInterfaceOrOnlyForUseInConstructor&, ErrorResult&);
   */
 
-  static
-  already_AddRefed<TestInterface> Test(const GlobalObject&, ErrorResult&);
-  static
-  already_AddRefed<TestInterface> Test(const GlobalObject&, const nsAString&,
-                                       ErrorResult&);
-  static
-  already_AddRefed<TestInterface> Test(const GlobalObject&, const nsACString&,
-                                       ErrorResult&);
+  static already_AddRefed<TestInterface> Test(const GlobalObject&,
+                                              ErrorResult&);
+  static already_AddRefed<TestInterface> Test(const GlobalObject&,
+                                              const nsAString&, ErrorResult&);
+  static already_AddRefed<TestInterface> Test(const GlobalObject&,
+                                              const nsACString&, ErrorResult&);
+
+  static already_AddRefed<TestInterface> Test2(
+      const GlobalObject&, const DictForConstructor&, JS::Handle<JS::Value>,
+      JS::Handle<JSObject*>, JS::Handle<JSObject*>, const Sequence<Dict>&,
+      JS::Handle<JS::Value>, const Optional<JS::Handle<JSObject*>>&,
+      const Optional<JS::Handle<JSObject*>>&, ErrorResult&);
+
+  static already_AddRefed<TestInterface> Test3(const GlobalObject&,
+                                               const LongOrStringAnyRecord&,
+                                               ErrorResult&);
 
-  static
-  already_AddRefed<TestInterface> Test2(const GlobalObject&,
-                                        const DictForConstructor&,
-                                        JS::Handle<JS::Value>,
-                                        JS::Handle<JSObject*>,
-                                        JS::Handle<JSObject*>,
-                                        const Sequence<Dict>&,
-                                        JS::Handle<JS::Value>,
-                                        const Optional<JS::Handle<JSObject*> >&,
-                                        const Optional<JS::Handle<JSObject*> >&,
-                                        ErrorResult&);
+  static already_AddRefed<TestInterface> Test4(
+      const GlobalObject&, const Record<nsString, Record<nsString, JS::Value>>&,
+      ErrorResult&);
 
-  static
-  already_AddRefed<TestInterface> Test3(const GlobalObject&,
-                                        const LongOrStringAnyRecord&,
-                                        ErrorResult&);
-
-  static
-  already_AddRefed<TestInterface> Test4(const GlobalObject&,
-                                        const Record<nsString, Record<nsString, JS::Value>>&,
-                                        ErrorResult&);
+  static already_AddRefed<TestInterface> Test5(
+      const GlobalObject&,
+      const Record<
+          nsString,
+          Sequence<Record<nsString,
+                          Record<nsString, Sequence<Sequence<JS::Value>>>>>>&,
+      ErrorResult&);
 
-  static
-  already_AddRefed<TestInterface> Test5(const GlobalObject&,
-                                        const Record<nsString, Sequence<Record<nsString, Record<nsString, Sequence<Sequence<JS::Value>>>>>>&,
-                                        ErrorResult&);
-
-  static
-  already_AddRefed<TestInterface> Test6(const GlobalObject&,
-                                        const Sequence<Record<nsCString, Sequence<Sequence<Record<nsCString, Record<nsString, JS::Value>>>>>>&,
-                                        ErrorResult&);
+  static already_AddRefed<TestInterface> Test6(
+      const GlobalObject&,
+      const Sequence<Record<
+          nsCString,
+          Sequence<Sequence<Record<nsCString, Record<nsString, JS::Value>>>>>>&,
+      ErrorResult&);
 
   // Integer types
   int8_t ReadonlyByte();
   int8_t WritableByte();
   void SetWritableByte(int8_t);
   void PassByte(int8_t);
   int8_t ReceiveByte();
   void PassOptionalByte(const Optional<int8_t>&);
   void PassOptionalByteBeforeRequired(const Optional<int8_t>&, int8_t);
   void PassOptionalByteWithDefault(int8_t);
   void PassOptionalByteWithDefaultBeforeRequired(int8_t, int8_t);
   void PassNullableByte(const Nullable<int8_t>&);
-  void PassOptionalNullableByte(const Optional< Nullable<int8_t> >&);
+  void PassOptionalNullableByte(const Optional<Nullable<int8_t>>&);
   void PassVariadicByte(const Sequence<int8_t>&);
   int8_t CachedByte();
   int8_t CachedConstantByte();
   int8_t CachedWritableByte();
   void SetCachedWritableByte(int8_t);
   int8_t SideEffectFreeByte();
   void SetSideEffectFreeByte(int8_t);
   int8_t DomDependentByte();
@@ -295,80 +292,81 @@ public:
   void SetWritableDouble(double);
   double WritableUnrestrictedDouble() const;
   void SetWritableUnrestrictedDouble(double);
   Nullable<double> GetWritableNullableDouble() const;
   void SetWritableNullableDouble(const Nullable<double>&);
   Nullable<double> GetWritableNullableUnrestrictedDouble() const;
   void SetWritableNullableUnrestrictedDouble(const Nullable<double>&);
   void PassFloat(float, float, const Nullable<float>&, const Nullable<float>&,
-                 double, double, const Nullable<double>&, const Nullable<double>&,
-                 const Sequence<float>&, const Sequence<float>&,
-                 const Sequence<Nullable<float> >&,
-                 const Sequence<Nullable<float> >&,
-                 const Sequence<double>&, const Sequence<double>&,
-                 const Sequence<Nullable<double> >&,
-                 const Sequence<Nullable<double> >&);
-  void PassLenientFloat(float, float, const Nullable<float>&, const Nullable<float>&,
-                        double, double, const Nullable<double>&, const Nullable<double>&,
+                 double, double, const Nullable<double>&,
+                 const Nullable<double>&, const Sequence<float>&,
+                 const Sequence<float>&, const Sequence<Nullable<float>>&,
+                 const Sequence<Nullable<float>>&, const Sequence<double>&,
+                 const Sequence<double>&, const Sequence<Nullable<double>>&,
+                 const Sequence<Nullable<double>>&);
+  void PassLenientFloat(float, float, const Nullable<float>&,
+                        const Nullable<float>&, double, double,
+                        const Nullable<double>&, const Nullable<double>&,
                         const Sequence<float>&, const Sequence<float>&,
-                        const Sequence<Nullable<float> >&,
-                        const Sequence<Nullable<float> >&,
+                        const Sequence<Nullable<float>>&,
+                        const Sequence<Nullable<float>>&,
                         const Sequence<double>&, const Sequence<double>&,
-                        const Sequence<Nullable<double> >&,
-                        const Sequence<Nullable<double> >&);
+                        const Sequence<Nullable<double>>&,
+                        const Sequence<Nullable<double>>&);
   float LenientFloatAttr() const;
   void SetLenientFloatAttr(float);
   double LenientDoubleAttr() const;
   void SetLenientDoubleAttr(double);
 
-  void PassUnrestricted(float arg1,
-                        float arg2,
-                        float arg3,
-                        float arg4,
-                        double arg5,
-                        double arg6,
-                        double arg7,
-                        double arg8);
+  void PassUnrestricted(float arg1, float arg2, float arg3, float arg4,
+                        double arg5, double arg6, double arg7, double arg8);
 
   // Interface types
   already_AddRefed<TestInterface> ReceiveSelf();
   already_AddRefed<TestInterface> ReceiveNullableSelf();
   TestInterface* ReceiveWeakSelf();
   TestInterface* ReceiveWeakNullableSelf();
   void PassSelf(TestInterface&);
   void PassNullableSelf(TestInterface*);
   already_AddRefed<TestInterface> NonNullSelf();
   void SetNonNullSelf(TestInterface&);
   already_AddRefed<TestInterface> GetNullableSelf();
   already_AddRefed<TestInterface> CachedSelf();
   void SetNullableSelf(TestInterface*);
-  void PassOptionalSelf(const Optional<TestInterface*> &);
-  void PassOptionalNonNullSelf(const Optional<NonNull<TestInterface> >&);
+  void PassOptionalSelf(const Optional<TestInterface*>&);
+  void PassOptionalNonNullSelf(const Optional<NonNull<TestInterface>>&);
   void PassOptionalSelfWithDefault(TestInterface*);
 
-  already_AddRefed<TestNonWrapperCacheInterface> ReceiveNonWrapperCacheInterface();
-  already_AddRefed<TestNonWrapperCacheInterface> ReceiveNullableNonWrapperCacheInterface();
-  void ReceiveNonWrapperCacheInterfaceSequence(nsTArray<RefPtr<TestNonWrapperCacheInterface> >&);
-  void ReceiveNullableNonWrapperCacheInterfaceSequence(nsTArray<RefPtr<TestNonWrapperCacheInterface> >&);
-  void ReceiveNonWrapperCacheInterfaceNullableSequence(Nullable<nsTArray<RefPtr<TestNonWrapperCacheInterface> > >&);
-  void ReceiveNullableNonWrapperCacheInterfaceNullableSequence(Nullable<nsTArray<RefPtr<TestNonWrapperCacheInterface> > >&);
+  already_AddRefed<TestNonWrapperCacheInterface>
+  ReceiveNonWrapperCacheInterface();
+  already_AddRefed<TestNonWrapperCacheInterface>
+  ReceiveNullableNonWrapperCacheInterface();
+  void ReceiveNonWrapperCacheInterfaceSequence(
+      nsTArray<RefPtr<TestNonWrapperCacheInterface>>&);
+  void ReceiveNullableNonWrapperCacheInterfaceSequence(
+      nsTArray<RefPtr<TestNonWrapperCacheInterface>>&);
+  void ReceiveNonWrapperCacheInterfaceNullableSequence(
+      Nullable<nsTArray<RefPtr<TestNonWrapperCacheInterface>>>&);
+  void ReceiveNullableNonWrapperCacheInterfaceNullableSequence(
+      Nullable<nsTArray<RefPtr<TestNonWrapperCacheInterface>>>&);
 
   already_AddRefed<IndirectlyImplementedInterface> ReceiveOther();
   already_AddRefed<IndirectlyImplementedInterface> ReceiveNullableOther();
   IndirectlyImplementedInterface* ReceiveWeakOther();
   IndirectlyImplementedInterface* ReceiveWeakNullableOther();
   void PassOther(IndirectlyImplementedInterface&);
   void PassNullableOther(IndirectlyImplementedInterface*);
   already_AddRefed<IndirectlyImplementedInterface> NonNullOther();
   void SetNonNullOther(IndirectlyImplementedInterface&);
   already_AddRefed<IndirectlyImplementedInterface> GetNullableOther();
   void SetNullableOther(IndirectlyImplementedInterface*);
   void PassOptionalOther(const Optional<IndirectlyImplementedInterface*>&);
-  void PassOptionalNonNullOther(const Optional<NonNull<IndirectlyImplementedInterface> >&);
+  void PassOptionalNonNullOther(
+      const Optional<NonNull<IndirectlyImplementedInterface>>&);
   void PassOptionalOtherWithDefault(IndirectlyImplementedInterface*);
 
   already_AddRefed<TestExternalInterface> ReceiveExternal();
   already_AddRefed<TestExternalInterface> ReceiveNullableExternal();
   TestExternalInterface* ReceiveWeakExternal();
   TestExternalInterface* ReceiveWeakNullableExternal();
   void PassExternal(TestExternalInterface*);
   void PassNullableExternal(TestExternalInterface*);
@@ -385,127 +383,167 @@ public:
   TestCallbackInterface* ReceiveWeakCallbackInterface();
   TestCallbackInterface* ReceiveWeakNullableCallbackInterface();
   void PassCallbackInterface(TestCallbackInterface&);
   void PassNullableCallbackInterface(TestCallbackInterface*);
   already_AddRefed<TestCallbackInterface> NonNullCallbackInterface();
   void SetNonNullCallbackInterface(TestCallbackInterface&);
   already_AddRefed<TestCallbackInterface> GetNullableCallbackInterface();
   void SetNullableCallbackInterface(TestCallbackInterface*);
-  void PassOptionalCallbackInterface(const Optional<RefPtr<TestCallbackInterface> >&);
-  void PassOptionalNonNullCallbackInterface(const Optional<OwningNonNull<TestCallbackInterface> >&);
+  void PassOptionalCallbackInterface(
+      const Optional<RefPtr<TestCallbackInterface>>&);
+  void PassOptionalNonNullCallbackInterface(
+      const Optional<OwningNonNull<TestCallbackInterface>>&);
   void PassOptionalCallbackInterfaceWithDefault(TestCallbackInterface*);
 
-  already_AddRefed<IndirectlyImplementedInterface> ReceiveConsequentialInterface();
+  already_AddRefed<IndirectlyImplementedInterface>
+  ReceiveConsequentialInterface();
   void PassConsequentialInterface(IndirectlyImplementedInterface&);
 
   // Sequence types
   void GetReadonlySequence(nsTArray<int32_t>&);
   void GetReadonlySequenceOfDictionaries(JSContext*, nsTArray<Dict>&);
-  void GetReadonlyNullableSequenceOfDictionaries(JSContext*, Nullable<nsTArray<Dict> >&);
+  void GetReadonlyNullableSequenceOfDictionaries(JSContext*,
+                                                 Nullable<nsTArray<Dict>>&);
   void GetReadonlyFrozenSequence(JSContext*, nsTArray<Dict>&);
   void GetReadonlyFrozenNullableSequence(JSContext*, Nullable<nsTArray<Dict>>&);
   void ReceiveSequence(nsTArray<int32_t>&);
-  void ReceiveNullableSequence(Nullable< nsTArray<int32_t> >&);
-  void ReceiveSequenceOfNullableInts(nsTArray< Nullable<int32_t> >&);
-  void ReceiveNullableSequenceOfNullableInts(Nullable< nsTArray< Nullable<int32_t> > >&);
-  void PassSequence(const Sequence<int32_t> &);
-  void PassNullableSequence(const Nullable< Sequence<int32_t> >&);
-  void PassSequenceOfNullableInts(const Sequence<Nullable<int32_t> >&);
-  void PassOptionalSequenceOfNullableInts(const Optional<Sequence<Nullable<int32_t> > > &);
-  void PassOptionalNullableSequenceOfNullableInts(const Optional<Nullable<Sequence<Nullable<int32_t> > > > &);
-  void ReceiveCastableObjectSequence(nsTArray< RefPtr<TestInterface> > &);
-  void ReceiveCallbackObjectSequence(nsTArray< RefPtr<TestCallbackInterface> > &);
-  void ReceiveNullableCastableObjectSequence(nsTArray< RefPtr<TestInterface> > &);
-  void ReceiveNullableCallbackObjectSequence(nsTArray< RefPtr<TestCallbackInterface> > &);
-  void ReceiveCastableObjectNullableSequence(Nullable< nsTArray< RefPtr<TestInterface> > >&);
-  void ReceiveNullableCastableObjectNullableSequence(Nullable< nsTArray< RefPtr<TestInterface> > >&);
-  void ReceiveWeakCastableObjectSequence(nsTArray<RefPtr<TestInterface>> &);
-  void ReceiveWeakNullableCastableObjectSequence(nsTArray<RefPtr<TestInterface>> &);
-  void ReceiveWeakCastableObjectNullableSequence(Nullable< nsTArray<RefPtr<TestInterface>> >&);
-  void ReceiveWeakNullableCastableObjectNullableSequence(Nullable< nsTArray<RefPtr<TestInterface>> >&);
-  void PassCastableObjectSequence(const Sequence< OwningNonNull<TestInterface> >&);
-  void PassNullableCastableObjectSequence(const Sequence< RefPtr<TestInterface> > &);
-  void PassCastableObjectNullableSequence(const Nullable< Sequence< OwningNonNull<TestInterface> > >&);
-  void PassNullableCastableObjectNullableSequence(const Nullable< Sequence< RefPtr<TestInterface> > >&);
-  void PassOptionalSequence(const Optional<Sequence<int32_t> >&);
-  void PassOptionalSequenceWithDefaultValue(const Sequence<int32_t> &);
-  void PassOptionalNullableSequence(const Optional<Nullable<Sequence<int32_t> > >&);
-  void PassOptionalNullableSequenceWithDefaultValue(const Nullable< Sequence<int32_t> >&);
-  void PassOptionalNullableSequenceWithDefaultValue2(const Nullable< Sequence<int32_t> >&);
-  void PassOptionalObjectSequence(const Optional<Sequence<OwningNonNull<TestInterface> > >&);
-  void PassExternalInterfaceSequence(const Sequence<RefPtr<TestExternalInterface> >&);
-  void PassNullableExternalInterfaceSequence(const Sequence<RefPtr<TestExternalInterface> >&);
+  void ReceiveNullableSequence(Nullable<nsTArray<int32_t>>&);
+  void ReceiveSequenceOfNullableInts(nsTArray<Nullable<int32_t>>&);
+  void ReceiveNullableSequenceOfNullableInts(
+      Nullable<nsTArray<Nullable<int32_t>>>&);
+  void PassSequence(const Sequence<int32_t>&);
+  void PassNullableSequence(const Nullable<Sequence<int32_t>>&);
+  void PassSequenceOfNullableInts(const Sequence<Nullable<int32_t>>&);
+  void PassOptionalSequenceOfNullableInts(
+      const Optional<Sequence<Nullable<int32_t>>>&);
+  void PassOptionalNullableSequenceOfNullableInts(
+      const Optional<Nullable<Sequence<Nullable<int32_t>>>>&);
+  void ReceiveCastableObjectSequence(nsTArray<RefPtr<TestInterface>>&);
+  void ReceiveCallbackObjectSequence(nsTArray<RefPtr<TestCallbackInterface>>&);
+  void ReceiveNullableCastableObjectSequence(nsTArray<RefPtr<TestInterface>>&);
+  void ReceiveNullableCallbackObjectSequence(
+      nsTArray<RefPtr<TestCallbackInterface>>&);
+  void ReceiveCastableObjectNullableSequence(
+      Nullable<nsTArray<RefPtr<TestInterface>>>&);
+  void ReceiveNullableCastableObjectNullableSequence(
+      Nullable<nsTArray<RefPtr<TestInterface>>>&);
+  void ReceiveWeakCastableObjectSequence(nsTArray<RefPtr<TestInterface>>&);
+  void ReceiveWeakNullableCastableObjectSequence(
+      nsTArray<RefPtr<TestInterface>>&);
+  void ReceiveWeakCastableObjectNullableSequence(
+      Nullable<nsTArray<RefPtr<TestInterface>>>&);
+  void ReceiveWeakNullableCastableObjectNullableSequence(
+      Nullable<nsTArray<RefPtr<TestInterface>>>&);
+  void PassCastableObjectSequence(
+      const Sequence<OwningNonNull<TestInterface>>&);
+  void PassNullableCastableObjectSequence(
+      const Sequence<RefPtr<TestInterface>>&);
+  void PassCastableObjectNullableSequence(
+      const Nullable<Sequence<OwningNonNull<TestInterface>>>&);
+  void PassNullableCastableObjectNullableSequence(
+      const Nullable<Sequence<RefPtr<TestInterface>>>&);
+  void PassOptionalSequence(const Optional<Sequence<int32_t>>&);
+  void PassOptionalSequenceWithDefaultValue(const Sequence<int32_t>&);
+  void PassOptionalNullableSequence(
+      const Optional<Nullable<Sequence<int32_t>>>&);
+  void PassOptionalNullableSequenceWithDefaultValue(
+      const Nullable<Sequence<int32_t>>&);
+  void PassOptionalNullableSequenceWithDefaultValue2(
+      const Nullable<Sequence<int32_t>>&);
+  void PassOptionalObjectSequence(
+      const Optional<Sequence<OwningNonNull<TestInterface>>>&);
+  void PassExternalInterfaceSequence(
+      const Sequence<RefPtr<TestExternalInterface>>&);
+  void PassNullableExternalInterfaceSequence(
+      const Sequence<RefPtr<TestExternalInterface>>&);
 
   void ReceiveStringSequence(nsTArray<nsString>&);
   void PassStringSequence(const Sequence<nsString>&);
 
   void ReceiveByteStringSequence(nsTArray<nsCString>&);
   void PassByteStringSequence(const Sequence<nsCString>&);
 
   void ReceiveAnySequence(JSContext*, nsTArray<JS::Value>&);
-  void ReceiveNullableAnySequence(JSContext*, Nullable<nsTArray<JS::Value> >&);
-  void ReceiveAnySequenceSequence(JSContext*, nsTArray<nsTArray<JS::Value> >&);
+  void ReceiveNullableAnySequence(JSContext*, Nullable<nsTArray<JS::Value>>&);
+  void ReceiveAnySequenceSequence(JSContext*, nsTArray<nsTArray<JS::Value>>&);
 
   void ReceiveObjectSequence(JSContext*, nsTArray<JSObject*>&);
   void ReceiveNullableObjectSequence(JSContext*, nsTArray<JSObject*>&);
 
-  void PassSequenceOfSequences(const Sequence< Sequence<int32_t> >&);
-  void PassSequenceOfSequencesOfSequences(const Sequence<Sequence<Sequence<int32_t>>>&);
-  void ReceiveSequenceOfSequences(nsTArray< nsTArray<int32_t> >&);
-  void ReceiveSequenceOfSequencesOfSequences(nsTArray<nsTArray<nsTArray<int32_t>>>&);
+  void PassSequenceOfSequences(const Sequence<Sequence<int32_t>>&);
+  void PassSequenceOfSequencesOfSequences(
+      const Sequence<Sequence<Sequence<int32_t>>>&);
+  void ReceiveSequenceOfSequences(nsTArray<nsTArray<int32_t>>&);
+  void ReceiveSequenceOfSequencesOfSequences(
+      nsTArray<nsTArray<nsTArray<int32_t>>>&);
 
   // Record types
-  void PassRecord(const Record<nsString, int32_t> &);
-  void PassNullableRecord(const Nullable< Record<nsString, int32_t> >&);
-  void PassRecordOfNullableInts(const Record<nsString, Nullable<int32_t> >&);
-  void PassOptionalRecordOfNullableInts(const Optional<Record<nsString, Nullable<int32_t> > > &);
-  void PassOptionalNullableRecordOfNullableInts(const Optional<Nullable<Record<nsString, Nullable<int32_t> > > > &);
-  void PassCastableObjectRecord(const Record<nsString,  OwningNonNull<TestInterface> >&);
-  void PassNullableCastableObjectRecord(const Record<nsString,  RefPtr<TestInterface> > &);
-  void PassCastableObjectNullableRecord(const Nullable< Record<nsString,  OwningNonNull<TestInterface> > >&);
-  void PassNullableCastableObjectNullableRecord(const Nullable< Record<nsString,  RefPtr<TestInterface> > >&);
-  void PassOptionalRecord(const Optional<Record<nsString, int32_t> >&);
-  void PassOptionalNullableRecord(const Optional<Nullable<Record<nsString, int32_t> > >&);
-  void PassOptionalNullableRecordWithDefaultValue(const Nullable< Record<nsString, int32_t> >&);
-  void PassOptionalObjectRecord(const Optional<Record<nsString, OwningNonNull<TestInterface> > >&);
-  void PassExternalInterfaceRecord(const Record<nsString, RefPtr<TestExternalInterface> >&);
-  void PassNullableExternalInterfaceRecord(const Record<nsString, RefPtr<TestExternalInterface> >&);
+  void PassRecord(const Record<nsString, int32_t>&);
+  void PassNullableRecord(const Nullable<Record<nsString, int32_t>>&);
+  void PassRecordOfNullableInts(const Record<nsString, Nullable<int32_t>>&);
+  void PassOptionalRecordOfNullableInts(
+      const Optional<Record<nsString, Nullable<int32_t>>>&);
+  void PassOptionalNullableRecordOfNullableInts(
+      const Optional<Nullable<Record<nsString, Nullable<int32_t>>>>&);
+  void PassCastableObjectRecord(
+      const Record<nsString, OwningNonNull<TestInterface>>&);
+  void PassNullableCastableObjectRecord(
+      const Record<nsString, RefPtr<TestInterface>>&);
+  void PassCastableObjectNullableRecord(
+      const Nullable<Record<nsString, OwningNonNull<TestInterface>>>&);
+  void PassNullableCastableObjectNullableRecord(
+      const Nullable<Record<nsString, RefPtr<TestInterface>>>&);
+  void PassOptionalRecord(const Optional<Record<nsString, int32_t>>&);
+  void PassOptionalNullableRecord(
+      const Optional<Nullable<Record<nsString, int32_t>>>&);
+  void PassOptionalNullableRecordWithDefaultValue(
+      const Nullable<Record<nsString, int32_t>>&);
+  void PassOptionalObjectRecord(
+      const Optional<Record<nsString, OwningNonNull<TestInterface>>>&);
+  void PassExternalInterfaceRecord(
+      const Record<nsString, RefPtr<TestExternalInterface>>&);
+  void PassNullableExternalInterfaceRecord(
+      const Record<nsString, RefPtr<TestExternalInterface>>&);
   void PassStringRecord(const Record<nsString, nsString>&);
   void PassByteStringRecord(const Record<nsString, nsCString>&);
-  void PassRecordOfRecords(const Record<nsString,  Record<nsString, int32_t> >&);
+  void PassRecordOfRecords(const Record<nsString, Record<nsString, int32_t>>&);
   void ReceiveRecord(Record<nsString, int32_t>&);
   void ReceiveNullableRecord(Nullable<Record<nsString, int32_t>>&);
   void ReceiveRecordOfNullableInts(Record<nsString, Nullable<int32_t>>&);
-  void ReceiveNullableRecordOfNullableInts(Nullable<Record<nsString, Nullable<int32_t>>>&);
+  void ReceiveNullableRecordOfNullableInts(
+      Nullable<Record<nsString, Nullable<int32_t>>>&);
   void ReceiveRecordOfRecords(Record<nsString, Record<nsString, int32_t>>&);
   void ReceiveAnyRecord(JSContext*, Record<nsString, JS::Value>&);
 
   // Typed array types
   void PassArrayBuffer(const ArrayBuffer&);
   void PassNullableArrayBuffer(const Nullable<ArrayBuffer>&);
   void PassOptionalArrayBuffer(const Optional<ArrayBuffer>&);
-  void PassOptionalNullableArrayBuffer(const Optional<Nullable<ArrayBuffer> >&);
-  void PassOptionalNullableArrayBufferWithDefaultValue(const Nullable<ArrayBuffer>&);
+  void PassOptionalNullableArrayBuffer(const Optional<Nullable<ArrayBuffer>>&);
+  void PassOptionalNullableArrayBufferWithDefaultValue(
+      const Nullable<ArrayBuffer>&);
   void PassArrayBufferView(const ArrayBufferView&);
   void PassInt8Array(const Int8Array&);
   void PassInt16Array(const Int16Array&);
   void PassInt32Array(const Int32Array&);
   void PassUint8Array(const Uint8Array&);
   void PassUint16Array(const Uint16Array&);
   void PassUint32Array(const Uint32Array&);
   void PassUint8ClampedArray(const Uint8ClampedArray&);
   void PassFloat32Array(const Float32Array&);
   void PassFloat64Array(const Float64Array&);
   void PassSequenceOfArrayBuffers(const Sequence<ArrayBuffer>&);
-  void PassSequenceOfNullableArrayBuffers(const Sequence<Nullable<ArrayBuffer> >&);
+  void PassSequenceOfNullableArrayBuffers(
+      const Sequence<Nullable<ArrayBuffer>>&);
   void PassRecordOfArrayBuffers(const Record<nsString, ArrayBuffer>&);
-  void PassRecordOfNullableArrayBuffers(const Record<nsString, Nullable<ArrayBuffer> >&);
+  void PassRecordOfNullableArrayBuffers(
+      const Record<nsString, Nullable<ArrayBuffer>>&);
   void PassVariadicTypedArray(const Sequence<Float32Array>&);
-  void PassVariadicNullableTypedArray(const Sequence<Nullable<Float32Array> >&);
+  void PassVariadicNullableTypedArray(const Sequence<Nullable<Float32Array>>&);
   void ReceiveUint8Array(JSContext*, JS::MutableHandle<JSObject*>);
   void SetUint8ArrayAttr(const Uint8Array&);
   void GetUint8ArrayAttr(JSContext*, JS::MutableHandle<JSObject*>);
 
   // DOMString types
   void PassString(const nsAString&);
   void PassNullableString(const nsAString&);
   void PassOptionalString(const Optional<nsAString>&);
@@ -536,115 +574,137 @@ public:
   void PassVariadicUSVS(const Sequence<nsString>&);
   void ReceiveUSVS(DOMString&);
 
   // Enumerated types
   void PassEnum(TestEnum);
   void PassNullableEnum(const Nullable<TestEnum>&);
   void PassOptionalEnum(const Optional<TestEnum>&);
   void PassEnumWithDefault(TestEnum);
-  void PassOptionalNullableEnum(const Optional<Nullable<TestEnum> >&);
+  void PassOptionalNullableEnum(const Optional<Nullable<TestEnum>>&);
   void PassOptionalNullableEnumWithDefaultValue(const Nullable<TestEnum>&);
   void PassOptionalNullableEnumWithDefaultValue2(const Nullable<TestEnum>&);
   TestEnum ReceiveEnum();
   Nullable<TestEnum> ReceiveNullableEnum();
   TestEnum EnumAttribute();
   TestEnum ReadonlyEnumAttribute();
   void SetEnumAttribute(TestEnum);
 
   // Callback types
   void PassCallback(TestCallback&);
   void PassNullableCallback(TestCallback*);
-  void PassOptionalCallback(const Optional<OwningNonNull<TestCallback> >&);
-  void PassOptionalNullableCallback(const Optional<RefPtr<TestCallback> >&);
+  void PassOptionalCallback(const Optional<OwningNonNull<TestCallback>>&);
+  void PassOptionalNullableCallback(const Optional<RefPtr<TestCallback>>&);
   void PassOptionalNullableCallbackWithDefaultValue(TestCallback*);
   already_AddRefed<TestCallback> ReceiveCallback();
   already_AddRefed<TestCallback> ReceiveNullableCallback();
   void PassNullableTreatAsNullCallback(TestTreatAsNullCallback*);
-  void PassOptionalNullableTreatAsNullCallback(const Optional<RefPtr<TestTreatAsNullCallback> >&);
-  void PassOptionalNullableTreatAsNullCallbackWithDefaultValue(TestTreatAsNullCallback*);
+  void PassOptionalNullableTreatAsNullCallback(
+      const Optional<RefPtr<TestTreatAsNullCallback>>&);
+  void PassOptionalNullableTreatAsNullCallbackWithDefaultValue(
+      TestTreatAsNullCallback*);
   void SetTreatAsNullCallback(TestTreatAsNullCallback&);
   already_AddRefed<TestTreatAsNullCallback> TreatAsNullCallback();
   void SetNullableTreatAsNullCallback(TestTreatAsNullCallback*);
   already_AddRefed<TestTreatAsNullCallback> GetNullableTreatAsNullCallback();
 
-  void ForceCallbackGeneration(TestIntegerReturn&,
-                               TestNullableIntegerReturn&,
-                               TestBooleanReturn&,
-                               TestFloatReturn&,
-                               TestStringReturn&,
-                               TestEnumReturn&,
-                               TestInterfaceReturn&,
-                               TestNullableInterfaceReturn&,
-                               TestExternalInterfaceReturn&,
-                               TestNullableExternalInterfaceReturn&,
-                               TestCallbackInterfaceReturn&,
-                               TestNullableCallbackInterfaceReturn&,
-                               TestCallbackReturn&,
-                               TestNullableCallbackReturn&,
-                               TestObjectReturn&,
-                               TestNullableObjectReturn&,
-                               TestTypedArrayReturn&,
-                               TestNullableTypedArrayReturn&,
-                               TestSequenceReturn&,
-                               TestNullableSequenceReturn&,
-                               TestIntegerArguments&,
-                               TestInterfaceArguments&,
-                               TestStringEnumArguments&,
-                               TestObjectArguments&,
-                               TestOptionalArguments&);
+  void ForceCallbackGeneration(
+      TestIntegerReturn&, TestNullableIntegerReturn&, TestBooleanReturn&,
+      TestFloatReturn&, TestStringReturn&, TestEnumReturn&,
+      TestInterfaceReturn&, TestNullableInterfaceReturn&,
+      TestExternalInterfaceReturn&, TestNullableExternalInterfaceReturn&,
+      TestCallbackInterfaceReturn&, TestNullableCallbackInterfaceReturn&,
+      TestCallbackReturn&, TestNullableCallbackReturn&, TestObjectReturn&,
+      TestNullableObjectReturn&, TestTypedArrayReturn&,
+      TestNullableTypedArrayReturn&, TestSequenceReturn&,
+      TestNullableSequenceReturn&, TestIntegerArguments&,
+      TestInterfaceArguments&, TestStringEnumArguments&, TestObjectArguments&,
+      TestOptionalArguments&);
 
   // Any types
   void PassAny(JSContext*, JS::Handle<JS::Value>);
   void PassVariadicAny(JSContext*, const Sequence<JS::Value>&);
   void PassOptionalAny(JSContext*, JS::Handle<JS::Value>);
   void PassAnyDefaultNull(JSContext*, JS::Handle<JS::Value>);
   void PassSequenceOfAny(JSContext*, const Sequence<JS::Value>&);
-  void PassNullableSequenceOfAny(JSContext*, const Nullable<Sequence<JS::Value> >&);
-  void PassOptionalSequenceOfAny(JSContext*, const Optional<Sequence<JS::Value> >&);
-  void PassOptionalNullableSequenceOfAny(JSContext*, const Optional<Nullable<Sequence<JS::Value> > >&);
-  void PassOptionalSequenceOfAnyWithDefaultValue(JSContext*, const Nullable<Sequence<JS::Value> >&);
-  void PassSequenceOfSequenceOfAny(JSContext*, const Sequence<Sequence<JS::Value> >&);
-  void PassSequenceOfNullableSequenceOfAny(JSContext*, const Sequence<Nullable<Sequence<JS::Value> > >&);
-  void PassNullableSequenceOfNullableSequenceOfAny(JSContext*, const Nullable<Sequence<Nullable<Sequence<JS::Value> > > >&);
-  void PassOptionalNullableSequenceOfNullableSequenceOfAny(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JS::Value> > > > >&);
+  void PassNullableSequenceOfAny(JSContext*,
+                                 const Nullable<Sequence<JS::Value>>&);
+  void PassOptionalSequenceOfAny(JSContext*,
+                                 const Optional<Sequence<JS::Value>>&);
+  void PassOptionalNullableSequenceOfAny(
+      JSContext*, const Optional<Nullable<Sequence<JS::Value>>>&);
+  void PassOptionalSequenceOfAnyWithDefaultValue(
+      JSContext*, const Nullable<Sequence<JS::Value>>&);
+  void PassSequenceOfSequenceOfAny(JSContext*,
+                                   const Sequence<Sequence<JS::Value>>&);
+  void PassSequenceOfNullableSequenceOfAny(
+      JSContext*, const Sequence<Nullable<Sequence<JS::Value>>>&);
+  void PassNullableSequenceOfNullableSequenceOfAny(
+      JSContext*, const Nullable<Sequence<Nullable<Sequence<JS::Value>>>>&);
+  void PassOptionalNullableSequenceOfNullableSequenceOfAny(
+      JSContext*,
+      const Optional<Nullable<Sequence<Nullable<Sequence<JS::Value>>>>>&);
   void PassRecordOfAny(JSContext*, const Record<nsString, JS::Value>&);
-  void PassNullableRecordOfAny(JSContext*, const Nullable<Record<nsString, JS::Value> >&);
-  void PassOptionalRecordOfAny(JSContext*, const Optional<Record<nsString, JS::Value> >&);
-  void PassOptionalNullableRecordOfAny(JSContext*, const Optional<Nullable<Record<nsString, JS::Value> > >&);
-  void PassOptionalRecordOfAnyWithDefaultValue(JSContext*, const Nullable<Record<nsString, JS::Value> >&);
-  void PassRecordOfRecordOfAny(JSContext*, const Record<nsString, Record<nsString, JS::Value> >&);
-  void PassRecordOfNullableRecordOfAny(JSContext*, const Record<nsString, Nullable<Record<nsString, JS::Value> > >&);
-  void PassNullableRecordOfNullableRecordOfAny(JSContext*, const Nullable<Record<nsString, Nullable<Record<nsString, JS::Value> > > >&);
-  void PassOptionalNullableRecordOfNullableRecordOfAny(JSContext*, const Optional<Nullable<Record<nsString, Nullable<Record<nsString, JS::Value>>>>>&);
-  void PassOptionalNullableRecordOfNullableSequenceOfAny(JSContext*, const Optional<Nullable<Record<nsString, Nullable<Sequence<JS::Value>>>>>&);
-  void PassOptionalNullableSequenceOfNullableRecordOfAny(JSContext*, const Optional<Nullable<Sequence<Nullable<Record<nsString, JS::Value>>>>>&);
+  void PassNullableRecordOfAny(JSContext*,
+                               const Nullable<Record<nsString, JS::Value>>&);
+  void PassOptionalRecordOfAny(JSContext*,
+                               const Optional<Record<nsString, JS::Value>>&);
+  void PassOptionalNullableRecordOfAny(
+      JSContext*, const Optional<Nullable<Record<nsString, JS::Value>>>&);
+  void PassOptionalRecordOfAnyWithDefaultValue(
+      JSContext*, const Nullable<Record<nsString, JS::Value>>&);
+  void PassRecordOfRecordOfAny(
+      JSContext*, const Record<nsString, Record<nsString, JS::Value>>&);
+  void PassRecordOfNullableRecordOfAny(
+      JSContext*,
+      const Record<nsString, Nullable<Record<nsString, JS::Value>>>&);
+  void PassNullableRecordOfNullableRecordOfAny(
+      JSContext*,
+      const Nullable<Record<nsString, Nullable<Record<nsString, JS::Value>>>>&);
+  void PassOptionalNullableRecordOfNullableRecordOfAny(
+      JSContext*,
+      const Optional<
+          Nullable<Record<nsString, Nullable<Record<nsString, JS::Value>>>>>&);
+  void PassOptionalNullableRecordOfNullableSequenceOfAny(
+      JSContext*,
+      const Optional<
+          Nullable<Record<nsString, Nullable<Sequence<JS::Value>>>>>&);
+  void PassOptionalNullableSequenceOfNullableRecordOfAny(
+      JSContext*,
+      const Optional<
+          Nullable<Sequence<Nullable<Record<nsString, JS::Value>>>>>&);
   void ReceiveAny(JSContext*, JS::MutableHandle<JS::Value>);
 
   // object types
   void PassObject(JSContext*, JS::Handle<JSObject*>);
   void PassVariadicObject(JSContext*, const Sequence<JSObject*>&);
   void PassNullableObject(JSContext*, JS::Handle<JSObject*>);
   void PassVariadicNullableObject(JSContext*, const Sequence<JSObject*>&);
-  void PassOptionalObject(JSContext*, const Optional<JS::Handle<JSObject*> >&);
-  void PassOptionalNullableObject(JSContext*, const Optional<JS::Handle<JSObject*> >&);
-  void PassOptionalNullableObjectWithDefaultValue(JSContext*, JS::Handle<JSObject*>);
+  void PassOptionalObject(JSContext*, const Optional<JS::Handle<JSObject*>>&);
+  void PassOptionalNullableObject(JSContext*,
+                                  const Optional<JS::Handle<JSObject*>>&);
+  void PassOptionalNullableObjectWithDefaultValue(JSContext*,
+                                                  JS::Handle<JSObject*>);
   void PassSequenceOfObject(JSContext*, const Sequence<JSObject*>&);
   void PassSequenceOfNullableObject(JSContext*, const Sequence<JSObject*>&);
-  void PassNullableSequenceOfObject(JSContext*, const Nullable<Sequence<JSObject*> >&);
-  void PassOptionalNullableSequenceOfNullableSequenceOfObject(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&);
-  void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&);
+  void PassNullableSequenceOfObject(JSContext*,
+                                    const Nullable<Sequence<JSObject*>>&);
+  void PassOptionalNullableSequenceOfNullableSequenceOfObject(
+      JSContext*,
+      const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*>>>>>&);
+  void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(
+      JSContext*,
+      const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*>>>>>&);
   void PassRecordOfObject(JSContext*, const Record<nsString, JSObject*>&);
   void ReceiveObject(JSContext*, JS::MutableHandle<JSObject*>);
   void ReceiveNullableObject(JSContext*, JS::MutableHandle<JSObject*>);
 
   // Union types
   void PassUnion(JSContext*, const ObjectOrLong& arg);
-  void PassUnionWithNullable(JSContext* cx, const ObjectOrNullOrLong& arg)
-  {
+  void PassUnionWithNullable(JSContext* cx, const ObjectOrNullOrLong& arg) {
     OwningObjectOrLong returnValue;
     if (arg.IsNull()) {
     } else if (arg.IsObject()) {
       JS::Rooted<JSObject*> obj(cx, arg.GetAsObject());
       JS_GetClass(obj);
       returnValue.SetAsObject() = obj;
     } else {
       int32_t i = arg.GetAsLong();
@@ -678,30 +738,35 @@ public:
   void PassUnion24(const ImageDataOrNullSequenceOrLong&);
   void PassUnion25(const ImageDataSequenceSequenceOrLong&);
   void PassUnion26(const ImageDataOrNullSequenceSequenceOrLong&);
   void PassUnion27(const StringSequenceOrEventInit&);
   void PassUnion28(const EventInitOrStringSequence&);
   void PassUnionWithCallback(const EventHandlerNonNullOrNullOrLong& arg);
   void PassUnionWithByteString(const ByteStringOrLong&);
   void PassUnionWithRecord(const StringStringRecordOrString&);
-  void PassUnionWithRecordAndSequence(const StringStringRecordOrStringSequence&);
-  void PassUnionWithSequenceAndRecord(const StringSequenceOrStringStringRecord&);
+  void PassUnionWithRecordAndSequence(
+      const StringStringRecordOrStringSequence&);
+  void PassUnionWithSequenceAndRecord(
+      const StringSequenceOrStringStringRecord&);
   void PassUnionWithUSVS(const USVStringOrLong&);
 #endif
   void PassNullableUnion(JSContext*, const Nullable<ObjectOrLong>&);
   void PassOptionalUnion(JSContext*, const Optional<ObjectOrLong>&);
-  void PassOptionalNullableUnion(JSContext*, const Optional<Nullable<ObjectOrLong> >&);
-  void PassOptionalNullableUnionWithDefaultValue(JSContext*, const Nullable<ObjectOrLong>&);
-  //void PassUnionWithInterfaces(const TestInterfaceOrTestExternalInterface& arg);
-  //void PassUnionWithInterfacesAndNullable(const TestInterfaceOrNullOrTestExternalInterface& arg);
+  void PassOptionalNullableUnion(JSContext*,
+                                 const Optional<Nullable<ObjectOrLong>>&);
+  void PassOptionalNullableUnionWithDefaultValue(JSContext*,
+                                                 const Nullable<ObjectOrLong>&);
+  // void PassUnionWithInterfaces(const TestInterfaceOrTestExternalInterface&
+  // arg); void PassUnionWithInterfacesAndNullable(const
+  // TestInterfaceOrNullOrTestExternalInterface& arg);
   void PassUnionWithArrayBuffer(const ArrayBufferOrLong&);
   void PassUnionWithString(JSContext*, const StringOrObject&);
   void PassUnionWithEnum(JSContext*, const SupportedTypeOrObject&);
-  //void PassUnionWithCallback(JSContext*, const TestCallbackOrLong&);
+  // void PassUnionWithCallback(JSContext*, const TestCallbackOrLong&);
   void PassUnionWithObject(JSContext*, const ObjectOrLong&);
 
   void PassUnionWithDefaultValue1(const DoubleOrString& arg);
   void PassUnionWithDefaultValue2(const DoubleOrString& arg);
   void PassUnionWithDefaultValue3(const DoubleOrString& arg);
   void PassUnionWithDefaultValue4(const FloatOrString& arg);
   void PassUnionWithDefaultValue5(const FloatOrString& arg);
   void PassUnionWithDefaultValue6(const FloatOrString& arg);
@@ -723,65 +788,90 @@ public:
   void PassUnionWithDefaultValue22(const DoubleOrUSVString& arg);
 
   void PassNullableUnionWithDefaultValue1(const Nullable<DoubleOrString>& arg);
   void PassNullableUnionWithDefaultValue2(const Nullable<DoubleOrString>& arg);
   void PassNullableUnionWithDefaultValue3(const Nullable<DoubleOrString>& arg);
   void PassNullableUnionWithDefaultValue4(const Nullable<FloatOrString>& arg);
   void PassNullableUnionWithDefaultValue5(const Nullable<FloatOrString>& arg);
   void PassNullableUnionWithDefaultValue6(const Nullable<FloatOrString>& arg);
-  void PassNullableUnionWithDefaultValue7(const Nullable<UnrestrictedDoubleOrString>& arg);
-  void PassNullableUnionWithDefaultValue8(const Nullable<UnrestrictedDoubleOrString>& arg);
-  void PassNullableUnionWithDefaultValue9(const Nullable<UnrestrictedDoubleOrString>& arg);
-  void PassNullableUnionWithDefaultValue10(const Nullable<UnrestrictedFloatOrString>& arg);
-  void PassNullableUnionWithDefaultValue11(const Nullable<UnrestrictedFloatOrString>& arg);
-  void PassNullableUnionWithDefaultValue12(const Nullable<UnrestrictedFloatOrString>& arg);
-  void PassNullableUnionWithDefaultValue13(const Nullable<DoubleOrByteString>& arg);
-  void PassNullableUnionWithDefaultValue14(const Nullable<DoubleOrByteString>& arg);
-  void PassNullableUnionWithDefaultValue15(const Nullable<DoubleOrByteString>& arg);
-  void PassNullableUnionWithDefaultValue16(const Nullable<DoubleOrByteString>& arg);
-  void PassNullableUnionWithDefaultValue17(const Nullable<DoubleOrSupportedType>& arg);
-  void PassNullableUnionWithDefaultValue18(const Nullable<DoubleOrSupportedType>& arg);
-  void PassNullableUnionWithDefaultValue19(const Nullable<DoubleOrSupportedType>& arg);
-  void PassNullableUnionWithDefaultValue20(const Nullable<DoubleOrSupportedType>& arg);
-  void PassNullableUnionWithDefaultValue21(const Nullable<DoubleOrUSVString>& arg);
-  void PassNullableUnionWithDefaultValue22(const Nullable<DoubleOrUSVString>& arg);
-  void PassNullableUnionWithDefaultValue23(const Nullable<DoubleOrUSVString>& arg);
-  void PassNullableUnionWithDefaultValue24(const Nullable<DoubleOrUSVString>& arg);
+  void PassNullableUnionWithDefaultValue7(
+      const Nullable<UnrestrictedDoubleOrString>& arg);
+  void PassNullableUnionWithDefaultValue8(
+      const Nullable<UnrestrictedDoubleOrString>& arg);
+  void PassNullableUnionWithDefaultValue9(
+      const Nullable<UnrestrictedDoubleOrString>& arg);
+  void PassNullableUnionWithDefaultValue10(
+      const Nullable<UnrestrictedFloatOrString>& arg);
+  void PassNullableUnionWithDefaultValue11(
+      const Nullable<UnrestrictedFloatOrString>& arg);
+  void PassNullableUnionWithDefaultValue12(
+      const Nullable<UnrestrictedFloatOrString>& arg);
+  void PassNullableUnionWithDefaultValue13(
+      const Nullable<DoubleOrByteString>& arg);
+  void PassNullableUnionWithDefaultValue14(
+      const Nullable<DoubleOrByteString>& arg);
+  void PassNullableUnionWithDefaultValue15(
+      const Nullable<DoubleOrByteString>& arg);
+  void PassNullableUnionWithDefaultValue16(
+      const Nullable<DoubleOrByteString>& arg);
+  void PassNullableUnionWithDefaultValue17(
+      const Nullable<DoubleOrSupportedType>& arg);
+  void PassNullableUnionWithDefaultValue18(
+      const Nullable<DoubleOrSupportedType>& arg);
+  void PassNullableUnionWithDefaultValue19(
+      const Nullable<DoubleOrSupportedType>& arg);
+  void PassNullableUnionWithDefaultValue20(
+      const Nullable<DoubleOrSupportedType>& arg);
+  void PassNullableUnionWithDefaultValue21(
+      const Nullable<DoubleOrUSVString>& arg);
+  void PassNullableUnionWithDefaultValue22(
+      const Nullable<DoubleOrUSVString>& arg);
+  void PassNullableUnionWithDefaultValue23(
+      const Nullable<DoubleOrUSVString>& arg);
+  void PassNullableUnionWithDefaultValue24(
+      const Nullable<DoubleOrUSVString>& arg);
 
-  void PassSequenceOfUnions(const Sequence<OwningCanvasPatternOrCanvasGradient>&);
+  void PassSequenceOfUnions(
+      const Sequence<OwningCanvasPatternOrCanvasGradient>&);
   void PassSequenceOfUnions2(JSContext*, const Sequence<OwningObjectOrLong>&);
   void PassVariadicUnion(const Sequence<OwningCanvasPatternOrCanvasGradient>&);
 
-  void PassSequenceOfNullableUnions(const Sequence<Nullable<OwningCanvasPatternOrCanvasGradient>>&);
-  void PassVariadicNullableUnion(const Sequence<Nullable<OwningCanvasPatternOrCanvasGradient>>&);
-  void PassRecordOfUnions(const Record<nsString, OwningCanvasPatternOrCanvasGradient>&);
-  void PassRecordOfUnions2(JSContext*, const Record<nsString, OwningObjectOrLong>&);
+  void PassSequenceOfNullableUnions(
+      const Sequence<Nullable<OwningCanvasPatternOrCanvasGradient>>&);
+  void PassVariadicNullableUnion(
+      const Sequence<Nullable<OwningCanvasPatternOrCanvasGradient>>&);
+  void PassRecordOfUnions(
+      const Record<nsString, OwningCanvasPatternOrCanvasGradient>&);
+  void PassRecordOfUnions2(JSContext*,
+                           const Record<nsString, OwningObjectOrLong>&);
 
   void ReceiveUnion(OwningCanvasPatternOrCanvasGradient&);
   void ReceiveUnion2(JSContext*, OwningObjectOrLong&);
   void ReceiveUnionContainingNull(OwningCanvasPatternOrNullOrCanvasGradient&);
   void ReceiveNullableUnion(Nullable<OwningCanvasPatternOrCanvasGradient>&);
   void ReceiveNullableUnion2(JSContext*, Nullable<OwningObjectOrLong>&);
   void GetWritableUnion(OwningCanvasPatternOrCanvasGradient&);
   void SetWritableUnion(const CanvasPatternOrCanvasGradient&);
-  void GetWritableUnionContainingNull(OwningCanvasPatternOrNullOrCanvasGradient&);
-  void SetWritableUnionContainingNull(const CanvasPatternOrNullOrCanvasGradient&);
+  void GetWritableUnionContainingNull(
+      OwningCanvasPatternOrNullOrCanvasGradient&);
+  void SetWritableUnionContainingNull(
+      const CanvasPatternOrNullOrCanvasGradient&);
   void GetWritableNullableUnion(Nullable<OwningCanvasPatternOrCanvasGradient>&);
   void SetWritableNullableUnion(const Nullable<CanvasPatternOrCanvasGradient>&);
 
   // Date types
   void PassDate(Date);
   void PassNullableDate(const Nullable<Date>&);
   void PassOptionalDate(const Optional<Date>&);
-  void PassOptionalNullableDate(const Optional<Nullable<Date> >&);
+  void PassOptionalNullableDate(const Optional<Nullable<Date>>&);
   void PassOptionalNullableDateWithDefaultValue(const Nullable<Date>&);
   void PassDateSequence(const Sequence<Date>&);
   void PassDateRecord(const Record<nsString, Date>&);
-  void PassNullableDateSequence(const Sequence<Nullable<Date> >&);
+  void PassNullableDateSequence(const Sequence<Nullable<Date>>&);
   Date ReceiveDate();
   Nullable<Date> ReceiveNullableDate();
 
   // Promise types
   void PassPromise(Promise&);
   void PassOptionalPromise(const Optional<OwningNonNull<Promise>>&);
   void PassPromiseSequence(const Sequence<OwningNonNull<Promise>>&);
   void PassPromiseRecord(const Record<nsString, RefPtr<Promise>>&);
@@ -838,17 +928,18 @@ public:
   static bool StaticAttribute(const GlobalObject&);
   static void SetStaticAttribute(const GlobalObject&, bool);
   static void Assert(const GlobalObject&, bool);
 
   // Deprecated static methods and attributes
   static int8_t StaticDeprecatedAttribute(const GlobalObject&);
   static void SetStaticDeprecatedAttribute(const GlobalObject&, int8_t);
   static void StaticDeprecatedMethod(const GlobalObject&);
-  static void StaticDeprecatedMethodWithContext(const GlobalObject&, const JS::Value&);
+  static void StaticDeprecatedMethodWithContext(const GlobalObject&,
+                                                const JS::Value&);
 
   // Overload resolution tests
   bool Overload1(TestInterface&);
   TestInterface* Overload1(const nsAString&, TestInterface&);
   void Overload2(TestInterface&);
   void Overload2(JSContext*, const Dict&);
   void Overload2(bool);
   void Overload2(const nsAString&);
@@ -876,31 +967,31 @@ public:
   void Overload11(const nsAString&);
   void Overload12(int32_t);
   void Overload12(const Nullable<bool>&);
   void Overload13(const Nullable<int32_t>&);
   void Overload13(bool);
   void Overload14(const Optional<int32_t>&);
   void Overload14(TestInterface&);
   void Overload15(int32_t);
-  void Overload15(const Optional<NonNull<TestInterface> >&);
+  void Overload15(const Optional<NonNull<TestInterface>>&);
   void Overload16(int32_t);
   void Overload16(const Optional<TestInterface*>&);
   void Overload17(const Sequence<int32_t>&);
   void Overload17(const Record<nsString, int32_t>&);
   void Overload18(const Record<nsString, nsString>&);
   void Overload18(const Sequence<nsString>&);
   void Overload19(const Sequence<int32_t>&);
   void Overload19(JSContext*, const Dict&);
   void Overload20(JSContext*, const Dict&);
   void Overload20(const Sequence<int32_t>&);
 
   // Variadic handling
   void PassVariadicThirdArg(const nsAString&, int32_t,
-                            const Sequence<OwningNonNull<TestInterface> >&);
+                            const Sequence<OwningNonNull<TestInterface>>&);
 
   // Conditionally exposed methods/attributes
   bool Prefable1();
   bool Prefable2();
   bool Prefable3();
   bool Prefable4();
   bool Prefable5();
   bool Prefable6();
@@ -1008,145 +1099,164 @@ public:
   void DontEnforceRangeOrClamp(int8_t);
   void DoEnforceRange(int8_t);
   void DoClamp(int8_t);
   void SetEnforcedByte(int8_t);
   int8_t EnforcedByte();
   void SetClampedByte(int8_t);
   int8_t ClampedByte();
 
-private:
+ private:
   // We add signatures here that _could_ start matching if the codegen
   // got data types wrong.  That way if it ever does we'll have a call
   // to these private deleted methods and compilation will fail.
   void SetReadonlyByte(int8_t) = delete;
-  template<typename T>
+  template <typename T>
   void SetWritableByte(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassByte(T) = delete;
   void PassNullableByte(Nullable<int8_t>&) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalByte(const Optional<T>&) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalByteWithDefault(T) = delete;
   void PassVariadicByte(Sequence<int8_t>&) = delete;
 
   void SetReadonlyShort(int16_t) = delete;
-  template<typename T>
+  template <typename T>
   void SetWritableShort(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassShort(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalShort(const Optional<T>&) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalShortWithDefault(T) = delete;
 
   void SetReadonlyLong(int32_t) = delete;
-  template<typename T>
+  template <typename T>
   void SetWritableLong(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassLong(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalLong(const Optional<T>&) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalLongWithDefault(T) = delete;
 
   void SetReadonlyLongLong(int64_t) = delete;
-  template<typename T>
+  template <typename T>
   void SetWritableLongLong(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassLongLong(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalLongLong(const Optional<T>&) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalLongLongWithDefault(T) = delete;
 
   void SetReadonlyOctet(uint8_t) = delete;
-  template<typename T>
+  template <typename T>
   void SetWritableOctet(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassOctet(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalOctet(const Optional<T>&) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalOctetWithDefault(T) = delete;
 
   void SetReadonlyUnsignedShort(uint16_t) = delete;
-  template<typename T>
+  template <typename T>
   void SetWritableUnsignedShort(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassUnsignedShort(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalUnsignedShort(const Optional<T>&) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalUnsignedShortWithDefault(T) = delete;
 
   void SetReadonlyUnsignedLong(uint32_t) = delete;
-  template<typename T>
+  template <typename T>
   void SetWritableUnsignedLong(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassUnsignedLong(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalUnsignedLong(const Optional<T>&) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalUnsignedLongWithDefault(T) = delete;
 
   void SetReadonlyUnsignedLongLong(uint64_t) = delete;
-  template<typename T>
+  template <typename T>
   void SetWritableUnsignedLongLong(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassUnsignedLongLong(T) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalUnsignedLongLong(const Optional<T>&) = delete;
-  template<typename T>
+  template <typename T>
   void PassOptionalUnsignedLongLongWithDefault(T) = delete;
 
   // Enforce that only const things are passed for sequences
-  void PassSequence(Sequence<int32_t> &) = delete;
-  void PassNullableSequence(Nullable< Sequence<int32_t> >&) = delete;
-  void PassOptionalNullableSequenceWithDefaultValue(Nullable< Sequence<int32_t> >&) = delete;
+  void PassSequence(Sequence<int32_t>&) = delete;
+  void PassNullableSequence(Nullable<Sequence<int32_t>>&) = delete;
+  void PassOptionalNullableSequenceWithDefaultValue(
+      Nullable<Sequence<int32_t>>&) = delete;
   void PassSequenceOfAny(JSContext*, Sequence<JS::Value>&) = delete;
-  void PassNullableSequenceOfAny(JSContext*, Nullable<Sequence<JS::Value> >&) = delete;
-  void PassOptionalSequenceOfAny(JSContext*, Optional<Sequence<JS::Value> >&) = delete;
-  void PassOptionalNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<JS::Value> > >&) = delete;
-  void PassOptionalSequenceOfAnyWithDefaultValue(JSContext*, Nullable<Sequence<JS::Value> >&) = delete;
-  void PassSequenceOfSequenceOfAny(JSContext*, Sequence<Sequence<JS::Value> >&) = delete;
-  void PassSequenceOfNullableSequenceOfAny(JSContext*, Sequence<Nullable<Sequence<JS::Value> > >&) = delete;
-  void PassNullableSequenceOfNullableSequenceOfAny(JSContext*, Nullable<Sequence<Nullable<Sequence<JS::Value> > > >&) = delete;
-  void PassOptionalNullableSequenceOfNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JS::Value> > > > >&) = delete;
+  void PassNullableSequenceOfAny(JSContext*,
+                                 Nullable<Sequence<JS::Value>>&) = delete;
+  void PassOptionalSequenceOfAny(JSContext*,
+                                 Optional<Sequence<JS::Value>>&) = delete;
+  void PassOptionalNullableSequenceOfAny(
+      JSContext*, Optional<Nullable<Sequence<JS::Value>>>&) = delete;
+  void PassOptionalSequenceOfAnyWithDefaultValue(
+      JSContext*, Nullable<Sequence<JS::Value>>&) = delete;
+  void PassSequenceOfSequenceOfAny(JSContext*,
+                                   Sequence<Sequence<JS::Value>>&) = delete;
+  void PassSequenceOfNullableSequenceOfAny(
+      JSContext*, Sequence<Nullable<Sequence<JS::Value>>>&) = delete;
+  void PassNullableSequenceOfNullableSequenceOfAny(
+      JSContext*, Nullable<Sequence<Nullable<Sequence<JS::Value>>>>&) = delete;
+  void PassOptionalNullableSequenceOfNullableSequenceOfAny(
+      JSContext*,
+      Optional<Nullable<Sequence<Nullable<Sequence<JS::Value>>>>>&) = delete;
   void PassSequenceOfObject(JSContext*, Sequence<JSObject*>&) = delete;
   void PassSequenceOfNullableObject(JSContext*, Sequence<JSObject*>&) = delete;
-  void PassOptionalNullableSequenceOfNullableSequenceOfObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) = delete;
-  void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) = delete;
+  void PassOptionalNullableSequenceOfNullableSequenceOfObject(
+      JSContext*,
+      Optional<Nullable<Sequence<Nullable<Sequence<JSObject*>>>>>&) = delete;
+  void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(
+      JSContext*,
+      Optional<Nullable<Sequence<Nullable<Sequence<JSObject*>>>>>&) = delete;
 
   // Enforce that only const things are passed for optional
   void PassOptionalByte(Optional<int8_t>&) = delete;
-  void PassOptionalNullableByte(Optional<Nullable<int8_t> >&) = delete;
+  void PassOptionalNullableByte(Optional<Nullable<int8_t>>&) = delete;
   void PassOptionalShort(Optional<int16_t>&) = delete;
   void PassOptionalLong(Optional<int32_t>&) = delete;
   void PassOptionalLongLong(Optional<int64_t>&) = delete;
   void PassOptionalOctet(Optional<uint8_t>&) = delete;
   void PassOptionalUnsignedShort(Optional<uint16_t>&) = delete;
   void PassOptionalUnsignedLong(Optional<uint32_t>&) = delete;
   void PassOptionalUnsignedLongLong(Optional<uint64_t>&) = delete;
-  void PassOptionalSelf(Optional<TestInterface*> &) = delete;
-  void PassOptionalNonNullSelf(Optional<NonNull<TestInterface> >&) = delete;
+  void PassOptionalSelf(Optional<TestInterface*>&) = delete;
+  void PassOptionalNonNullSelf(Optional<NonNull<TestInterface>>&) = delete;
   void PassOptionalOther(Optional<IndirectlyImplementedInterface*>&);
-  void PassOptionalNonNullOther(Optional<NonNull<IndirectlyImplementedInterface> >&);
+  void PassOptionalNonNullOther(
+      Optional<NonNull<IndirectlyImplementedInterface>>&);
   void PassOptionalExternal(Optional<TestExternalInterface*>&) = delete;
   void PassOptionalNonNullExternal(Optional<TestExternalInterface*>&) = delete;
-  void PassOptionalSequence(Optional<Sequence<int32_t> >&) = delete;
-  void PassOptionalNullableSequence(Optional<Nullable<Sequence<int32_t> > >&) = delete;
-  void PassOptionalObjectSequence(Optional<Sequence<OwningNonNull<TestInterface> > >&) = delete;
+  void PassOptionalSequence(Optional<Sequence<int32_t>>&) = delete;
+  void PassOptionalNullableSequence(Optional<Nullable<Sequence<int32_t>>>&) =
+      delete;
+  void PassOptionalObjectSequence(
+      Optional<Sequence<OwningNonNull<TestInterface>>>&) = delete;
   void PassOptionalArrayBuffer(Optional<ArrayBuffer>&) = delete;
   void PassOptionalNullableArrayBuffer(Optional<ArrayBuffer*>&) = delete;
   void PassOptionalEnum(Optional<TestEnum>&) = delete;
-  void PassOptionalCallback(JSContext*, Optional<OwningNonNull<TestCallback> >&) = delete;
-  void PassOptionalNullableCallback(JSContext*, Optional<RefPtr<TestCallback> >&) = delete;
-  void PassOptionalAny(Optional<JS::Handle<JS::Value> >&) = delete;
+  void PassOptionalCallback(JSContext*,
+                            Optional<OwningNonNull<TestCallback>>&) = delete;
+  void PassOptionalNullableCallback(JSContext*,
+                                    Optional<RefPtr<TestCallback>>&) = delete;
+  void PassOptionalAny(Optional<JS::Handle<JS::Value>>&) = delete;
 
   // And test that string stuff is always const
   void PassString(nsAString&) = delete;
   void PassNullableString(nsAString&) = delete;
   void PassOptionalString(Optional<nsAString>&) = delete;
   void PassOptionalStringWithDefaultValue(nsAString&) = delete;
   void PassOptionalNullableString(Optional<nsAString>&) = delete;
   void PassOptionalNullableStringWithDefaultValue(nsAString&) = delete;
@@ -1172,335 +1282,308 @@ private:
   // Make sure various nullable things are always const
   void PassNullableEnum(Nullable<TestEnum>&) = delete;
 
   // Make sure unions are always const
   void PassUnion(JSContext*, ObjectOrLong& arg) = delete;
   void PassUnionWithNullable(JSContext*, ObjectOrNullOrLong& arg) = delete;
   void PassNullableUnion(JSContext*, Nullable<ObjectOrLong>&) = delete;
   void PassOptionalUnion(JSContext*, Optional<ObjectOrLong>&) = delete;
-  void PassOptionalNullableUnion(JSContext*, Optional<Nullable<ObjectOrLong> >&) = delete;
-  void PassOptionalNullableUnionWithDefaultValue(JSContext*, Nullable<ObjectOrLong>&) = delete;
+  void PassOptionalNullableUnion(JSContext*,
+                                 Optional<Nullable<ObjectOrLong>>&) = delete;
+  void PassOptionalNullableUnionWithDefaultValue(
+      JSContext*, Nullable<ObjectOrLong>&) = delete;
 
   // Make sure various date stuff is const as needed
   void PassNullableDate(Nullable<Date>&) = delete;
   void PassOptionalDate(Optional<Date>&) = delete;
-  void PassOptionalNullableDate(Optional<Nullable<Date> >&) = delete;
+  void PassOptionalNullableDate(Optional<Nullable<Date>>&) = delete;
   void PassOptionalNullableDateWithDefaultValue(Nullable<Date>&) = delete;
   void PassDateSequence(Sequence<Date>&) = delete;
-  void PassNullableDateSequence(Sequence<Nullable<Date> >&) = delete;
+  void PassNullableDateSequence(Sequence<Nullable<Date>>&) = delete;
 
   // Make sure variadics are const as needed
   void PassVariadicAny(JSContext*, Sequence<JS::Value>&) = delete;
   void PassVariadicObject(JSContext*, Sequence<JSObject*>&) = delete;
   void PassVariadicNullableObject(JSContext*, Sequence<JSObject*>&) = delete;
 
   // Ensure NonNull does not leak in
   void PassSelf(NonNull<TestInterface>&) = delete;
   void PassSelf(OwningNonNull<TestInterface>&) = delete;
   void PassSelf(const NonNull<TestInterface>&) = delete;
   void PassSelf(const OwningNonNull<TestInterface>&) = delete;
   void PassOther(NonNull<IndirectlyImplementedInterface>&) = delete;
   void PassOther(const NonNull<IndirectlyImplementedInterface>&) = delete;
   void PassOther(OwningNonNull<IndirectlyImplementedInterface>&) = delete;
   void PassOther(const OwningNonNull<IndirectlyImplementedInterface>&) = delete;
   void PassCallbackInterface(OwningNonNull<TestCallbackInterface>&) = delete;
-  void PassCallbackInterface(const OwningNonNull<TestCallbackInterface>&) = delete;
+  void PassCallbackInterface(const OwningNonNull<TestCallbackInterface>&) =
+      delete;
   void PassCallbackInterface(NonNull<TestCallbackInterface>&) = delete;
   void PassCallbackInterface(const NonNull<TestCallbackInterface>&) = delete;
   void PassCallback(OwningNonNull<TestCallback>&) = delete;
   void PassCallback(const OwningNonNull<TestCallback>&) = delete;
   void PassCallback(NonNull<TestCallback>&) = delete;
   void PassCallback(const NonNull<TestCallback>&) = delete;
   void PassString(const NonNull<nsAString>&) = delete;
   void PassString(NonNull<nsAString>&) = delete;
   void PassString(const OwningNonNull<nsAString>&) = delete;
   void PassString(OwningNonNull<nsAString>&) = delete;
 };
 
-class TestIndexedGetterInterface : public nsISupports,
-                                   public nsWrapperCache
-{
-public:
+class TestIndexedGetterInterface : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   uint32_t IndexedGetter(uint32_t, bool&);
   uint32_t IndexedGetter(uint32_t&) = delete;
   uint32_t Item(uint32_t&);
   uint32_t Item(uint32_t, bool&) = delete;
   uint32_t Length();
   void LegacyCall(JS::Handle<JS::Value>);
   int32_t CachedAttr();
   int32_t StoreInSlotAttr();
 };
 
-class TestNamedGetterInterface : public nsISupports,
-                                 public nsWrapperCache
-{
-public:
+class TestNamedGetterInterface : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   void NamedGetter(const nsAString&, bool&, nsAString&);
   void GetSupportedNames(nsTArray<nsString>&);
 };
 
-class TestIndexedGetterAndSetterAndNamedGetterInterface : public nsISupports,
-                                                          public nsWrapperCache
-{
-public:
+class TestIndexedGetterAndSetterAndNamedGetterInterface
+    : public nsISupports,
+      public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   void NamedGetter(const nsAString&, bool&, nsAString&);
   void GetSupportedNames(nsTArray<nsString>&);
   int32_t IndexedGetter(uint32_t, bool&);
   void IndexedSetter(uint32_t, int32_t);
   uint32_t Length();
 };
 
 class TestIndexedAndNamedGetterInterface : public nsISupports,
-                                           public nsWrapperCache
-{
-public:
+                                           public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   uint32_t IndexedGetter(uint32_t, bool&);
   void NamedGetter(const nsAString&, bool&, nsAString&);
   void NamedItem(const nsAString&, nsAString&);
   uint32_t Length();
   void GetSupportedNames(nsTArray<nsString>&);
 };
 
-class TestIndexedSetterInterface : public nsISupports,
-                                   public nsWrapperCache
-{
-public:
+class TestIndexedSetterInterface : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   void IndexedSetter(uint32_t, const nsAString&);
   void IndexedGetter(uint32_t, bool&, nsString&);
   uint32_t Length();
   void SetItem(uint32_t, const nsAString&);
 };
 
-class TestNamedSetterInterface : public nsISupports,
-                                 public nsWrapperCache
-{
-public:
+class TestNamedSetterInterface : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   void NamedSetter(const nsAString&, TestIndexedSetterInterface&);
   TestIndexedSetterInterface* NamedGetter(const nsAString&, bool&);
   void GetSupportedNames(nsTArray<nsString>&);
 };
 
 class TestIndexedAndNamedSetterInterface : public nsISupports,
-                                           public nsWrapperCache
-{
-public:
+                                           public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   void IndexedSetter(uint32_t, TestIndexedSetterInterface&);
   TestIndexedSetterInterface* IndexedGetter(uint32_t, bool&);
   uint32_t Length();
   void NamedSetter(const nsAString&, TestIndexedSetterInterface&);
   TestIndexedSetterInterface* NamedGetter(const nsAString&, bool&);
   void SetNamedItem(const nsAString&, TestIndexedSetterInterface&);
   void GetSupportedNames(nsTArray<nsString>&);
 };
 
-class TestIndexedAndNamedGetterAndSetterInterface : public TestIndexedSetterInterface
-{
-public:
+class TestIndexedAndNamedGetterAndSetterInterface
+    : public TestIndexedSetterInterface {
+ public:
   uint32_t IndexedGetter(uint32_t, bool&);
   uint32_t Item(uint32_t);
   void NamedGetter(const nsAString&, bool&, nsAString&);
   void NamedItem(const nsAString&, nsAString&);
   void IndexedSetter(uint32_t, int32_t&);
   void IndexedSetter(uint32_t, const nsAString&) = delete;
   void NamedSetter(const nsAString&, const nsAString&);
   void Stringify(nsAString&);
   uint32_t Length();
   void GetSupportedNames(nsTArray<nsString>&);
 };
 
 class TestCppKeywordNamedMethodsInterface : public nsISupports,
-                                            public nsWrapperCache
-{
-public:
+                                            public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   bool Continue();
   bool Delete();
   int32_t Volatile();
 };
 
-class TestNamedDeleterInterface : public nsISupports,
-                                  public nsWrapperCache
-{
-public:
+class TestNamedDeleterInterface : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   void NamedDeleter(const nsAString&, bool&);
   long NamedGetter(const nsAString&, bool&);
   void GetSupportedNames(nsTArray<nsString>&);
 };
 
 class TestNamedDeleterWithRetvalInterface : public nsISupports,
-                                            public nsWrapperCache
-{
-public:
+                                            public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 
   bool NamedDeleter(const nsAString&, bool&);
   bool NamedDeleter(const nsAString&) = delete;
   long NamedGetter(const nsAString&, bool&);
   bool DelNamedItem(const nsAString&);
   bool DelNamedItem(const nsAString&, bool&) = delete;
   void GetSupportedNames(nsTArray<nsString>&);
 };
 
-class TestParentInterface : public nsISupports,
-                            public nsWrapperCache
-{
-public:
+class TestParentInterface : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   virtual nsISupports* GetParentObject();
 };
 
-class TestChildInterface : public TestParentInterface
-{
-};
+class TestChildInterface : public TestParentInterface {};
 
-class TestDeprecatedInterface : public nsISupports, public nsWrapperCache
-{
-public:
+class TestDeprecatedInterface : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
-  static
-  already_AddRefed<TestDeprecatedInterface>
-    Constructor(const GlobalObject&, ErrorResult&);
+  static already_AddRefed<TestDeprecatedInterface> Constructor(
+      const GlobalObject&, ErrorResult&);
 
   static void AlsoDeprecated(const GlobalObject&);
 
   virtual nsISupports* GetParentObject();
 };
 
-class TestInterfaceWithPromiseConstructorArg : public nsISupports, public nsWrapperCache
-{
-public:
+class TestInterfaceWithPromiseConstructorArg : public nsISupports,
+                                               public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
-  static
-  already_AddRefed<TestInterfaceWithPromiseConstructorArg>
-    Constructor(const GlobalObject&, Promise&, ErrorResult&);
+  static already_AddRefed<TestInterfaceWithPromiseConstructorArg> Constructor(
+      const GlobalObject&, Promise&, ErrorResult&);
 
   virtual nsISupports* GetParentObject();
 };
 
-class TestSecureContextInterface : public nsISupports, public nsWrapperCache
-{
-public:
+class TestSecureContextInterface : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
-  static
-  already_AddRefed<TestSecureContextInterface>
-    Constructor(const GlobalObject&, ErrorResult&);
+  static already_AddRefed<TestSecureContextInterface> Constructor(
+      const GlobalObject&, ErrorResult&);
 
   static void AlsoSecureContext(const GlobalObject&);
 
   virtual nsISupports* GetParentObject();
 };
 
 class TestNamespace {
-public:
+ public:
   static bool Foo(const GlobalObject&);
   static int32_t Bar(const GlobalObject&);
   static void Baz(const GlobalObject&);
 };
 
-class TestRenamedNamespace {
-};
+class TestRenamedNamespace {};
 
-class TestProtoObjectHackedNamespace {
-};
+class TestProtoObjectHackedNamespace {};
 
-class TestWorkerExposedInterface : public nsISupports,
-                                   public nsWrapperCache
-{
-public:
+class TestWorkerExposedInterface : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject to make binding codegen happy
   nsISupports* GetParentObject();
 
   void NeedsSubjectPrincipalMethod(Maybe<nsIPrincipal*>);
   bool NeedsSubjectPrincipalAttr(Maybe<nsIPrincipal*>);
   void SetNeedsSubjectPrincipalAttr(bool, Maybe<nsIPrincipal*>);
   void NeedsCallerTypeMethod(CallerType);
   bool NeedsCallerTypeAttr(CallerType);
   void SetNeedsCallerTypeAttr(bool, CallerType);
   void NeedsNonSystemSubjectPrincipalMethod(Maybe<nsIPrincipal*>);
   bool NeedsNonSystemSubjectPrincipalAttr(Maybe<nsIPrincipal*>);
   void SetNeedsNonSystemSubjectPrincipalAttr(bool, Maybe<nsIPrincipal*>);
 };
 
-class TestHTMLConstructorInterface : public nsGenericHTMLElement
-{
-public:
+class TestHTMLConstructorInterface : public nsGenericHTMLElement {
+ public:
   virtual nsISupports* GetParentObject();
 };
 
-class TestCEReactionsInterface : public nsISupports,
-                                 public nsWrapperCache
-{
-public:
+class TestCEReactionsInterface : public nsISupports, public nsWrapperCache {
+ public:
   NS_DECL_ISUPPORTS
 
   // We need a GetParentObject and GetDocGroup to make binding codegen happy
   virtual nsISupports* GetParentObject();
   DocGroup* GetDocGroup() const;
 
   int32_t Item(uint32_t);
   uint32_t Length() const;
-  int32_t IndexedGetter(uint32_t, bool &);
+  int32_t IndexedGetter(uint32_t, bool&);
   void IndexedSetter(uint32_t, int32_t);
-  void NamedDeleter(const nsAString&, bool &);
-  void NamedGetter(const nsAString&, bool &, nsString&);
+  void NamedDeleter(const nsAString&, bool&);
+  void NamedGetter(const nsAString&, bool&, nsString&);
   void NamedSetter(const nsAString&, const nsAString&);
   void GetSupportedNames(nsTArray<nsString>&);
 };
 
-} // namespace dom
-} // namespace mozilla
+}  // namespace dom
+}  // namespace mozilla
 
 #endif /* TestBindingHeader_h */