--- a/accessible/base/MarkupMap.h
+++ b/accessible/base/MarkupMap.h
@@ -1,60 +1,61 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:expandtab:shiftwidth=2:tabstop=2:
  */
 /* 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/. */
 
-MARKUPMAP(a,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            // Only some roles truly enjoy life as HTMLLinkAccessibles, for
-            // details see closed bug 494807.
-            const nsRoleMapEntry* roleMapEntry = aria::GetRoleMap(aElement);
-            if (roleMapEntry && roleMapEntry->role != roles::NOTHING &&
-                roleMapEntry->role != roles::LINK) {
-              return new HyperTextAccessibleWrap(aElement,
-                                                 aContext->Document());
-            }
+MARKUPMAP(
+    a,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      // Only some roles truly enjoy life as HTMLLinkAccessibles, for
+      // details see closed bug 494807.
+      const nsRoleMapEntry* roleMapEntry = aria::GetRoleMap(aElement);
+      if (roleMapEntry && roleMapEntry->role != roles::NOTHING &&
+          roleMapEntry->role != roles::LINK) {
+        return new HyperTextAccessibleWrap(aElement, aContext->Document());
+      }
 
-            return new HTMLLinkAccessible(aElement, aContext->Document());
-          },
-          roles::LINK)
+      return new HTMLLinkAccessible(aElement, aContext->Document());
+    },
+    roles::LINK);
 
 MARKUPMAP(abbr, New_HyperText, 0)
 
 MARKUPMAP(acronym, New_HyperText, 0)
 
 MARKUPMAP(article, New_HyperText, roles::ARTICLE, Attr(xmlroles, article))
 
 MARKUPMAP(aside, New_HyperText, roles::LANDMARK)
 
 MARKUPMAP(blockquote, New_HyperText, roles::BLOCKQUOTE)
 
-MARKUPMAP(button,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLButtonAccessible(aElement, aContext->Document());
-          },
-          0)
+MARKUPMAP(
+    button,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLButtonAccessible(aElement, aContext->Document());
+    },
+    0)
 
-MARKUPMAP(caption,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            if (aContext->IsTable()) {
-              dom::HTMLTableElement* tableEl =
-                  dom::HTMLTableElement::FromNode(aContext->GetContent());
-              if (tableEl && tableEl == aElement->GetParent() &&
-                  tableEl->GetCaption() == aElement) {
-                return new HTMLCaptionAccessible(aElement,
-                                                 aContext->Document());
-              }
-            }
-            return nullptr;
-          },
-          0)
+MARKUPMAP(
+    caption,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      if (aContext->IsTable()) {
+        dom::HTMLTableElement* tableEl =
+            dom::HTMLTableElement::FromNode(aContext->GetContent());
+        if (tableEl && tableEl == aElement->GetParent() &&
+            tableEl->GetCaption() == aElement) {
+          return new HTMLCaptionAccessible(aElement, aContext->Document());
+        }
+      }
+      return nullptr;
+    },
+    0)
 
 MARKUPMAP(dd, New_HTMLDtOrDd<HyperTextAccessibleWrap>, roles::DEFINITION)
 
 MARKUPMAP(del, New_HyperText, roles::CONTENT_DELETION)
 
 MARKUPMAP(details, New_HyperText, roles::DETAILS)
 
 MARKUPMAP(
@@ -115,139 +116,148 @@ MARKUPMAP(
             return new HyperTextAccessibleWrap(aElement, aContext->Document());
           }
         }
       }
       return nullptr;
     },
     roles::SECTION)
 
-MARKUPMAP(dl,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLListAccessible(aElement, aContext->Document());
-          },
-          roles::DEFINITION_LIST)
+MARKUPMAP(
+    dl,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLListAccessible(aElement, aContext->Document());
+    },
+    roles::DEFINITION_LIST)
 
 MARKUPMAP(dt, New_HTMLDtOrDd<HTMLLIAccessible>, roles::TERM)
 
-MARKUPMAP(figcaption,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLFigcaptionAccessible(aElement, aContext->Document());
-          },
-          roles::CAPTION)
+MARKUPMAP(
+    figcaption,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLFigcaptionAccessible(aElement, aContext->Document());
+    },
+    roles::CAPTION)
 
-MARKUPMAP(figure,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLFigureAccessible(aElement, aContext->Document());
-          },
-          roles::FIGURE, Attr(xmlroles, figure))
+MARKUPMAP(
+    figure,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLFigureAccessible(aElement, aContext->Document());
+    },
+    roles::FIGURE, Attr(xmlroles, figure))
 
-MARKUPMAP(fieldset,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLGroupboxAccessible(aElement, aContext->Document());
-          },
-          0)
+MARKUPMAP(
+    fieldset,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLGroupboxAccessible(aElement, aContext->Document());
+    },
+    0)
 
-MARKUPMAP(form,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLFormAccessible(aElement, aContext->Document());
-          },
-          0)
+MARKUPMAP(
+    form,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLFormAccessible(aElement, aContext->Document());
+    },
+    0)
 
-MARKUPMAP(footer,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLHeaderOrFooterAccessible(aElement,
-                                                    aContext->Document());
-          },
-          0)
+MARKUPMAP(
+    footer,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLHeaderOrFooterAccessible(aElement, aContext->Document());
+    },
+    0)
 
-MARKUPMAP(header,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLHeaderOrFooterAccessible(aElement,
-                                                    aContext->Document());
-          },
-          0)
+MARKUPMAP(
+    header,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLHeaderOrFooterAccessible(aElement, aContext->Document());
+    },
+    0)
 
 MARKUPMAP(h1, New_HyperText, roles::HEADING)
 
 MARKUPMAP(h2, New_HyperText, roles::HEADING)
 
 MARKUPMAP(h3, New_HyperText, roles::HEADING)
 
 MARKUPMAP(h4, New_HyperText, roles::HEADING)
 
 MARKUPMAP(h5, New_HyperText, roles::HEADING)
 
 MARKUPMAP(h6, New_HyperText, roles::HEADING)
 
-MARKUPMAP(hr,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLHRAccessible(aElement, aContext->Document());
-          },
-          0)
+MARKUPMAP(
+    hr,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLHRAccessible(aElement, aContext->Document());
+    },
+    0)
 
-MARKUPMAP(input,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            // TODO(emilio): This would be faster if it used
-            // HTMLInputElement's already-parsed representation.
-            if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
-                                      nsGkAtoms::checkbox, eIgnoreCase)) {
-              return new CheckboxAccessible(aElement, aContext->Document());
-            }
-            if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
-                                      nsGkAtoms::image, eIgnoreCase)) {
-              return new HTMLButtonAccessible(aElement, aContext->Document());
-            }
-            if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
-                                      nsGkAtoms::radio, eIgnoreCase)) {
-              return new HTMLRadioButtonAccessible(aElement,
-                                                   aContext->Document());
-            }
-            if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
-                                      nsGkAtoms::time, eIgnoreCase)) {
-              return new EnumRoleAccessible<roles::GROUPING>(
-                  aElement, aContext->Document());
-            }
-            if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
-                                      nsGkAtoms::date, eIgnoreCase)) {
-              return new EnumRoleAccessible<roles::DATE_EDITOR>(
-                  aElement, aContext->Document());
-            }
-            return nullptr;
-          },
-          0)
+MARKUPMAP(
+    input,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      // TODO(emilio): This would be faster if it used
+      // HTMLInputElement's already-parsed representation.
+      if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                nsGkAtoms::checkbox, eIgnoreCase)) {
+        return new CheckboxAccessible(aElement, aContext->Document());
+      }
+      if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                nsGkAtoms::image, eIgnoreCase)) {
+        return new HTMLButtonAccessible(aElement, aContext->Document());
+      }
+      if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                nsGkAtoms::radio, eIgnoreCase)) {
+        return new HTMLRadioButtonAccessible(aElement, aContext->Document());
+      }
+      if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                nsGkAtoms::time, eIgnoreCase)) {
+        return new EnumRoleAccessible<roles::GROUPING>(aElement,
+                                                       aContext->Document());
+      }
+      if (aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
+                                nsGkAtoms::date, eIgnoreCase)) {
+        return new EnumRoleAccessible<roles::DATE_EDITOR>(aElement,
+                                                          aContext->Document());
+      }
+      return nullptr;
+    },
+    0)
 
 MARKUPMAP(ins, New_HyperText, roles::CONTENT_INSERTION)
 
-MARKUPMAP(label,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLLabelAccessible(aElement, aContext->Document());
-          },
-          roles::LABEL)
+MARKUPMAP(
+    label,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLLabelAccessible(aElement, aContext->Document());
+    },
+    roles::LABEL)
 
-MARKUPMAP(legend,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLLegendAccessible(aElement, aContext->Document());
-          },
-          roles::LABEL)
+MARKUPMAP(
+    legend,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLLegendAccessible(aElement, aContext->Document());
+    },
+    roles::LABEL)
 
-MARKUPMAP(li,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            // If list item is a child of accessible list then create an
-            // accessible for it unconditionally by tag name. nsBlockFrame
-            // creates the list item accessible for other elements styled as
-            // list items.
-            if (aContext->IsList() &&
-                aContext->GetContent() == aElement->GetParent()) {
-              return new HTMLLIAccessible(aElement, aContext->Document());
-            }
+MARKUPMAP(
+    li,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      // If list item is a child of accessible list then create an
+      // accessible for it unconditionally by tag name. nsBlockFrame
+      // creates the list item accessible for other elements styled as
+      // list items.
+      if (aContext->IsList() &&
+          aContext->GetContent() == aElement->GetParent()) {
+        return new HTMLLIAccessible(aElement, aContext->Document());
+      }
 
-            return nullptr;
-          },
-          0)
+      return nullptr;
+    },
+    0)
 
 MARKUPMAP(main, New_HyperText, roles::LANDMARK)
 
 MARKUPMAP(map, nullptr, roles::TEXT_CONTAINER)
 
 MARKUPMAP(math, New_HyperText, roles::MATHML_MATH)
 
 MARKUPMAP(mi_, New_HyperText, roles::MATHML_IDENTIFIER)
@@ -296,41 +306,44 @@ MARKUPMAP(mover_, New_HyperText, roles::
           AttrFromDOM(accent_, accent_), AttrFromDOM(align, align))
 
 MARKUPMAP(munderover_, New_HyperText, roles::MATHML_UNDER_OVER,
           AttrFromDOM(accent_, accent_),
           AttrFromDOM(accentunder_, accentunder_), AttrFromDOM(align, align))
 
 MARKUPMAP(mmultiscripts_, New_HyperText, roles::MATHML_MULTISCRIPTS)
 
-MARKUPMAP(mtable_,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLTableAccessible(aElement, aContext->Document());
-          },
-          roles::MATHML_TABLE, AttrFromDOM(align, align),
-          AttrFromDOM(columnlines_, columnlines_),
-          AttrFromDOM(rowlines_, rowlines_))
+MARKUPMAP(
+    mtable_,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLTableAccessible(aElement, aContext->Document());
+    },
+    roles::MATHML_TABLE, AttrFromDOM(align, align),
+    AttrFromDOM(columnlines_, columnlines_), AttrFromDOM(rowlines_, rowlines_))
 
-MARKUPMAP(mlabeledtr_,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLTableRowAccessible(aElement, aContext->Document());
-          },
-          roles::MATHML_LABELED_ROW)
+MARKUPMAP(
+    mlabeledtr_,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLTableRowAccessible(aElement, aContext->Document());
+    },
+    roles::MATHML_LABELED_ROW)
 
-MARKUPMAP(mtr_,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLTableRowAccessible(aElement, aContext->Document());
-          },
-          roles::MATHML_TABLE_ROW)
+MARKUPMAP(
+    mtr_,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLTableRowAccessible(aElement, aContext->Document());
+    },
+    roles::MATHML_TABLE_ROW)
 
-MARKUPMAP(mtd_,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLTableCellAccessible(aElement, aContext->Document());
-          },
-          roles::MATHML_CELL)
+MARKUPMAP(
+    mtd_,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLTableCellAccessible(aElement, aContext->Document());
+    },
+    roles::MATHML_CELL)
 
 MARKUPMAP(maction_, New_HyperText, roles::MATHML_ACTION,
           AttrFromDOM(actiontype_, actiontype_),
           AttrFromDOM(selection_, selection_))
 
 MARKUPMAP(merror_, New_HyperText, roles::MATHML_ERROR)
 
 MARKUPMAP(mstack_, New_HyperText, roles::MATHML_STACK,
@@ -351,178 +364,188 @@ MARKUPMAP(mscarries_, New_HyperText, rol
 MARKUPMAP(mscarry_, New_HyperText, roles::MATHML_STACK_CARRY,
           AttrFromDOM(crossout_, crossout_))
 
 MARKUPMAP(msline_, New_HyperText, roles::MATHML_STACK_LINE,
           AttrFromDOM(position, position))
 
 MARKUPMAP(nav, New_HyperText, roles::LANDMARK)
 
-MARKUPMAP(ol,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLListAccessible(aElement, aContext->Document());
-          },
-          roles::LIST)
+MARKUPMAP(
+    ol,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLListAccessible(aElement, aContext->Document());
+    },
+    roles::LIST)
 
-MARKUPMAP(option,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLSelectOptionAccessible(aElement,
-                                                  aContext->Document());
-          },
-          0)
+MARKUPMAP(
+    option,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLSelectOptionAccessible(aElement, aContext->Document());
+    },
+    0)
 
-MARKUPMAP(optgroup,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLSelectOptGroupAccessible(aElement,
-                                                    aContext->Document());
-          },
-          0)
+MARKUPMAP(
+    optgroup,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLSelectOptGroupAccessible(aElement, aContext->Document());
+    },
+    0)
 
-MARKUPMAP(output,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLOutputAccessible(aElement, aContext->Document());
-          },
-          roles::SECTION, Attr(live, polite))
+MARKUPMAP(
+    output,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLOutputAccessible(aElement, aContext->Document());
+    },
+    roles::SECTION, Attr(live, polite))
 
 MARKUPMAP(p, nullptr, roles::PARAGRAPH)
 
-MARKUPMAP(progress,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLProgressAccessible(aElement, aContext->Document());
-          },
-          0)
+MARKUPMAP(
+    progress,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLProgressAccessible(aElement, aContext->Document());
+    },
+    0)
 
 MARKUPMAP(q, New_HyperText, 0)
 
-MARKUPMAP(section,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLSectionAccessible(aElement, aContext->Document());
-          },
-          0)
+MARKUPMAP(
+    section,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLSectionAccessible(aElement, aContext->Document());
+    },
+    0)
 
-MARKUPMAP(summary,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLSummaryAccessible(aElement, aContext->Document());
-          },
-          roles::SUMMARY)
+MARKUPMAP(
+    summary,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLSummaryAccessible(aElement, aContext->Document());
+    },
+    roles::SUMMARY)
 
-MARKUPMAP(table,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            if (aElement->GetPrimaryFrame() &&
-                aElement->GetPrimaryFrame()->AccessibleType() !=
-                    eHTMLTableType) {
-              return new ARIAGridAccessibleWrap(aElement, aContext->Document());
-            }
-            return nullptr;
-          },
-          0)
+MARKUPMAP(
+    table,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      if (aElement->GetPrimaryFrame() &&
+          aElement->GetPrimaryFrame()->AccessibleType() != eHTMLTableType) {
+        return new ARIAGridAccessibleWrap(aElement, aContext->Document());
+      }
+      return nullptr;
+    },
+    0)
 
 MARKUPMAP(time, New_HyperText, 0, Attr(xmlroles, time),
           AttrFromDOM(datetime, datetime))
 
-MARKUPMAP(tbody,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            // Expose this as a grouping if its frame type is non-standard.
-            if (aElement->GetPrimaryFrame() &&
-                aElement->GetPrimaryFrame()->IsTableRowGroupFrame()) {
-              return nullptr;
-            }
-            return new HyperTextAccessibleWrap(aElement, aContext->Document());
-          },
-          roles::GROUPING)
+MARKUPMAP(
+    tbody,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      // Expose this as a grouping if its frame type is non-standard.
+      if (aElement->GetPrimaryFrame() &&
+          aElement->GetPrimaryFrame()->IsTableRowGroupFrame()) {
+        return nullptr;
+      }
+      return new HyperTextAccessibleWrap(aElement, aContext->Document());
+    },
+    roles::GROUPING)
 
-MARKUPMAP(td,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            if (aContext->IsTableRow() &&
-                aContext->GetContent() == aElement->GetParent()) {
-              // If HTML:td element is part of its HTML:table, which has CSS
-              // display style other than 'table', then create a generic table
-              // cell accessible, because there's no underlying table layout and
-              // thus native HTML table cell class doesn't work. The same is
-              // true if the cell itself has CSS display:block;.
-              if (!aContext->IsHTMLTableRow() ||
-                  (aElement->GetPrimaryFrame() &&
-                   aElement->GetPrimaryFrame()->AccessibleType() !=
-                       eHTMLTableCellType)) {
-                return new ARIAGridCellAccessibleWrap(aElement,
-                                                      aContext->Document());
-              }
-              if (aElement->HasAttr(kNameSpaceID_None, nsGkAtoms::scope)) {
-                return new HTMLTableHeaderCellAccessibleWrap(
-                    aElement, aContext->Document());
-              }
-            }
-            return nullptr;
-          },
-          0)
+MARKUPMAP(
+    td,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      if (aContext->IsTableRow() &&
+          aContext->GetContent() == aElement->GetParent()) {
+        // If HTML:td element is part of its HTML:table, which has CSS
+        // display style other than 'table', then create a generic table
+        // cell accessible, because there's no underlying table layout and
+        // thus native HTML table cell class doesn't work. The same is
+        // true if the cell itself has CSS display:block;.
+        if (!aContext->IsHTMLTableRow() ||
+            (aElement->GetPrimaryFrame() &&
+             aElement->GetPrimaryFrame()->AccessibleType() !=
+                 eHTMLTableCellType)) {
+          return new ARIAGridCellAccessibleWrap(aElement, aContext->Document());
+        }
+        if (aElement->HasAttr(kNameSpaceID_None, nsGkAtoms::scope)) {
+          return new HTMLTableHeaderCellAccessibleWrap(aElement,
+                                                       aContext->Document());
+        }
+      }
+      return nullptr;
+    },
+    0)
 
-MARKUPMAP(tfoot,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            // Expose this as a grouping if its frame type is non-standard.
-            if (aElement->GetPrimaryFrame() &&
-                aElement->GetPrimaryFrame()->IsTableRowGroupFrame()) {
-              return nullptr;
-            }
-            return new HyperTextAccessibleWrap(aElement, aContext->Document());
-          },
-          roles::GROUPING)
+MARKUPMAP(
+    tfoot,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      // Expose this as a grouping if its frame type is non-standard.
+      if (aElement->GetPrimaryFrame() &&
+          aElement->GetPrimaryFrame()->IsTableRowGroupFrame()) {
+        return nullptr;
+      }
+      return new HyperTextAccessibleWrap(aElement, aContext->Document());
+    },
+    roles::GROUPING)
 
-MARKUPMAP(th,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            if (aContext->IsTableRow() &&
-                aContext->GetContent() == aElement->GetParent()) {
-              if (!aContext->IsHTMLTableRow()) {
-                return new ARIAGridCellAccessibleWrap(aElement,
-                                                      aContext->Document());
-              }
-              return new HTMLTableHeaderCellAccessibleWrap(
-                  aElement, aContext->Document());
-            }
-            return nullptr;
-          },
-          0)
+MARKUPMAP(
+    th,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      if (aContext->IsTableRow() &&
+          aContext->GetContent() == aElement->GetParent()) {
+        if (!aContext->IsHTMLTableRow()) {
+          return new ARIAGridCellAccessibleWrap(aElement, aContext->Document());
+        }
+        return new HTMLTableHeaderCellAccessibleWrap(aElement,
+                                                     aContext->Document());
+      }
+      return nullptr;
+    },
+    0)
 
-MARKUPMAP(tfoot,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            // Expose this as a grouping if its frame type is non-standard.
-            if (aElement->GetPrimaryFrame() &&
-                aElement->GetPrimaryFrame()->IsTableRowGroupFrame()) {
-              return nullptr;
-            }
-            return new HyperTextAccessibleWrap(aElement, aContext->Document());
-          },
-          roles::GROUPING)
+MARKUPMAP(
+    tfoot,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      // Expose this as a grouping if its frame type is non-standard.
+      if (aElement->GetPrimaryFrame() &&
+          aElement->GetPrimaryFrame()->IsTableRowGroupFrame()) {
+        return nullptr;
+      }
+      return new HyperTextAccessibleWrap(aElement, aContext->Document());
+    },
+    roles::GROUPING)
 
-MARKUPMAP(tr,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            // If HTML:tr element is part of its HTML:table, which has CSS
-            // display style other than 'table', then create a generic table row
-            // accessible, because there's no underlying table layout and thus
-            // native HTML table row class doesn't work. Refer to
-            // CreateAccessibleByFrameType dual logic.
-            Accessible* table = aContext->IsTable() ? aContext : nullptr;
-            if (!table && aContext->Parent() && aContext->Parent()->IsTable()) {
-              table = aContext->Parent();
-            }
-            if (table) {
-              nsIContent* parentContent = aElement->GetParent();
-              nsIFrame* parentFrame = parentContent->GetPrimaryFrame();
-              if (parentFrame && !parentFrame->IsTableWrapperFrame()) {
-                parentContent = parentContent->GetParent();
-                parentFrame = parentContent->GetPrimaryFrame();
-                if (table->GetContent() == parentContent &&
-                    ((parentFrame && !parentFrame->IsTableWrapperFrame()) ||
-                     (aElement->GetPrimaryFrame() &&
-                      aElement->GetPrimaryFrame()->AccessibleType() !=
-                          eHTMLTableRowType))) {
-                  return new ARIARowAccessible(aElement, aContext->Document());
-                }
-              }
-            }
-            return nullptr;
-          },
-          0)
+MARKUPMAP(
+    tr,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      // If HTML:tr element is part of its HTML:table, which has CSS
+      // display style other than 'table', then create a generic table row
+      // accessible, because there's no underlying table layout and thus
+      // native HTML table row class doesn't work. Refer to
+      // CreateAccessibleByFrameType dual logic.
+      Accessible* table = aContext->IsTable() ? aContext : nullptr;
+      if (!table && aContext->Parent() && aContext->Parent()->IsTable()) {
+        table = aContext->Parent();
+      }
+      if (table) {
+        nsIContent* parentContent = aElement->GetParent();
+        nsIFrame* parentFrame = parentContent->GetPrimaryFrame();
+        if (parentFrame && !parentFrame->IsTableWrapperFrame()) {
+          parentContent = parentContent->GetParent();
+          parentFrame = parentContent->GetPrimaryFrame();
+          if (table->GetContent() == parentContent &&
+              ((parentFrame && !parentFrame->IsTableWrapperFrame()) ||
+               (aElement->GetPrimaryFrame() &&
+                aElement->GetPrimaryFrame()->AccessibleType() !=
+                    eHTMLTableRowType))) {
+            return new ARIARowAccessible(aElement, aContext->Document());
+          }
+        }
+      }
+      return nullptr;
+    },
+    0)
 
-MARKUPMAP(ul,
-          [](Element* aElement, Accessible* aContext) -> Accessible* {
-            return new HTMLListAccessible(aElement, aContext->Document());
-          },
-          roles::LIST)
+MARKUPMAP(
+    ul,
+    [](Element* aElement, Accessible* aContext) -> Accessible* {
+      return new HTMLListAccessible(aElement, aContext->Document());
+    },
+    roles::LIST)

--- a/caps/tests/gtest/TestOriginAttributes.cpp
+++ b/caps/tests/gtest/TestOriginAttributes.cpp
@@ -12,22 +12,25 @@ static void TestSuffix(const OriginAttri
 
   OriginAttributes attrsFromSuffix;
   bool success = attrsFromSuffix.PopulateFromSuffix(suffix);
   EXPECT_TRUE(success);
 
   EXPECT_EQ(attrs, attrsFromSuffix);
 }
 
-TEST(OriginAttributes, Suffix_default) {
+TEST(OriginAttributes, Suffix_default)
+{
   OriginAttributes attrs;
   TestSuffix(attrs);
 }
 
-TEST(OriginAttributes, Suffix_appId_inIsolatedMozBrowser) {
+TEST(OriginAttributes, Suffix_appId_inIsolatedMozBrowser)
+{
   OriginAttributes attrs(1, true);
   TestSuffix(attrs);
 }
 
-TEST(OriginAttributes, Suffix_maxAppId_inIsolatedMozBrowser) {
+TEST(OriginAttributes, Suffix_maxAppId_inIsolatedMozBrowser)
+{
   OriginAttributes attrs(4294967295, true);
   TestSuffix(attrs);
 }

--- a/dom/base/AnonymousContent.cpp
+++ b/dom/base/AnonymousContent.cpp
@@ -192,18 +192,17 @@ void AnonymousContent::GetComputedStyleP
   }
 
   RefPtr<nsComputedDOMStyle> cs =
       new nsComputedDOMStyle(element, NS_LITERAL_STRING(""),
                              element->OwnerDoc(), nsComputedDOMStyle::eAll);
   aRv = cs->GetPropertyValue(aPropertyName, aResult);
 }
 
-void AnonymousContent::GetTargetIdForEvent(Event& aEvent, DOMString& aResult)
-{
+void AnonymousContent::GetTargetIdForEvent(Event& aEvent, DOMString& aResult) {
   nsCOMPtr<Element> el = do_QueryInterface(aEvent.GetOriginalTarget());
   if (el && el->IsInNativeAnonymousSubtree() && mContentNode->Contains(el)) {
     aResult.SetKnownLiveAtom(el->GetID(), DOMString::eTreatNullAsNull);
     return;
   }
 
   aResult.SetNull();
 }

--- a/dom/base/DocGroup.cpp
+++ b/dom/base/DocGroup.cpp
@@ -138,30 +138,31 @@ RefPtr<PerformanceInfoPromise> DocGroup:
                         items),
         __func__);
   }
 
   MOZ_ASSERT(mainThread);
   RefPtr<DocGroup> self = this;
 
   return CollectMemoryInfo(top, mainThread)
-      ->Then(mainThread, __func__,
-             [self, host, pid, windowID, duration, isTopLevel,
-              items](const PerformanceMemoryInfo& aMemoryInfo) {
-               PerformanceInfo info =
-                   PerformanceInfo(host, pid, windowID, duration,
-                                   self->mPerformanceCounter->GetID(), false,
-                                   isTopLevel, aMemoryInfo, items);
+      ->Then(
+          mainThread, __func__,
+          [self, host, pid, windowID, duration, isTopLevel,
+           items](const PerformanceMemoryInfo& aMemoryInfo) {
+            PerformanceInfo info =
+                PerformanceInfo(host, pid, windowID, duration,
+                                self->mPerformanceCounter->GetID(), false,
+                                isTopLevel, aMemoryInfo, items);
 
-               return PerformanceInfoPromise::CreateAndResolve(std::move(info),
-                                                               __func__);
-             },
-             [self](const nsresult rv) {
-               return PerformanceInfoPromise::CreateAndReject(rv, __func__);
-             });
+            return PerformanceInfoPromise::CreateAndResolve(std::move(info),
+                                                            __func__);
+          },
+          [self](const nsresult rv) {
+            return PerformanceInfoPromise::CreateAndReject(rv, __func__);
+          });
 }
 
 nsresult DocGroup::Dispatch(TaskCategory aCategory,
                             already_AddRefed<nsIRunnable>&& aRunnable) {
   if (mPerformanceCounter) {
     mPerformanceCounter->IncrementDispatchCounter(DispatchCategory(aCategory));
   }
   return mTabGroup->DispatchWithDocGroup(aCategory, std::move(aRunnable), this);

--- a/dom/base/Document.cpp
+++ b/dom/base/Document.cpp
@@ -12622,29 +12622,30 @@ already_AddRefed<mozilla::dom::Promise> 
         sapr->RequestDelayedTask(
             inner->EventTargetFor(TaskCategory::Other),
             ContentPermissionRequestBase::DelayedTaskType::Request);
         return p.forget();
       };
       AntiTrackingCommon::AddFirstPartyStorageAccessGrantedFor(
           NodePrincipal(), inner, AntiTrackingCommon::eStorageAccessAPI,
           performFinalChecks)
-          ->Then(GetCurrentThreadSerialEventTarget(), __func__,
-                 [outer, promise] {
-                   // Step 10. Grant the document access to cookies and store
-                   // that fact for
-                   //          the purposes of future calls to
-                   //          hasStorageAccess() and requestStorageAccess().
-                   outer->SetHasStorageAccess(true);
-                   promise->MaybeResolveWithUndefined();
-                 },
-                 [outer, promise] {
-                   outer->SetHasStorageAccess(false);
-                   promise->MaybeRejectWithUndefined();
-                 });
+          ->Then(
+              GetCurrentThreadSerialEventTarget(), __func__,
+              [outer, promise] {
+                // Step 10. Grant the document access to cookies and store
+                // that fact for
+                //          the purposes of future calls to
+                //          hasStorageAccess() and requestStorageAccess().
+                outer->SetHasStorageAccess(true);
+                promise->MaybeResolveWithUndefined();
+              },
+              [outer, promise] {
+                outer->SetHasStorageAccess(false);
+                promise->MaybeRejectWithUndefined();
+              });
 
       return promise.forget();
     }
   }
 
   outer->SetHasStorageAccess(true);
   promise->MaybeResolveWithUndefined();
   return promise.forget();

--- a/dom/base/TreeOrderedArrayInlines.h
+++ b/dom/base/TreeOrderedArrayInlines.h
@@ -42,17 +42,16 @@ size_t TreeOrderedArray<Node>::Insert(No
       if (nsContentUtils::PositionIsBefore(&mNode, curNode)) {
         return -1;
       }
       return 1;
     }
   };
 
   size_t idx;
-  BinarySearchIf(mList, 0, mList.Length(),
-                 PositionComparator(aNode), &idx);
+  BinarySearchIf(mList, 0, mList.Length(), PositionComparator(aNode), &idx);
   mList.InsertElementAt(idx, &aNode);
   return idx;
 }
 
 }  // namespace dom
 }  // namespace mozilla
 #endif

--- a/dom/base/UIDirectionManager.cpp
+++ b/dom/base/UIDirectionManager.cpp
@@ -46,18 +46,17 @@ void OnPrefChange(const char* aPrefName,
     }
   }
 }
 
 /* static */
 void UIDirectionManager::Initialize() {
   DebugOnly<nsresult> rv =
       Preferences::RegisterCallback(OnPrefChange, "intl.uidirection");
-  MOZ_ASSERT(NS_SUCCEEDED(rv),
-             "Failed to observe \"intl.uidirection\"");
+  MOZ_ASSERT(NS_SUCCEEDED(rv), "Failed to observe \"intl.uidirection\"");
 }
 
 /* static */
 void UIDirectionManager::Shutdown() {
   Preferences::UnregisterCallback(OnPrefChange, "intl.uidirection");
 }
 
 }  // namespace dom

--- a/dom/base/nsAttrValue.cpp
+++ b/dom/base/nsAttrValue.cpp
@@ -1640,17 +1640,19 @@ MiscContainer* nsAttrValue::ClearMiscCon
         case eAtomArray: {
           delete cont->mValue.mAtomArray;
           break;
         }
         case eIntMarginValue: {
           delete cont->mValue.mIntMargin;
           break;
         }
-        default: { break; }
+        default: {
+          break;
+        }
       }
     }
     ResetMiscAtomOrString();
   } else {
     ResetIfSet();
   }
 
   return cont;

--- a/dom/base/nsAttrValueInlines.h
+++ b/dom/base/nsAttrValueInlines.h
@@ -237,13 +237,15 @@ inline void nsAttrValue::ToString(mozill
       // else aResult is already empty
       return;
     }
     case eAtom: {
       nsAtom* atom = static_cast<nsAtom*>(GetPtr());
       aResult.SetKnownLiveAtom(atom, mozilla::dom::DOMString::eNullNotExpected);
       break;
     }
-    default: { ToString(aResult.AsAString()); }
+    default: {
+      ToString(aResult.AsAString());
+    }
   }
 }
 
 #endif

--- a/dom/base/nsCCUncollectableMarker.cpp
+++ b/dom/base/nsCCUncollectableMarker.cpp
@@ -421,17 +421,19 @@ nsresult nsCCUncollectableMarker::Observ
           mozilla::services::GetObserverService();
       static_cast<nsObserverService*>(obs.get())->UnmarkGrayStrongObservers();
       break;
     }
     case eUnmarkJSHolders: {
       xpc_UnmarkSkippableJSHolders();
       break;
     }
-    default: { break; }
+    default: {
+      break;
+    }
   }
 
   return NS_OK;
 }
 
 void mozilla::dom::TraceBlackJS(JSTracer* aTrc, bool aIsShutdownGC) {
 #ifdef MOZ_XUL
   // Mark the scripts held in the XULPrototypeCache. This is required to keep

--- a/dom/base/test/gtest/TestContentUtils.cpp
+++ b/dom/base/test/gtest/TestContentUtils.cpp
@@ -6,31 +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) {
+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) {
+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));

--- a/dom/base/test/gtest/TestMimeType.cpp
+++ b/dom/base/test/gtest/TestMimeType.cpp
@@ -6,600 +6,715 @@
 
 #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";
 }
 
-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";
 }
 
-TEST(MimeType, JustBackslash) {
+TEST(MimeType, JustBackslash)
+{
   const auto in = NS_LITERAL_STRING("\\");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
   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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-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";
 }
 
-TEST(MimeType, MultipleParameters) {
+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";
+  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";
+  << "Multiple parameters";
 }
 
-TEST(MimeType, DuplicateParameter1) {
+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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.Equals(NS_LITERAL_STRING("text/html;charset=gbk")))
-      << "Duplicate parameter #1";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.Equals(NS_LITERAL_STRING("text/html;charset=\"()\"")))
-      << "Duplicate parameter #2";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsCString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.Equals(NS_LITERAL_CSTRING("text/html;charset=\"()\"")))
-      << "Duplicate parameter #2";
+  << "Duplicate parameter #2";
 }
 
 #ifdef _MSC_VER
 #  pragma warning(push)
 #  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";
+  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";
+  << "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";
+  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";
+  << "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";
+  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";
+  << "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";
+  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";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("x/x;test=\"\""))
-      << "Improperly-quoted parameter is handled properly #1";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("x/x;test=\"\\\\\""))
-      << "Improperly-quoted parameter is handled properly #2";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("x/x;x=x"))
-      << "Non latin-1 parameters are ignored";
+  << "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";
+  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";
+  << "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";
+  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";
+  << "Parameter ignored if whitespace in name #2";
 }
 
-TEST(MimeType, WhitespaceTrimmed) {
+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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/plain;charset=123"))
-      << "Whitespace appropriately ignored";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
+  nsAutoString out;
+  parsed->Serialize(out);
+  ASSERT_TRUE(out.EqualsLiteral("x/x"))
+  << "Whitespace-only parameter is ignored";
+}
+
+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"))
-      << "Whitespace-only parameter is ignored";
+  << "Incomplete parameter is ignored #1";
 }
 
-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";
-}
-
-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";
+  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";
+  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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Incomplete parameter is ignored #4";
+  << "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";
-}
-
-TEST(MimeType, EmptyParameterIgnored1) {
-  const auto in = NS_LITERAL_STRING("text/html ; ; charset=gbk");
-  UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Empty parameter ignored #1";
+  << "Incomplete parameter is ignored #5";
 }
 
-TEST(MimeType, EmptyParameterIgnored2) {
-  const auto in = NS_LITERAL_STRING("text/html;;;;charset=gbk");
+TEST(MimeType, EmptyParameterIgnored1)
+{
+  const auto in = NS_LITERAL_STRING("text/html ; ; charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Empty parameter ignored #2";
+  << "Empty parameter ignored #1";
 }
 
-TEST(MimeType, InvalidParameterIgnored1) {
-  const auto in = NS_LITERAL_STRING("text/html;';charset=gbk");
+TEST(MimeType, EmptyParameterIgnored2)
+{
+  const auto in = NS_LITERAL_STRING("text/html;;;;charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Invalid parameter ignored #1";
+  << "Empty parameter ignored #2";
 }
 
-TEST(MimeType, InvalidParameterIgnored2) {
-  const auto in = NS_LITERAL_STRING("text/html;\";charset=gbk;=123; =321");
+TEST(MimeType, InvalidParameterIgnored1)
+{
+  const auto in = NS_LITERAL_STRING("text/html;';charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Invalid parameter ignored #2";
+  << "Invalid parameter ignored #1";
 }
 
-TEST(MimeType, InvalidParameterIgnored3) {
+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";
+}
+
+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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=GBK"))
-      << "Invalid parameter ignored #3";
+  << "Invalid parameter ignored #3";
 }
 
-TEST(MimeType, InvalidParameterIgnored4) {
+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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=GBK"))
-      << "Invalid parameter ignored #4";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset='gbk'"))
-      << "Single quotes handled properly #1";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset='gbk"))
-      << "Single quotes handled properly #2";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk'"))
-      << "Single quotes handled properly #3";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset='"))
-      << "Single quotes handled properly #4";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset='''"))
-      << "Single quotes handled properly #5";
+  << "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";
-}
-
-TEST(MimeType, DoubleQuotes2) {
-  const auto in = NS_LITERAL_STRING("text/html;charset=\"gbk");
-  UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Double quotes handled properly #2";
+  << "Double quotes handled properly #1";
 }
 
-TEST(MimeType, DoubleQuotes3) {
+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";
+}
+
+TEST(MimeType, DoubleQuotes3)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=gbk\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"gbk\\\"\""))
-      << "Double quotes handled properly #3";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" gbk\""))
-      << "Double quotes handled properly #4";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"gbk \""))
-      << "Double quotes handled properly #5";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" gbk\""))
-      << "Double quotes handled properly #6";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Double quotes handled properly #7";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Double quotes handled properly #8";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"\""))
-      << "Double quotes handled properly #9";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\";charset=GBK\""))
-      << "Double quotes handled properly #10";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"{gbk}\""))
-      << "Unexpected code points handled properly";
+  << "Unexpected code points handled properly";
 }
 
-TEST(MimeType, LongTypesSubtypesAccepted) {
+TEST(MimeType, LongTypesSubtypesAccepted)
+{
   const auto in = NS_LITERAL_STRING(
       "012345678901234567890123456789012345678901234567890123456789012345678901"
       "2345678901234567890123456789012345678901234567890123456789/"
       "012345678901234567890123456789012345678901234567890123456789012345678901"
       "2345678901234567890123456789012345678901234567890123456789");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  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 type/subtype accepted";
 }
 
-TEST(MimeType, LongParametersAccepted) {
+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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(in)) << "Long parameters accepted";
+  ASSERT_TRUE(out.Equals(in))
+  << "Long parameters accepted";
 }
 
-TEST(MimeType, AllValidCharactersAccepted1) {
+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"
@@ -608,67 +723,77 @@ TEST(MimeType, AllValidCharactersAccepte
       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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(in)) << "All valid characters accepted #1";
+  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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/plain;charset=TEST"))
-      << "Case normalized properly #1";
+  << "Case normalized properly #1";
 }
 
-TEST(MimeType, CaseNormalization2) {
+TEST(MimeType, CaseNormalization2)
+{
   const auto in = NS_LITERAL_STRING(
       "!#$%&'*+-.^_`|~"
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/"
       "!#$%&'*+-.^_`|~"
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz;!#$%&'*+-"
       ".^_`|~0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz=!#$"
       "%&'*+-.^_`|~"
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral(
       "!#$%&'*+-.^_`|~"
       "0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz/"
       "!#$%&'*+-.^_`|~"
       "0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz;!#$%&'*+-"
       ".^_`|~0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz=!#$"
       "%&'*+-.^_`|~"
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"))
-      << "Case normalized properly #2";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"gbk(\""))
-      << "Legacy comment syntax #1";
+  << "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";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;x=\"(\";charset=gbk"))
-      << "Legacy comment syntax #2";
+  << "Legacy comment syntax #2";
 }