Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan
authorSylvestre Ledru <sledru@mozilla.com>
Fri, 12 Apr 2019 13:14:25 +0000
changeset 469276 f95dc32944ac670befcd7a2d1355877db4ed3831
parent 469275 9517981892925f44013aff6ab06d63b8ad6c9220
child 469277 6800e99ad32ab85ccce4de926e261b93ce2b45fb
push id35861
push userbtara@mozilla.com
push dateFri, 12 Apr 2019 21:56:33 +0000
treeherdermozilla-central@db6f9582aaa8 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersEhsan
bugs1519636
milestone68.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1519636 - Reformat recent changes to the Google coding style r=Ehsan # ignore-this-changeset Differential Revision: https://phabricator.services.mozilla.com/D27245
accessible/atk/Platform.cpp
browser/app/winlauncher/LauncherProcessWin.cpp
docshell/shistory/nsSHistory.cpp
dom/base/ImageEncoder.cpp
dom/base/MaybeCrossOriginObject.cpp
dom/base/RemoteOuterWindowProxy.cpp
dom/base/WindowNamedPropertiesHandler.h
dom/base/nsJSEnvironment.cpp
dom/base/nsObjectLoadingContent.cpp
dom/base/nsObjectLoadingContent.h
dom/bindings/BindingUtils.cpp
dom/bindings/BindingUtils.h
dom/bindings/DOMJSProxyHandler.cpp
dom/bindings/DOMJSProxyHandler.h
dom/bindings/RemoteObjectProxy.cpp
dom/bindings/RemoteObjectProxy.h
dom/bindings/WebIDLGlobalNameHash.cpp
dom/bindings/WebIDLGlobalNameHash.h
dom/gamepad/GamepadRemapping.cpp
dom/gamepad/GamepadRemapping.h
dom/gamepad/windows/WindowsGamepad.cpp
dom/html/HTMLFormElement.cpp
dom/ipc/TabChild.cpp
dom/ipc/TabChild.h
dom/ipc/TabParent.cpp
dom/media/ipc/RDDProcessHost.h
dom/media/webaudio/AudioContext.h
dom/svg/SVGAnimatedIntegerPair.h
dom/svg/SVGAnimatedNumberPair.h
editor/libeditor/HTMLAbsPositionEditor.cpp
editor/libeditor/HTMLEditRules.cpp
editor/libeditor/SelectionState.h
editor/libeditor/WSRunObject.cpp
extensions/universalchardet/src/base/nsUniversalDetector.cpp
gfx/gl/GLContextProviderEGL.cpp
gfx/layers/apz/src/AsyncPanZoomController.cpp
gfx/layers/apz/src/Axis.cpp
gfx/layers/apz/src/GenericFlingAnimation.h
gfx/layers/client/ClientTiledPaintedLayer.cpp
gfx/layers/wr/WebRenderCommandBuilder.cpp
gfx/src/nsFont.h
gfx/thebes/gfxFontFamilyList.h
gfx/thebes/gfxPlatformGtk.cpp
gfx/thebes/gfxTextRun.cpp
gfx/thebes/gfxTextRun.h
gfx/vr/VRDisplayHost.h
gfx/vr/ipc/VRGPUChild.cpp
ipc/glue/GeckoChildProcessHost.cpp
ipc/glue/ProcessUtils_common.cpp
js/ipc/WrapperOwner.cpp
js/public/Wrapper.h
js/src/builtin/Stream.cpp
js/src/builtin/TypedObject.cpp
js/src/frontend/TokenStream.h
js/src/gc/GCRuntime.h
js/src/jit/BaselineIC.h
js/src/jit/CacheIR.cpp
js/src/jsapi-tests/testFreshGlobalEvalRedefinition.cpp
js/src/jsapi-tests/testSavedStacks.cpp
js/src/jsapi-tests/testScriptObject.cpp
js/src/jsapi-tests/testXDR.cpp
js/src/jsapi.cpp
js/src/jsapi.h
js/src/jsfriendapi.h
js/src/proxy/BaseProxyHandler.cpp
js/src/proxy/CrossCompartmentWrapper.cpp
js/src/proxy/OpaqueCrossCompartmentWrapper.cpp
js/src/proxy/Proxy.cpp
js/src/proxy/Proxy.h
js/src/proxy/Wrapper.cpp
js/src/util/StringBuffer.h
js/src/vm/EnvironmentObject.h
js/src/vm/ForOfIterator.cpp
js/src/vm/Interpreter.h
js/src/vm/Iteration.cpp
js/src/vm/JSContext-inl.h
js/src/vm/JSContext.cpp
js/src/vm/StructuredClone.cpp
js/src/wasm/WasmJS.cpp
js/xpconnect/public/xpc_make_class.h
js/xpconnect/src/Sandbox.cpp
js/xpconnect/src/XPCComponents.cpp
js/xpconnect/src/XPCRuntimeService.cpp
js/xpconnect/src/XPCWrappedNativeJSOps.cpp
js/xpconnect/wrappers/FilteringWrapper.cpp
js/xpconnect/wrappers/XrayWrapper.cpp
layout/base/nsCounterManager.h
layout/generic/nsBlockFrame.cpp
layout/generic/nsGfxScrollFrame.cpp
layout/generic/nsImageFrame.cpp
layout/style/ServoStyleSet.h
layout/style/StyleColor.cpp
layout/style/nsStyleStruct.cpp
layout/xul/nsMenuPopupFrame.cpp
memory/build/mozjemalloc.cpp
netwerk/base/nsURLParsers.cpp
security/manager/ssl/SSLServerCertVerification.cpp
security/manager/ssl/nsKeygenHandler.cpp
testing/gtest/mozilla/GTestRunner.cpp
toolkit/components/startup/StartupTimeline.h
toolkit/components/url-classifier/Classifier.cpp
toolkit/components/url-classifier/tests/gtest/TestLookupCacheV4.cpp
toolkit/crashreporter/client/crashreporter_gtk_common.cpp
toolkit/library/gtest/static/TestUCRTDepends.cpp
toolkit/xre/nsAppRunner.cpp
widget/android/nsWindow.cpp
widget/cocoa/nsAppShell.mm
widget/cocoa/nsTouchBarUpdater.mm
widget/cocoa/nsWidgetFactory.mm
widget/gtk/WindowSurfaceWayland.cpp
widget/gtk/nsWaylandDisplay.cpp
widget/gtk/nsWaylandDisplay.h
xpcom/build/GeckoProcessTypes.h
xpcom/components/Module.h
--- a/accessible/atk/Platform.cpp
+++ b/accessible/atk/Platform.cpp
@@ -305,24 +305,25 @@ bool a11y::ShouldA11yBeEnabled() {
 dbus_done:
   if (reply) dbus_message_unref(reply);
 
   if (dbusSuccess) return sShouldEnable;
 #endif
 
 // check GSettings
 #define GSETINGS_A11Y_INTERFACE "org.gnome.desktop.interface"
-#define GSETINGS_A11Y_KEY       "toolkit-accessibility"
+#define GSETINGS_A11Y_KEY "toolkit-accessibility"
   nsCOMPtr<nsIGSettingsService> gsettings =
       do_GetService(NS_GSETTINGSSERVICE_CONTRACTID);
   nsCOMPtr<nsIGSettingsCollection> a11y_settings;
 
   if (gsettings) {
-    gsettings->GetCollectionForSchema(NS_LITERAL_CSTRING(GSETINGS_A11Y_INTERFACE),
-                                      getter_AddRefs(a11y_settings));
+    gsettings->GetCollectionForSchema(
+        NS_LITERAL_CSTRING(GSETINGS_A11Y_INTERFACE),
+        getter_AddRefs(a11y_settings));
     if (a11y_settings) {
       a11y_settings->GetBoolean(NS_LITERAL_CSTRING(GSETINGS_A11Y_KEY),
                                 &sShouldEnable);
     }
   }
 
   return sShouldEnable;
 }
--- a/browser/app/winlauncher/LauncherProcessWin.cpp
+++ b/browser/app/winlauncher/LauncherProcessWin.cpp
@@ -175,20 +175,20 @@ static mozilla::Maybe<bool> RunAsLaunche
     return mozilla::Nothing();
   }
 
   runAsLauncher = runAsType.unwrap() ==
                   mozilla::LauncherRegistryInfo::ProcessType::Launcher;
 #endif  // defined(MOZ_LAUNCHER_PROCESS)
 
   // We must check for force-launcher *after* we do LauncherRegistryInfo checks
-  runAsLauncher |= mozilla::CheckArg(argc, argv, L"force-launcher",
-                                     static_cast<const wchar_t**>(nullptr),
-                                     mozilla::CheckArgFlag::RemoveArg) ==
-                   mozilla::ARG_FOUND;
+  runAsLauncher |=
+      mozilla::CheckArg(argc, argv, L"force-launcher",
+                        static_cast<const wchar_t**>(nullptr),
+                        mozilla::CheckArgFlag::RemoveArg) == mozilla::ARG_FOUND;
 
   if (!runAsLauncher) {
     // In this case, we will be proceeding to run as the browser.
     // We should check MOZ_DEBUG_BROWSER_* env vars.
     MaybeBreakForBrowserDebugging();
   }
 
   return mozilla::Some(runAsLauncher);
--- a/docshell/shistory/nsSHistory.cpp
+++ b/docshell/shistory/nsSHistory.cpp
@@ -593,19 +593,17 @@ nsSHistory::AddEntry(nsISHEntry* aSHEntr
   if (gHistoryMaxSize >= 0 && Length() > gHistoryMaxSize) {
     PurgeHistory(Length() - gHistoryMaxSize);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP_(void)
-nsSHistory::ClearRootDocShell() {
-  mRootDocShell = nullptr;
-}
+nsSHistory::ClearRootDocShell() { mRootDocShell = nullptr; }
 
 /* Get size of the history list */
 NS_IMETHODIMP
 nsSHistory::GetCount(int32_t* aResult) {
   MOZ_ASSERT(aResult, "null out param?");
   *aResult = Length();
   return NS_OK;
 }
--- a/dom/base/ImageEncoder.cpp
+++ b/dom/base/ImageEncoder.cpp
@@ -282,19 +282,19 @@ nsresult ImageEncoder::ExtractDataAsync(
 }
 
 /*static*/
 nsresult ImageEncoder::GetInputStream(int32_t aWidth, int32_t aHeight,
                                       uint8_t* aImageBuffer, int32_t aFormat,
                                       imgIEncoder* aEncoder,
                                       const nsAString& aEncoderOptions,
                                       nsIInputStream** aStream) {
-  nsresult rv = aEncoder->InitFromData(aImageBuffer, aWidth * aHeight * 4,
-                                       aWidth, aHeight, aWidth * 4, aFormat,
-                                       aEncoderOptions);
+  nsresult rv =
+      aEncoder->InitFromData(aImageBuffer, aWidth * aHeight * 4, aWidth,
+                             aHeight, aWidth * 4, aFormat, aEncoderOptions);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<imgIEncoder> encoder(aEncoder);
   encoder.forget(aStream);
   return NS_OK;
 }
 
 /* static */
@@ -312,19 +312,19 @@ nsresult ImageEncoder::ExtractDataIntern
 
   // get image bytes
   nsresult rv;
   if (aImageBuffer && !aUsePlaceholder) {
     if (BufferSizeFromDimensions(aSize.width, aSize.height, 4) == 0) {
       return NS_ERROR_INVALID_ARG;
     }
 
-    rv = ImageEncoder::GetInputStream(
-        aSize.width, aSize.height, aImageBuffer, aFormat, aEncoder,
-        aOptions, getter_AddRefs(imgStream));
+    rv = ImageEncoder::GetInputStream(aSize.width, aSize.height, aImageBuffer,
+                                      aFormat, aEncoder, aOptions,
+                                      getter_AddRefs(imgStream));
   } else if (aContext && !aUsePlaceholder) {
     NS_ConvertUTF16toUTF8 encoderType(aType);
     rv = aContext->GetInputStream(encoderType.get(), aOptions,
                                   getter_AddRefs(imgStream));
   } else if (aRenderer && !aUsePlaceholder) {
     NS_ConvertUTF16toUTF8 encoderType(aType);
     rv = aRenderer->GetInputStream(encoderType.get(), aOptions,
                                    getter_AddRefs(imgStream));
--- a/dom/base/MaybeCrossOriginObject.cpp
+++ b/dom/base/MaybeCrossOriginObject.cpp
@@ -430,19 +430,19 @@ bool MaybeCrossOriginObject<Base>::defin
   }
 
   JS_MarkCrossZoneId(cx, id);
 
   return definePropertySameOrigin(cx, proxy, id, descCopy, result);
 }
 
 template <typename Base>
-bool MaybeCrossOriginObject<Base>::enumerate(JSContext* cx,
-                                             JS::Handle<JSObject*> proxy,
-                                             JS::MutableHandleVector<jsid> props) const {
+bool MaybeCrossOriginObject<Base>::enumerate(
+    JSContext* cx, JS::Handle<JSObject*> proxy,
+    JS::MutableHandleVector<jsid> props) const {
   // Just get the property keys from ourselves, in whatever Realm we happen to
   // be in. It's important to not enter the Realm of "proxy" here, because that
   // would affect the list of keys we claim to have. We wrap the proxy in the
   // current compartment just to be safe; it doesn't affect behavior as far as
   // CrossOriginObjectWrapper and MaybeCrossOriginObject are concerned.
   JS::Rooted<JSObject*> self(cx, proxy);
   if (!MaybeWrapObject(cx, &self)) {
     return false;
--- a/dom/base/RemoteOuterWindowProxy.cpp
+++ b/dom/base/RemoteOuterWindowProxy.cpp
@@ -40,18 +40,19 @@ class RemoteOuterWindowProxy
   // Standard internal methods
   bool getOwnPropertyDescriptor(
       JSContext* aCx, JS::Handle<JSObject*> aProxy, JS::Handle<jsid> aId,
       JS::MutableHandle<JS::PropertyDescriptor> aDesc) const final;
   bool ownPropertyKeys(JSContext* aCx, JS::Handle<JSObject*> aProxy,
                        JS::MutableHandleVector<jsid> aProps) const final;
 
   // SpiderMonkey extensions
-  bool getOwnEnumerablePropertyKeys(JSContext* cx, JS::Handle<JSObject*> proxy,
-                                    JS::MutableHandleVector<jsid> props) const final;
+  bool getOwnEnumerablePropertyKeys(
+      JSContext* cx, JS::Handle<JSObject*> proxy,
+      JS::MutableHandleVector<jsid> props) const final;
 
   void NoteChildren(JSObject* aProxy,
                     nsCycleCollectionTraversalCallback& aCb) const override {
     CycleCollectionNoteChild(aCb,
                              static_cast<BrowsingContext*>(GetNative(aProxy)),
                              "js::GetObjectPrivate(obj)");
   }
 };
@@ -135,19 +136,19 @@ bool AppendIndexedPropertyNames(JSContex
   }
 
   for (int32_t i = 0; i < length; ++i) {
     aIndexedProps.infallibleAppend(INT_TO_JSID(i));
   }
   return true;
 }
 
-bool RemoteOuterWindowProxy::ownPropertyKeys(JSContext* aCx,
-                                             JS::Handle<JSObject*> aProxy,
-                                             JS::MutableHandleVector<jsid> aProps) const {
+bool RemoteOuterWindowProxy::ownPropertyKeys(
+    JSContext* aCx, JS::Handle<JSObject*> aProxy,
+    JS::MutableHandleVector<jsid> aProps) const {
   BrowsingContext* bc = GetBrowsingContext(aProxy);
 
   // https://html.spec.whatwg.org/multipage/window-object.html#windowproxy-ownpropertykeys:crossoriginownpropertykeys-(-o-)
   // step 3 to 5
   if (!AppendIndexedPropertyNames(aCx, bc, aProps)) {
     return false;
   }
 
--- a/dom/base/WindowNamedPropertiesHandler.h
+++ b/dom/base/WindowNamedPropertiesHandler.h
@@ -19,19 +19,19 @@ class WindowNamedPropertiesHandler : pub
   virtual bool getOwnPropDescriptor(
       JSContext* aCx, JS::Handle<JSObject*> aProxy, JS::Handle<jsid> aId,
       bool /* unused */,
       JS::MutableHandle<JS::PropertyDescriptor> aDesc) const override;
   virtual bool defineProperty(JSContext* aCx, JS::Handle<JSObject*> aProxy,
                               JS::Handle<jsid> aId,
                               JS::Handle<JS::PropertyDescriptor> aDesc,
                               JS::ObjectOpResult& result) const override;
-  virtual bool ownPropNames(JSContext* aCx, JS::Handle<JSObject*> aProxy,
-                            unsigned flags,
-                            JS::MutableHandleVector<jsid> aProps) const override;
+  virtual bool ownPropNames(
+      JSContext* aCx, JS::Handle<JSObject*> aProxy, unsigned flags,
+      JS::MutableHandleVector<jsid> aProps) const override;
   virtual bool delete_(JSContext* aCx, JS::Handle<JSObject*> aProxy,
                        JS::Handle<jsid> aId,
                        JS::ObjectOpResult& aResult) const override;
 
   // No need for getPrototypeIfOrdinary here: window named-properties objects
   // have static prototypes, so the version inherited from BaseDOMProxyHandler
   // will do the right thing.
 
--- a/dom/base/nsJSEnvironment.cpp
+++ b/dom/base/nsJSEnvironment.cpp
@@ -494,18 +494,18 @@ bool ScriptErrorEvent::sHandlingScriptEr
 // soon.
 namespace xpc {
 
 void DispatchScriptErrorEvent(nsPIDOMWindowInner* win,
                               JS::RootingContext* rootingCx,
                               xpc::ErrorReport* xpcReport,
                               JS::Handle<JS::Value> exception,
                               JS::Handle<JSObject*> exceptionStack) {
-  nsContentUtils::AddScriptRunner(
-      new ScriptErrorEvent(win, rootingCx, xpcReport, exception, exceptionStack));
+  nsContentUtils::AddScriptRunner(new ScriptErrorEvent(
+      win, rootingCx, xpcReport, exception, exceptionStack));
 }
 
 } /* namespace xpc */
 
 #ifdef DEBUG
 // A couple of useful functions to call when you're debugging.
 nsGlobalWindowInner* JSObject2Win(JSObject* obj) {
   return xpc::WindowOrNull(obj);
--- a/dom/base/nsObjectLoadingContent.cpp
+++ b/dom/base/nsObjectLoadingContent.cpp
@@ -3503,20 +3503,19 @@ bool nsObjectLoadingContent::DoResolve(
 }
 
 /* static */
 bool nsObjectLoadingContent::MayResolve(jsid aId) {
   // We can resolve anything, really.
   return true;
 }
 
-void nsObjectLoadingContent::GetOwnPropertyNames(JSContext* aCx,
-                                                 JS::MutableHandleVector<jsid> /* unused */,
-                                                 bool /* unused */,
-                                                 ErrorResult& aRv) {
+void nsObjectLoadingContent::GetOwnPropertyNames(
+    JSContext* aCx, JS::MutableHandleVector<jsid> /* unused */,
+    bool /* unused */, ErrorResult& aRv) {
   // Just like DoResolve, just make sure we're instantiated.  That will do
   // the work our Enumerate hook needs to do.  This purposefully does not fire
   // for xray resolves, see bug 967694
   Unused << ScriptRequestPluginInstance(aCx);
 }
 
 void nsObjectLoadingContent::MaybeFireErrorEvent() {
   nsCOMPtr<nsIContent> thisContent =
--- a/dom/base/nsObjectLoadingContent.h
+++ b/dom/base/nsObjectLoadingContent.h
@@ -184,17 +184,18 @@ class nsObjectLoadingContent : public ns
   bool DoResolve(JSContext* aCx, JS::Handle<JSObject*> aObject,
                  JS::Handle<jsid> aId,
                  JS::MutableHandle<JS::PropertyDescriptor> aDesc);
   // The return value is whether DoResolve might end up resolving the given
   // id.  If in doubt, return true.
   static bool MayResolve(jsid aId);
 
   // Helper for WebIDL enumeration
-  void GetOwnPropertyNames(JSContext* aCx, JS::MutableHandleVector<jsid> /* unused */,
+  void GetOwnPropertyNames(JSContext* aCx,
+                           JS::MutableHandleVector<jsid> /* unused */,
                            bool /* unused */, mozilla::ErrorResult& aRv);
 
   // WebIDL API
   mozilla::dom::Document* GetContentDocument(nsIPrincipal& aSubjectPrincipal);
   void GetActualType(nsAString& aType) const {
     CopyUTF8toUTF16(mContentType, aType);
   }
   uint32_t DisplayedType() const { return mType; }
--- a/dom/bindings/BindingUtils.cpp
+++ b/dom/bindings/BindingUtils.cpp
@@ -1865,17 +1865,18 @@ bool XrayAppendPropertyKeys<ConstantSpec
                                 nativeProperties->FieldName##PropertyInfos(), \
                                 flags, props)) {                              \
       return false;                                                           \
     }                                                                         \
   }
 
 bool XrayOwnPropertyKeys(JSContext* cx, JS::Handle<JSObject*> wrapper,
                          JS::Handle<JSObject*> obj, unsigned flags,
-                         JS::MutableHandleVector<jsid> props, DOMObjectType type,
+                         JS::MutableHandleVector<jsid> props,
+                         DOMObjectType type,
                          const NativeProperties* nativeProperties) {
   MOZ_ASSERT(type != eNamedPropertiesObject);
 
   if (IsInstance(type)) {
     ADD_KEYS_IF_DEFINED(UnforgeableMethod);
     ADD_KEYS_IF_DEFINED(UnforgeableAttribute);
     if (type == eGlobalInstance) {
       ADD_KEYS_IF_DEFINED(Method);
@@ -1897,17 +1898,18 @@ bool XrayOwnPropertyKeys(JSContext* cx, 
   return true;
 }
 
 #undef ADD_KEYS_IF_DEFINED
 
 bool XrayOwnNativePropertyKeys(JSContext* cx, JS::Handle<JSObject*> wrapper,
                                const NativePropertyHooks* nativePropertyHooks,
                                DOMObjectType type, JS::Handle<JSObject*> obj,
-                               unsigned flags, JS::MutableHandleVector<jsid> props) {
+                               unsigned flags,
+                               JS::MutableHandleVector<jsid> props) {
   MOZ_ASSERT(type != eNamedPropertiesObject);
 
   if (type == eInterface &&
       nativePropertyHooks->mPrototypeID != prototypes::id::_ID_Count &&
       !AddStringToIDVector(cx, props, "prototype")) {
     return false;
   }
 
@@ -2734,17 +2736,18 @@ bool ResolveGlobal(JSContext* aCx, JS::H
 }
 
 bool MayResolveGlobal(const JSAtomState& aNames, jsid aId,
                       JSObject* aMaybeObj) {
   return JS_MayResolveStandardClass(aNames, aId, aMaybeObj);
 }
 
 bool EnumerateGlobal(JSContext* aCx, JS::HandleObject aObj,
-                     JS::MutableHandleVector<jsid> aProperties, bool aEnumerableOnly) {
+                     JS::MutableHandleVector<jsid> aProperties,
+                     bool aEnumerableOnly) {
   MOZ_ASSERT(JS_IsGlobalObject(aObj),
              "Should have a global here, since we plan to enumerate standard "
              "classes!");
 
   return JS_NewEnumerateStandardClasses(aCx, aObj, aProperties,
                                         aEnumerableOnly);
 }
 
--- a/dom/bindings/BindingUtils.h
+++ b/dom/bindings/BindingUtils.h
@@ -2187,17 +2187,18 @@ class MOZ_STACK_CLASS NullableRootedUnio
   }
 };
 
 inline bool IdEquals(jsid id, const char* string) {
   return JSID_IS_STRING(id) &&
          JS_FlatStringEqualsAscii(JSID_TO_FLAT_STRING(id), string);
 }
 
-inline bool AddStringToIDVector(JSContext* cx, JS::MutableHandleVector<jsid> vector,
+inline bool AddStringToIDVector(JSContext* cx,
+                                JS::MutableHandleVector<jsid> vector,
                                 const char* name) {
   return vector.growBy(1) &&
          AtomizeAndPinJSString(cx, *(vector[vector.length() - 1]).address(),
                                name);
 }
 
 // We use one constructor JSNative to represent all DOM interface objects (so
 // we can easily detect when we need to wrap them in an Xray wrapper). We store
@@ -2773,17 +2774,18 @@ class GetCCParticipant<T, true> {
 void FinalizeGlobal(JSFreeOp* aFop, JSObject* aObj);
 
 bool ResolveGlobal(JSContext* aCx, JS::Handle<JSObject*> aObj,
                    JS::Handle<jsid> aId, bool* aResolvedp);
 
 bool MayResolveGlobal(const JSAtomState& aNames, jsid aId, JSObject* aMaybeObj);
 
 bool EnumerateGlobal(JSContext* aCx, JS::HandleObject aObj,
-                     JS::MutableHandleVector<jsid> aProperties, bool aEnumerableOnly);
+                     JS::MutableHandleVector<jsid> aProperties,
+                     bool aEnumerableOnly);
 
 struct CreateGlobalOptionsGeneric {
   static void TraceGlobal(JSTracer* aTrc, JSObject* aObj) {
     mozilla::dom::TraceProtoAndIfaceCache(aTrc, aObj);
   }
   static bool PostCreateGlobal(JSContext* aCx, JS::Handle<JSObject*> aGlobal) {
     MOZ_ALWAYS_TRUE(TryPreserveWrapper(aGlobal));
 
--- a/dom/bindings/DOMJSProxyHandler.cpp
+++ b/dom/bindings/DOMJSProxyHandler.cpp
@@ -248,33 +248,34 @@ bool DOMProxyHandler::delete_(JSContext*
   if (!xpc::WrapperFactory::IsXrayWrapper(proxy) &&
       (expando = GetExpandoObject(proxy))) {
     return JS_DeletePropertyById(cx, expando, id, result);
   }
 
   return result.succeed();
 }
 
-bool BaseDOMProxyHandler::ownPropertyKeys(JSContext* cx,
-                                          JS::Handle<JSObject*> proxy,
-                                          JS::MutableHandleVector<jsid> props) const {
+bool BaseDOMProxyHandler::ownPropertyKeys(
+    JSContext* cx, JS::Handle<JSObject*> proxy,
+    JS::MutableHandleVector<jsid> props) const {
   return ownPropNames(cx, proxy,
                       JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS, props);
 }
 
 bool BaseDOMProxyHandler::getPrototypeIfOrdinary(
     JSContext* cx, JS::Handle<JSObject*> proxy, bool* isOrdinary,
     JS::MutableHandle<JSObject*> proto) const {
   *isOrdinary = true;
   proto.set(GetStaticPrototype(proxy));
   return true;
 }
 
 bool BaseDOMProxyHandler::getOwnEnumerablePropertyKeys(
-    JSContext* cx, JS::Handle<JSObject*> proxy, JS::MutableHandleVector<jsid> props) const {
+    JSContext* cx, JS::Handle<JSObject*> proxy,
+    JS::MutableHandleVector<jsid> props) const {
   return ownPropNames(cx, proxy, JSITER_OWNONLY, props);
 }
 
 bool DOMProxyHandler::setCustom(JSContext* cx, JS::Handle<JSObject*> proxy,
                                 JS::Handle<jsid> id, JS::Handle<JS::Value> v,
                                 bool* done) const {
   *done = false;
   return true;
--- a/dom/bindings/DOMJSProxyHandler.h
+++ b/dom/bindings/DOMJSProxyHandler.h
@@ -47,18 +47,19 @@ class BaseDOMProxyHandler : public js::B
                                          bool aHasPrototype = false)
       : js::BaseProxyHandler(aProxyFamily, aHasPrototype) {}
 
   // Implementations of methods that can be implemented in terms of
   // other lower-level methods.
   bool getOwnPropertyDescriptor(
       JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
       JS::MutableHandle<JS::PropertyDescriptor> desc) const override;
-  virtual bool ownPropertyKeys(JSContext* cx, JS::Handle<JSObject*> proxy,
-                               JS::MutableHandleVector<jsid> props) const override;
+  virtual bool ownPropertyKeys(
+      JSContext* cx, JS::Handle<JSObject*> proxy,
+      JS::MutableHandleVector<jsid> props) const override;
 
   virtual bool getPrototypeIfOrdinary(
       JSContext* cx, JS::Handle<JSObject*> proxy, bool* isOrdinary,
       JS::MutableHandle<JSObject*> proto) const override;
 
   // We override getOwnEnumerablePropertyKeys() and implement it directly
   // instead of using the default implementation, which would call
   // ownPropertyKeys and then filter out the non-enumerable ones. This avoids
@@ -68,17 +69,18 @@ class BaseDOMProxyHandler : public js::B
       JS::MutableHandleVector<jsid> props) const override;
 
  protected:
   // Hook for subclasses to implement shared ownPropertyKeys()/keys()
   // functionality.  The "flags" argument is either JSITER_OWNONLY (for keys())
   // or JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS (for
   // ownPropertyKeys()).
   virtual bool ownPropNames(JSContext* cx, JS::Handle<JSObject*> proxy,
-                            unsigned flags, JS::MutableHandleVector<jsid> props) const = 0;
+                            unsigned flags,
+                            JS::MutableHandleVector<jsid> props) const = 0;
 
   // Hook for subclasses to allow set() to ignore named props while other things
   // that look at property descriptors see them.  This is intentionally not
   // named getOwnPropertyDescriptor to avoid subclasses that override it hiding
   // our public getOwnPropertyDescriptor.
   virtual bool getOwnPropDescriptor(
       JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
       bool ignoreNamedProps,
--- a/dom/bindings/RemoteObjectProxy.cpp
+++ b/dom/bindings/RemoteObjectProxy.cpp
@@ -28,19 +28,19 @@ bool RemoteObjectProxyBase::defineProper
     JS::ObjectOpResult& aResult) const {
   // https://html.spec.whatwg.org/multipage/browsers.html#windowproxy-defineownproperty
   // step 3 and
   // https://html.spec.whatwg.org/multipage/browsers.html#location-defineownproperty
   // step 2
   return ReportCrossOriginDenial(aCx, aId, NS_LITERAL_CSTRING("define"));
 }
 
-bool RemoteObjectProxyBase::ownPropertyKeys(JSContext* aCx,
-                                            JS::Handle<JSObject*> aProxy,
-                                            JS::MutableHandleVector<jsid> aProps) const {
+bool RemoteObjectProxyBase::ownPropertyKeys(
+    JSContext* aCx, JS::Handle<JSObject*> aProxy,
+    JS::MutableHandleVector<jsid> aProps) const {
   // https://html.spec.whatwg.org/multipage/browsers.html#crossoriginownpropertykeys-(-o-)
   // step 2 and
   // https://html.spec.whatwg.org/multipage/browsers.html#crossoriginproperties-(-o-)
   JS::Rooted<JSObject*> holder(aCx);
   if (!EnsureHolder(aCx, aProxy, &holder) ||
       !js::GetPropertyKeys(aCx, holder,
                            JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS,
                            aProps)) {
--- a/dom/bindings/RemoteObjectProxy.h
+++ b/dom/bindings/RemoteObjectProxy.h
@@ -62,19 +62,19 @@ class RemoteObjectProxyBase : public js:
            JS::MutableHandle<JS::Value> aVp) const final;
   bool set(JSContext* cx, JS::Handle<JSObject*> aProxy, JS::Handle<jsid> aId,
            JS::Handle<JS::Value> aValue, JS::Handle<JS::Value> aReceiver,
            JS::ObjectOpResult& aResult) const final;
 
   // SpiderMonkey extensions
   bool hasOwn(JSContext* aCx, JS::Handle<JSObject*> aProxy,
               JS::Handle<jsid> aId, bool* aBp) const override;
-  bool getOwnEnumerablePropertyKeys(JSContext* aCx,
-                                    JS::Handle<JSObject*> aProxy,
-                                    JS::MutableHandleVector<jsid> aProps) const override;
+  bool getOwnEnumerablePropertyKeys(
+      JSContext* aCx, JS::Handle<JSObject*> aProxy,
+      JS::MutableHandleVector<jsid> aProps) const override;
   const char* className(JSContext* aCx,
                         JS::Handle<JSObject*> aProxy) const final;
 
   bool isCallable(JSObject* aObj) const final { return false; }
   bool isConstructor(JSObject* aObj) const final { return false; }
 
   virtual void NoteChildren(JSObject* aProxy,
                             nsCycleCollectionTraversalCallback& aCb) const = 0;
--- a/dom/bindings/WebIDLGlobalNameHash.cpp
+++ b/dom/bindings/WebIDLGlobalNameHash.cpp
@@ -238,18 +238,18 @@ bool WebIDLGlobalNameHash::ResolveForSys
 
     *aResolvedp = true;
   }
   return true;
 }
 
 /* static */
 bool WebIDLGlobalNameHash::NewEnumerateSystemGlobal(
-    JSContext* aCx, JS::Handle<JSObject*> aObj, JS::MutableHandleVector<jsid> aProperties,
-    bool aEnumerableOnly) {
+    JSContext* aCx, JS::Handle<JSObject*> aObj,
+    JS::MutableHandleVector<jsid> aProperties, bool aEnumerableOnly) {
   MOZ_ASSERT(JS_IsGlobalObject(aObj));
 
   if (!JS_NewEnumerateStandardClasses(aCx, aObj, aProperties,
                                       aEnumerableOnly)) {
     return false;
   }
 
   // All properties defined on our global are non-enumerable, so we can skip
--- a/dom/bindings/WebIDLGlobalNameHash.h
+++ b/dom/bindings/WebIDLGlobalNameHash.h
@@ -54,28 +54,28 @@ class WebIDLGlobalNameHash {
     // All WebIDL names enabled for aObj.
     AllNames,
     // Only the names that are enabled for aObj and have not been resolved for
     // aObj in the past (and therefore can't have been deleted).
     UnresolvedNamesOnly
   };
   // Returns false if an exception has been thrown on aCx.
   static bool GetNames(JSContext* aCx, JS::Handle<JSObject*> aObj,
-                       NameType aNameType, JS::MutableHandleVector<jsid> aNames);
+                       NameType aNameType,
+                       JS::MutableHandleVector<jsid> aNames);
 
   // Helpers for resolving & enumerating names on the system global.
   // NOTE: These are distinct as it currently lacks a ProtoAndIfaceCache, and is
   // an XPCOM global.
   static bool ResolveForSystemGlobal(JSContext* aCx, JS::Handle<JSObject*> aObj,
                                      JS::Handle<jsid> aId, bool* aResolvedp);
 
-  static bool NewEnumerateSystemGlobal(JSContext* aCx,
-                                       JS::Handle<JSObject*> aObj,
-                                       JS::MutableHandleVector<jsid> aProperties,
-                                       bool aEnumerableOnly);
+  static bool NewEnumerateSystemGlobal(
+      JSContext* aCx, JS::Handle<JSObject*> aObj,
+      JS::MutableHandleVector<jsid> aProperties, bool aEnumerableOnly);
 
  private:
   friend struct WebIDLNameTableEntry;
 
   // Look up an entry by key name. `nullptr` if the entry was not found.
   // The impl of GetEntry is generated by Codegen.py in RegisterBindings.cpp
   static const WebIDLNameTableEntry* GetEntry(JSFlatString* aKey);
 
--- a/dom/gamepad/GamepadRemapping.cpp
+++ b/dom/gamepad/GamepadRemapping.cpp
@@ -72,56 +72,52 @@ void FetchDpadFromAxis(uint32_t aIndex, 
 
   service->NewButtonEvent(aIndex, BUTTON_INDEX_DPAD_UP, up);
   service->NewButtonEvent(aIndex, BUTTON_INDEX_DPAD_RIGHT, right);
   service->NewButtonEvent(aIndex, BUTTON_INDEX_DPAD_DOWN, down);
   service->NewButtonEvent(aIndex, BUTTON_INDEX_DPAD_LEFT, left);
 }
 
 class DefaultRemapper final : public GamepadRemapper {
-  public:
-    virtual uint32_t GetAxisCount() const override {
-      return numAxes;
-    }
+ public:
+  virtual uint32_t GetAxisCount() const override { return numAxes; }
 
-    virtual uint32_t GetButtonCount() const override {
-      return numButtons;
-    }
+  virtual uint32_t GetButtonCount() const override { return numButtons; }
 
-    virtual void SetAxisCount(uint32_t aAxisCount) override {
-      numAxes = aAxisCount;
-    }
+  virtual void SetAxisCount(uint32_t aAxisCount) override {
+    numAxes = aAxisCount;
+  }
 
-    virtual void SetButtonCount(uint32_t aButtonCount) override {
-      numButtons = aButtonCount;
-    }
+  virtual void SetButtonCount(uint32_t aButtonCount) override {
+    numButtons = aButtonCount;
+  }
 
-    virtual void RemapAxisMoveEvent(uint32_t aIndex, uint32_t aAxis,
+  virtual void RemapAxisMoveEvent(uint32_t aIndex, uint32_t aAxis,
                                   double aValue) const override {
-      RefPtr<GamepadPlatformService> service =
-          GamepadPlatformService::GetParentService();
-      if (!service) {
-        return;
-      }                             
-      service->NewAxisMoveEvent(aIndex, aAxis, aValue);
+    RefPtr<GamepadPlatformService> service =
+        GamepadPlatformService::GetParentService();
+    if (!service) {
+      return;
     }
+    service->NewAxisMoveEvent(aIndex, aAxis, aValue);
+  }
 
-    virtual void RemapButtonEvent(uint32_t aIndex, uint32_t aButton,
-                                  bool aPressed) const override {
-      RefPtr<GamepadPlatformService> service =
-          GamepadPlatformService::GetParentService();
-      if (!service) {
-        return;
-      }
-      service->NewButtonEvent(aIndex, aButton, aPressed);
+  virtual void RemapButtonEvent(uint32_t aIndex, uint32_t aButton,
+                                bool aPressed) const override {
+    RefPtr<GamepadPlatformService> service =
+        GamepadPlatformService::GetParentService();
+    if (!service) {
+      return;
     }
+    service->NewButtonEvent(aIndex, aButton, aPressed);
+  }
 
-  private:
-    uint32_t numAxes;
-    uint32_t numButtons;
+ private:
+  uint32_t numAxes;
+  uint32_t numButtons;
 };
 
 class Dualshock4Remapper final : public GamepadRemapper {
  public:
   virtual uint32_t GetAxisCount() const override { return AXIS_INDEX_COUNT; }
 
   virtual uint32_t GetButtonCount() const override {
     return DUALSHOCK_BUTTON_COUNT;
@@ -175,59 +171,55 @@ class Dualshock4Remapper final : public 
   virtual void RemapButtonEvent(uint32_t aIndex, uint32_t aButton,
                                 bool aPressed) const override {
     RefPtr<GamepadPlatformService> service =
         GamepadPlatformService::GetParentService();
     if (!service) {
       return;
     }
 
-    const std::vector<uint32_t> buttonMapping = {
-      BUTTON_INDEX_TERTIARY,
-      BUTTON_INDEX_PRIMARY,
-      BUTTON_INDEX_SECONDARY,
-      BUTTON_INDEX_QUATERNARY,
-      BUTTON_INDEX_LEFT_SHOULDER,
-      BUTTON_INDEX_RIGHT_SHOULDER,
-      BUTTON_INDEX_LEFT_TRIGGER,
-      BUTTON_INDEX_RIGHT_TRIGGER,
-      BUTTON_INDEX_BACK_SELECT,
-      BUTTON_INDEX_START,
-      BUTTON_INDEX_LEFT_THUMBSTICK,
-      BUTTON_INDEX_RIGHT_THUMBSTICK,
-      BUTTON_INDEX_META,
-      DUALSHOCK_BUTTON_TOUCHPAD
-    };
+    const std::vector<uint32_t> buttonMapping = {BUTTON_INDEX_TERTIARY,
+                                                 BUTTON_INDEX_PRIMARY,
+                                                 BUTTON_INDEX_SECONDARY,
+                                                 BUTTON_INDEX_QUATERNARY,
+                                                 BUTTON_INDEX_LEFT_SHOULDER,
+                                                 BUTTON_INDEX_RIGHT_SHOULDER,
+                                                 BUTTON_INDEX_LEFT_TRIGGER,
+                                                 BUTTON_INDEX_RIGHT_TRIGGER,
+                                                 BUTTON_INDEX_BACK_SELECT,
+                                                 BUTTON_INDEX_START,
+                                                 BUTTON_INDEX_LEFT_THUMBSTICK,
+                                                 BUTTON_INDEX_RIGHT_THUMBSTICK,
+                                                 BUTTON_INDEX_META,
+                                                 DUALSHOCK_BUTTON_TOUCHPAD};
 
     if (buttonMapping.size() <= aIndex) {
-      NS_WARNING(
-            nsPrintfCString(
-                "Button idx '%d' doesn't support in Dualshock4Remapper().",
-                aButton)
-                .get());
+      NS_WARNING(nsPrintfCString(
+                     "Button idx '%d' doesn't support in Dualshock4Remapper().",
+                     aButton)
+                     .get());
       return;
     }
 
     service->NewButtonEvent(aIndex, buttonMapping[aButton], aPressed);
   }
 
  private:
   enum Dualshock4Buttons {
     DUALSHOCK_BUTTON_TOUCHPAD = BUTTON_INDEX_COUNT,
     DUALSHOCK_BUTTON_COUNT
   };
 };
 
-already_AddRefed<GamepadRemapper> GetGamepadRemapper(const uint16_t aVendorId,
-                                                     const uint16_t aProductId) {
+already_AddRefed<GamepadRemapper> GetGamepadRemapper(
+    const uint16_t aVendorId, const uint16_t aProductId) {
   const std::vector<GamepadRemappingData> remappingRules = {
       {GamepadId::kSonyDualshock4, new Dualshock4Remapper()},
       {GamepadId::kSonyDualshock4Slim, new Dualshock4Remapper()},
-      {GamepadId::kSonyDualshock4USBReceiver, new Dualshock4Remapper()}
-  };
+      {GamepadId::kSonyDualshock4USBReceiver, new Dualshock4Remapper()}};
   const GamepadId id = static_cast<GamepadId>((aVendorId << 16) | aProductId);
 
   for (uint32_t i = 0; i < remappingRules.size(); ++i) {
     if (id == remappingRules[i].id) {
       return do_AddRef(remappingRules[i].remapping.get());
     }
   }
 
--- a/dom/gamepad/GamepadRemapping.h
+++ b/dom/gamepad/GamepadRemapping.h
@@ -27,17 +27,17 @@ class GamepadRemapper {
   virtual void SetButtonCount(uint32_t aButtonCount) {}
   virtual GamepadMappingType GetMappingType() const {
     return GamepadMappingType::Standard;
   }
   virtual void RemapAxisMoveEvent(uint32_t aIndex, uint32_t aAxis,
                                   double aValue) const = 0;
   virtual void RemapButtonEvent(uint32_t aIndex, uint32_t aButton,
                                 bool aPressed) const = 0;
-  
+
  protected:
   GamepadRemapper() = default;
   virtual ~GamepadRemapper() = default;
 };
 
 struct GamepadRemappingData {
   GamepadId id;
   RefPtr<GamepadRemapper> remapping;
--- a/dom/gamepad/windows/WindowsGamepad.cpp
+++ b/dom/gamepad/windows/WindowsGamepad.cpp
@@ -130,20 +130,17 @@ class Gamepad {
   nsTArray<axisValue> axes;
 
   RefPtr<GamepadRemapper> remapper;
 
   // Used during rescan to find devices that were disconnected.
   bool present;
 
   Gamepad(uint32_t aNumAxes, uint32_t aNumButtons, GamepadType aType)
-      : type(aType),
-        numAxes(aNumAxes),
-        numButtons(aNumButtons),
-        present(true) {
+      : type(aType), numAxes(aNumAxes), numButtons(aNumButtons), present(true) {
     buttons.SetLength(numButtons);
     axes.SetLength(numAxes);
   }
 
  private:
   Gamepad() {}
 };
 
@@ -426,17 +423,18 @@ bool WindowsGamepadService::ScanForXInpu
     }
     found = true;
     // See if this device is already present in our list.
     if (HaveXInputGamepad(i)) {
       continue;
     }
 
     // Not already present, add it.
-    Gamepad gamepad(kStandardGamepadAxes, kStandardGamepadButtons, kXInputGamepad);
+    Gamepad gamepad(kStandardGamepadAxes, kStandardGamepadButtons,
+                    kXInputGamepad);
     gamepad.userIndex = i;
     gamepad.state = state;
     gamepad.id = service->AddGamepad(
         "xinput", GamepadMappingType::Standard, GamepadHand::_empty,
         kStandardGamepadButtons, kStandardGamepadAxes,
         0);  // TODO: Bug 680289, implement gamepad haptics for Windows.
     mGamepads.AppendElement(gamepad);
   }
@@ -683,26 +681,28 @@ bool WindowsGamepadService::GetRawGamepa
   axisCaps.SetLength(count);
   if (mHID.mHidP_GetValueCaps(HidP_Input, axisCaps.Elements(), &count,
                               parsed) != HIDP_STATUS_SUCCESS) {
     return false;
   }
 
   size_t numAxes = 0;
   nsTArray<Gamepad::axisValue> axes(kAxesLengthCap);
-  // We store these value caps and handle the dpad info in GamepadRemapper later.
+  // We store these value caps and handle the dpad info in GamepadRemapper
+  // later.
   axes.SetLength(kAxesLengthCap);
 
   // Looking for the exisiting ramapping rule.
   RefPtr<GamepadRemapper> remapper =
       GetGamepadRemapper(rdi.hid.dwVendorId, rdi.hid.dwProductId);
   MOZ_ASSERT(remapper);
 
   for (size_t i = 0; i < count; i++) {
-    const size_t axisIndex = axisCaps[i].Range.UsageMin - kAxisMinimumUsageNumber;
+    const size_t axisIndex =
+        axisCaps[i].Range.UsageMin - kAxisMinimumUsageNumber;
     if (axisIndex < kAxesLengthCap && !axes[axisIndex].active) {
       axes[axisIndex].caps = axisCaps[i];
       axes[axisIndex].active = true;
       numAxes = std::max(numAxes, axisIndex + 1);
     }
   }
 
   // Not already present, add it.
@@ -712,20 +712,19 @@ bool WindowsGamepadService::GetRawGamepa
   Gamepad gamepad(numAxes, numButtons, kRawInputGamepad);
   gamepad.handle = handle;
 
   for (unsigned i = 0; i < gamepad.numAxes; i++) {
     gamepad.axes[i] = axes[i];
   }
 
   gamepad.remapper = remapper.forget();
-  gamepad.id =
-      service->AddGamepad(gamepad_id, gamepad.remapper->GetMappingType(),
-                          GamepadHand::_empty, gamepad.remapper->GetButtonCount(),
-                          gamepad.remapper->GetAxisCount(), 0);
+  gamepad.id = service->AddGamepad(
+      gamepad_id, gamepad.remapper->GetMappingType(), GamepadHand::_empty,
+      gamepad.remapper->GetButtonCount(), gamepad.remapper->GetAxisCount(), 0);
   mGamepads.AppendElement(gamepad);
   return true;
 }
 
 bool WindowsGamepadService::HandleRawInput(HRAWINPUT handle) {
   if (!mHID) {
     return false;
   }
--- a/dom/html/HTMLFormElement.cpp
+++ b/dom/html/HTMLFormElement.cpp
@@ -1617,18 +1617,17 @@ bool HTMLFormElement::ImplicitSubmission
 }
 
 bool HTMLFormElement::IsLastActiveElement(
     const nsIFormControl* aControl) const {
   MOZ_ASSERT(aControl, "Unexpected call");
 
   for (auto* element : Reversed(mControls->mElements)) {
     // XXX How about date/time control?
-    if (element->IsTextOrNumberControl(false) &&
-        !element->IsDisabled()) {
+    if (element->IsTextOrNumberControl(false) && !element->IsDisabled()) {
       return element == aControl;
     }
   }
   return false;
 }
 
 int32_t HTMLFormElement::Length() { return mControls->Length(); }
 
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -1458,17 +1458,18 @@ void TabChild::ProcessPendingCoalescedMo
   }
   // mCoalescedMouseEventFlusher may be destroyed when reentrying the event
   // loop.
   if (mCoalescedMouseEventFlusher) {
     mCoalescedMouseEventFlusher->RemoveObserver();
   }
 }
 
-LayoutDeviceToLayoutDeviceMatrix4x4 TabChild::GetChildToParentConversionMatrix() const {
+LayoutDeviceToLayoutDeviceMatrix4x4 TabChild::GetChildToParentConversionMatrix()
+    const {
   if (mChildToParentConversionMatrix) {
     return *mChildToParentConversionMatrix;
   }
   LayoutDevicePoint offset(GetChromeOffset());
   return LayoutDeviceToLayoutDeviceMatrix4x4::Translation(offset);
 }
 
 void TabChild::FlushAllCoalescedMouseData() {
--- a/dom/ipc/TabChild.h
+++ b/dom/ipc/TabChild.h
@@ -637,17 +637,18 @@ class TabChild final : public TabChildBa
   void AddPendingDocShellBlocker();
   void RemovePendingDocShellBlocker();
 
   // The HANDLE object for the widget this TabChild in.
   WindowsHandle WidgetNativeData() { return mWidgetNativeData; }
 
   // The transform from the coordinate space of this TabChild to the coordinate
   // space of the native window its TabParent is in.
-  mozilla::LayoutDeviceToLayoutDeviceMatrix4x4 GetChildToParentConversionMatrix() const;
+  mozilla::LayoutDeviceToLayoutDeviceMatrix4x4
+  GetChildToParentConversionMatrix() const;
 
   // Prepare to dispatch all coalesced mousemove events. We'll move all data
   // in mCoalescedMouseData to a nsDeque; then we start processing them. We
   // can't fetch the coalesced event one by one and dispatch it because we may
   // reentry the event loop and access to the same hashtable. It's called when
   // dispatching some mouse events other than mousemove.
   void FlushAllCoalescedMouseData();
   void ProcessPendingCoalescedMouseDataAndDispatchEvents();
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -1036,17 +1036,18 @@ bool TabParent::DeallocPWindowGlobalPare
   return true;
 }
 
 IPCResult TabParent::RecvPBrowserBridgeConstructor(
     PBrowserBridgeParent* aActor, const nsString& aName,
     const nsString& aRemoteType, BrowsingContext* aBrowsingContext,
     const uint32_t& aChromeFlags) {
   static_cast<BrowserBridgeParent*>(aActor)->Init(
-      aName, aRemoteType, CanonicalBrowsingContext::Cast(aBrowsingContext), aChromeFlags);
+      aName, aRemoteType, CanonicalBrowsingContext::Cast(aBrowsingContext),
+      aChromeFlags);
   return IPC_OK();
 }
 
 PBrowserBridgeParent* TabParent::AllocPBrowserBridgeParent(
     const nsString& aName, const nsString& aRemoteType,
     BrowsingContext* aBrowsingContext, const uint32_t& aChromeFlags) {
   // Reference freed in DeallocPBrowserBridgeParent.
   return do_AddRef(new BrowserBridgeParent()).take();
@@ -1355,19 +1356,20 @@ class SynthesizedEventObserver : public 
     if (!mTabParent || !mObserverId) {
       // We already sent the notification, or we don't actually need to
       // send any notification at all.
       return NS_OK;
     }
 
     if (mTabParent->IsDestroyed()) {
       // If this happens it's probably a bug in the test that's triggering this.
-      NS_WARNING("TabParent was unexpectedly destroyed during event synthesization!");
+      NS_WARNING(
+          "TabParent was unexpectedly destroyed during event synthesization!");
     } else if (!mTabParent->SendNativeSynthesisResponse(mObserverId,
-                                                 nsCString(aTopic))) {
+                                                        nsCString(aTopic))) {
       NS_WARNING("Unable to send native event synthesization response!");
     }
     // Null out tabparent to indicate we already sent the response
     mTabParent = nullptr;
     return NS_OK;
   }
 
  private:
--- a/dom/media/ipc/RDDProcessHost.h
+++ b/dom/media/ipc/RDDProcessHost.h
@@ -12,17 +12,17 @@
 #include "mozilla/UniquePtr.h"
 #include "mozilla/ipc/ProtocolUtils.h"
 #include "mozilla/ipc/TaskFactory.h"
 
 namespace mozilla {
 namespace ipc {
 class SharedPreferenceSerializer;
 }
-}
+}  // namespace mozilla
 class nsITimer;
 
 namespace mozilla {
 
 class RDDChild;
 
 // RDDProcessHost is the "parent process" container for a subprocess handle and
 // IPC connection. It owns the parent process IPDL actor, which in this case,
--- a/dom/media/webaudio/AudioContext.h
+++ b/dom/media/webaudio/AudioContext.h
@@ -244,18 +244,18 @@ class AudioContext final : public DOMEve
 
   already_AddRefed<WaveShaperNode> CreateWaveShaper(ErrorResult& aRv);
 
   already_AddRefed<MediaElementAudioSourceNode> CreateMediaElementSource(
       HTMLMediaElement& aMediaElement, ErrorResult& aRv);
   already_AddRefed<MediaStreamAudioSourceNode> CreateMediaStreamSource(
       DOMMediaStream& aMediaStream, ErrorResult& aRv);
   already_AddRefed<MediaStreamTrackAudioSourceNode>
-    CreateMediaStreamTrackSource(MediaStreamTrack& aMediaStreamTrack,
-        ErrorResult& aRv);
+  CreateMediaStreamTrackSource(MediaStreamTrack& aMediaStreamTrack,
+                               ErrorResult& aRv);
 
   already_AddRefed<DelayNode> CreateDelay(double aMaxDelayTime,
                                           ErrorResult& aRv);
 
   already_AddRefed<PannerNode> CreatePanner(ErrorResult& aRv);
 
   already_AddRefed<ConvolverNode> CreateConvolver(ErrorResult& aRv);
 
--- a/dom/svg/SVGAnimatedIntegerPair.h
+++ b/dom/svg/SVGAnimatedIntegerPair.h
@@ -74,17 +74,17 @@ class SVGAnimatedIntegerPair {
     DOMAnimatedInteger(SVGAnimatedIntegerPair* aVal, PairIndex aIndex,
                        SVGElement* aSVGElement)
         : mozilla::dom::DOMSVGAnimatedInteger(aSVGElement),
           mVal(aVal),
           mIndex(aIndex) {}
     virtual ~DOMAnimatedInteger();
 
     SVGAnimatedIntegerPair* mVal;  // kept alive because it belongs to content
-    PairIndex mIndex;      // are we the first or second integer
+    PairIndex mIndex;              // are we the first or second integer
 
     virtual int32_t BaseVal() override { return mVal->GetBaseValue(mIndex); }
     virtual void SetBaseVal(int32_t aValue) override {
       mVal->SetBaseValue(aValue, mIndex, mSVGElement);
     }
 
     // Script may have modified animation parameters or timeline -- DOM getters
     // need to flush any resample requests to reflect these modifications.
--- a/dom/svg/SVGAnimatedNumberPair.h
+++ b/dom/svg/SVGAnimatedNumberPair.h
@@ -77,17 +77,17 @@ class SVGAnimatedNumberPair {
     DOMAnimatedNumber(SVGAnimatedNumberPair* aVal, PairIndex aIndex,
                       SVGElement* aSVGElement)
         : mozilla::dom::DOMSVGAnimatedNumber(aSVGElement),
           mVal(aVal),
           mIndex(aIndex) {}
     virtual ~DOMAnimatedNumber();
 
     SVGAnimatedNumberPair* mVal;  // kept alive because it belongs to content
-    PairIndex mIndex;     // are we the first or second number
+    PairIndex mIndex;             // are we the first or second number
 
     virtual float BaseVal() override { return mVal->GetBaseValue(mIndex); }
     virtual void SetBaseVal(float aValue) override {
       MOZ_ASSERT(mozilla::IsFinite(aValue));
       mVal->SetBaseValue(aValue, mIndex, mSVGElement);
     }
 
     // Script may have modified animation parameters or timeline -- DOM getters
--- a/editor/libeditor/HTMLAbsPositionEditor.cpp
+++ b/editor/libeditor/HTMLAbsPositionEditor.cpp
@@ -619,18 +619,17 @@ nsresult HTMLEditor::GetTemporaryStyleFo
 
   RefPtr<ComputedStyle> style =
       nsComputedDOMStyle::GetComputedStyle(&aElement, nullptr);
   NS_ENSURE_STATE(style);
 
   const uint8_t kBlackBgTrigger = 0xd0;
 
   const auto& color = style->StyleColor()->mColor;
-  if (color.red >= kBlackBgTrigger &&
-      color.green >= kBlackBgTrigger &&
+  if (color.red >= kBlackBgTrigger && color.green >= kBlackBgTrigger &&
       color.blue >= kBlackBgTrigger) {
     aReturn.AssignLiteral("black");
   } else {
     aReturn.AssignLiteral("white");
   }
 
   return NS_OK;
 }
--- a/editor/libeditor/HTMLEditRules.cpp
+++ b/editor/libeditor/HTMLEditRules.cpp
@@ -336,17 +336,18 @@ nsresult HTMLEditRules::BeforeEdit(EditS
     mDidRangedDelete = false;
 
     AutoSafeEditorData setData(*this, *mHTMLEditor);
 
     // Remember where our selection was before edit action took place:
     if (HTMLEditorRef().GetCompositionStartPoint().IsSet()) {
       // If there is composition string, let's remember current composition
       // range.
-      mRangeItem->StoreRange(HTMLEditorRef().GetCompositionStartPoint(), HTMLEditorRef().GetCompositionEndPoint());
+      mRangeItem->StoreRange(HTMLEditorRef().GetCompositionStartPoint(),
+                             HTMLEditorRef().GetCompositionEndPoint());
     } else {
       // Get the selection location
       if (!SelectionRefPtr()->RangeCount()) {
         return NS_ERROR_UNEXPECTED;
       }
       mRangeItem->StoreRange(SelectionRefPtr()->GetRangeAt(0));
     }
     nsCOMPtr<nsINode> selStartNode = mRangeItem->mStartContainer;
--- a/editor/libeditor/SelectionState.h
+++ b/editor/libeditor/SelectionState.h
@@ -29,17 +29,18 @@ struct RangeItem final {
   RangeItem();
 
  private:
   // Private destructor, to discourage deletion outside of Release():
   ~RangeItem();
 
  public:
   void StoreRange(nsRange* aRange);
-  void StoreRange(const EditorRawDOMPoint& aStartPoint, const EditorRawDOMPoint& aEndPoint) {
+  void StoreRange(const EditorRawDOMPoint& aStartPoint,
+                  const EditorRawDOMPoint& aEndPoint) {
     MOZ_ASSERT(aStartPoint.IsSet());
     MOZ_ASSERT(aEndPoint.IsSet());
     mStartContainer = aStartPoint.GetContainer();
     mStartOffset = aStartPoint.Offset();
     mEndContainer = aEndPoint.GetContainer();
     mEndOffset = aEndPoint.Offset();
   }
   already_AddRefed<nsRange> GetRange();
--- a/editor/libeditor/WSRunObject.cpp
+++ b/editor/libeditor/WSRunObject.cpp
@@ -242,19 +242,19 @@ already_AddRefed<Element> WSRunObject::I
   RefPtr<Element> newBrElement =
       mHTMLEditor->InsertBrElementWithTransaction(pointToInsert, aSelect);
   if (NS_WARN_IF(!newBrElement)) {
     return nullptr;
   }
   return newBrElement.forget();
 }
 
-nsresult WSRunObject::InsertText(
-    Document& aDocument, const nsAString& aStringToInsert,
-    EditorRawDOMPoint* aPointAfterInsertedString)
+nsresult WSRunObject::InsertText(Document& aDocument,
+                                 const nsAString& aStringToInsert,
+                                 EditorRawDOMPoint* aPointAfterInsertedString)
     MOZ_CAN_RUN_SCRIPT_FOR_DEFINITION {
   // MOOSE: for now, we always assume non-PRE formatting.  Fix this later.
   // meanwhile, the pre case is handled in WillInsertText in
   // HTMLEditRules.cpp
 
   // MOOSE: for now, just getting the ws logic straight.  This implementation
   // is very slow.  Will need to replace edit rules impl with a more efficient
   // text sink here that does the minimal amount of searching/replacing/copying
--- a/extensions/universalchardet/src/base/nsUniversalDetector.cpp
+++ b/extensions/universalchardet/src/base/nsUniversalDetector.cpp
@@ -40,17 +40,17 @@ void nsUniversalDetector::Reset() {
   mInputState = ePureAscii;
   mLastChar = '\0';
 
   if (mMultibyteProber) {
     mMultibyteProber->Reset();
   }
 
   if (mEscCharSetProber) {
-    mEscCharSetProber->Reset(); 
+    mEscCharSetProber->Reset();
   }
 }
 
 //---------------------------------------------------------------------
 #define SHORTCUT_THRESHOLD (float)0.95
 #define MINIMUM_THRESHOLD (float)0.20
 
 nsresult nsUniversalDetector::HandleData(const char* aBuf, uint32_t aLen) {
@@ -131,22 +131,22 @@ nsresult nsUniversalDetector::HandleData
       }
       st = mEscCharSetProber->HandleData(aBuf, aLen);
       if (st == eFoundIt) {
         mDone = true;
         mDetectedCharset = mEscCharSetProber->GetCharSetName();
       }
       break;
     case eHighbyte:
-          st = mMultibyteProber->HandleData(aBuf, aLen);
-          if (st == eFoundIt) {
-            mDone = true;
-            mDetectedCharset = mMultibyteProber->GetCharSetName();
-            return NS_OK;
-          }
+      st = mMultibyteProber->HandleData(aBuf, aLen);
+      if (st == eFoundIt) {
+        mDone = true;
+        mDetectedCharset = mMultibyteProber->GetCharSetName();
+        return NS_OK;
+      }
       break;
 
     default:     // pure ascii
               ;  // do nothing here
   }
   return NS_OK;
 }
 
--- a/gfx/gl/GLContextProviderEGL.cpp
+++ b/gfx/gl/GLContextProviderEGL.cpp
@@ -475,18 +475,17 @@ bool GLContextEGL::RenewSurface(Composit
     if (!mSurface) {
       NS_WARNING("Failed to create EGLSurface from native window");
       return false;
     }
   }
   const bool ok = MakeCurrent(true);
   MOZ_ASSERT(ok);
 #if defined(MOZ_WAYLAND)
-  if (mSurface &&
-      !GDK_IS_X11_DISPLAY(gdk_display_get_default())) {
+  if (mSurface && !GDK_IS_X11_DISPLAY(gdk_display_get_default())) {
     const auto* egl = gl::GLLibraryEGL::Get();
     // Make eglSwapBuffers() non-blocking on wayland
     egl->fSwapInterval(EGL_DISPLAY(), 0);
   }
 #endif
   return ok;
 }
 
--- a/gfx/layers/apz/src/AsyncPanZoomController.cpp
+++ b/gfx/layers/apz/src/AsyncPanZoomController.cpp
@@ -3139,17 +3139,17 @@ bool AsyncPanZoomController::AttemptScro
                     manager->GetAndroidDynamicToolbarAnimator()) {
               animator->SetScrollingRootContent();
             }
           }
         }
 #endif
         bool displacementIsUserVisible = true;
 
-        { // Release the APZC lock before calling ToScreenCoordinates which
+        {  // Release the APZC lock before calling ToScreenCoordinates which
           // acquires the APZ tree lock. Note that this just unlocks the mutex
           // once, so if we're locking it multiple times on the callstack then
           // this will be insufficient.
           RecursiveMutexAutoUnlock unlock(mRecursiveMutex);
 
           ScreenIntPoint screenDisplacement = RoundedToInt(
               ToScreenCoordinates(adjustedDisplacement, aStartPoint));
           // If the displacement we just applied rounds to zero in screen space,
@@ -3354,17 +3354,17 @@ void AsyncPanZoomController::HandleFling
     const RefPtr<const AsyncPanZoomController>& aScrolledApzc) {
   APZCTreeManager* treeManagerLocal = GetApzcTreeManager();
   if (treeManagerLocal) {
     const FlingHandoffState handoffState{aVelocity, aOverscrollHandoffChain,
                                          true /* handoff */, aScrolledApzc};
     ParentLayerPoint residualVelocity =
         treeManagerLocal->DispatchFling(this, handoffState);
     FLING_LOG("APZC %p left with residual velocity %s\n", this,
-        Stringify(residualVelocity).c_str());
+              Stringify(residualVelocity).c_str());
     if (!IsZero(residualVelocity) && IsPannable() &&
         gfxPrefs::APZOverscrollEnabled()) {
       // Obey overscroll-behavior.
       RecursiveMutexAutoLock lock(mRecursiveMutex);
       if (!mX.OverscrollBehaviorAllowsOverscrollEffect()) {
         residualVelocity.x = 0;
       }
       if (!mY.OverscrollBehaviorAllowsOverscrollEffect()) {
@@ -4815,18 +4815,18 @@ void AsyncPanZoomController::ZoomToRect(
     // If the zoom factor is lower than this (i.e. we are zoomed more into the
     // page), then the CSS content rect, in layers pixels, will be smaller than
     // the composition bounds. If this happens, we can't fill the target
     // composited area with this frame.
     CSSToParentLayerScale localMinZoom(
         std::max(mZoomConstraints.mMinZoom.scale,
                  std::max(compositionBounds.Width() / cssPageRect.Width(),
                           compositionBounds.Height() / cssPageRect.Height())));
-    CSSToParentLayerScale localMaxZoom
-        = std::max(localMinZoom, mZoomConstraints.mMaxZoom);
+    CSSToParentLayerScale localMaxZoom =
+        std::max(localMinZoom, mZoomConstraints.mMaxZoom);
 
     if (!aRect.IsEmpty()) {
       // Intersect the zoom-to-rect to the CSS rect to make sure it fits.
       aRect = aRect.Intersect(cssPageRect);
       targetZoom = CSSToParentLayerScale(
           std::min(compositionBounds.Width() / aRect.Width(),
                    compositionBounds.Height() / aRect.Height()));
     }
--- a/gfx/layers/apz/src/Axis.cpp
+++ b/gfx/layers/apz/src/Axis.cpp
@@ -61,22 +61,22 @@ float Axis::ToLocalVelocity(float aVeloc
 void Axis::UpdateWithTouchAtDevicePoint(ParentLayerCoord aPos,
                                         uint32_t aTimestampMs) {
   // mVelocityTracker is controller-thread only
   APZThreadUtils::AssertOnControllerThread();
 
   mPos = aPos;
 
   AXIS_LOG("%p|%s got position %f\n", mAsyncPanZoomController, Name(),
-      mPos.value);
+           mPos.value);
   if (Maybe<float> newVelocity =
           mVelocityTracker->AddPosition(aPos, aTimestampMs)) {
     mVelocity = mAxisLocked ? 0 : *newVelocity;
     AXIS_LOG("%p|%s velocity from tracker is %f\n", mAsyncPanZoomController,
-        Name(), mVelocity);
+             Name(), mVelocity);
   }
 }
 
 void Axis::HandleDynamicToolbarMovement(uint32_t aStartTimestampMs,
                                         uint32_t aEndTimestampMs,
                                         ParentLayerCoord aDelta) {
   // mVelocityTracker is controller-thread only
   APZThreadUtils::AssertOnControllerThread();
--- a/gfx/layers/apz/src/GenericFlingAnimation.h
+++ b/gfx/layers/apz/src/GenericFlingAnimation.h
@@ -92,24 +92,26 @@ class GenericFlingAnimation : public Asy
     // are then handed off using the normal DispatchFling codepath. Acceleration
     // is only applied in the APZC that originated the fling, not in APZCs
     // further down the handoff chain during handoff.
     bool applyAcceleration = !aFlingIsHandedOff;
     if (applyAcceleration && !mApzc.mLastFlingTime.IsNull() &&
         (now - mApzc.mLastFlingTime).ToMilliseconds() <
             gfxPrefs::APZFlingAccelInterval() &&
         velocity.Length() >= gfxPrefs::APZFlingAccelMinVelocity()) {
-      if (velocity.x != 0 && SameDirection(velocity.x, mApzc.mLastFlingVelocity.x)) {
+      if (velocity.x != 0 &&
+          SameDirection(velocity.x, mApzc.mLastFlingVelocity.x)) {
         velocity.x = Accelerate(velocity.x, mApzc.mLastFlingVelocity.x);
         FLING_LOG("%p Applying fling x-acceleration from %f to %f (delta %f)\n",
                   &mApzc, mApzc.mX.GetVelocity(), velocity.x,
                   mApzc.mLastFlingVelocity.x);
         mApzc.mX.SetVelocity(velocity.x);
       }
-      if (velocity.y != 0 && SameDirection(velocity.y, mApzc.mLastFlingVelocity.y)) {
+      if (velocity.y != 0 &&
+          SameDirection(velocity.y, mApzc.mLastFlingVelocity.y)) {
         velocity.y = Accelerate(velocity.y, mApzc.mLastFlingVelocity.y);
         FLING_LOG("%p Applying fling y-acceleration from %f to %f (delta %f)\n",
                   &mApzc, mApzc.mY.GetVelocity(), velocity.y,
                   mApzc.mLastFlingVelocity.y);
         mApzc.mY.SetVelocity(velocity.y);
       }
     }
 
--- a/gfx/layers/client/ClientTiledPaintedLayer.cpp
+++ b/gfx/layers/client/ClientTiledPaintedLayer.cpp
@@ -64,17 +64,16 @@ void ClientTiledPaintedLayer::FillSpecif
 static Maybe<LayerRect> ApplyParentLayerToLayerTransform(
     const ParentLayerToLayerMatrix4x4& aTransform,
     const ParentLayerRect& aParentLayerRect, const LayerRect& aClip) {
   return UntransformBy(aTransform, aParentLayerRect, aClip);
 }
 
 static LayerToParentLayerMatrix4x4 GetTransformToAncestorsParentLayer(
     Layer* aStart, const LayerMetricsWrapper& aAncestor) {
-
   // If the ancestor layer Combines3DTransformWithAncestors, then the
   // scroll offset is contained in the transform of the layer at the
   // root of the 3D context. So we must first find that layer, then
   // calcuate the transform to its parent.
   LayerMetricsWrapper root3dAncestor = aAncestor;
   while (root3dAncestor.Combines3DTransformWithAncestors()) {
     root3dAncestor = root3dAncestor.GetParent();
   }
--- a/gfx/layers/wr/WebRenderCommandBuilder.cpp
+++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ -1129,18 +1129,18 @@ static bool IsItemProbablyActive(nsDispl
     }
     case DisplayItemType::TYPE_FOREIGN_OBJECT: {
       return true;
     }
     case DisplayItemType::TYPE_BLEND_MODE: {
       /* BLEND_MODE needs to be active if it might have a previous sibling
        * that is active. We use the activeness of the parent as a rough
        * proxy for this situation. */
-      return aParentActive || HasActiveChildren(*aItem->GetChildren(),
-                                                aDisplayListBuilder);
+      return aParentActive ||
+             HasActiveChildren(*aItem->GetChildren(), aDisplayListBuilder);
     }
     case DisplayItemType::TYPE_WRAP_LIST:
     case DisplayItemType::TYPE_PERSPECTIVE: {
       if (aItem->GetChildren()) {
         return HasActiveChildren(*aItem->GetChildren(), aDisplayListBuilder);
       }
       return false;
     }
--- a/gfx/src/nsFont.h
+++ b/gfx/src/nsFont.h
@@ -9,20 +9,20 @@
 
 #include <stdint.h>     // for uint8_t, uint16_t
 #include <sys/types.h>  // for int16_t
 #include "gfxFontFamilyList.h"
 #include "gfxFontConstants.h"  // for NS_FONT_KERNING_AUTO, etc
 #include "gfxFontFeatures.h"
 #include "gfxFontVariations.h"
 #include "mozilla/FontPropertyTypes.h"
-#include "mozilla/RefPtr.h"  // for RefPtr
-#include "mozilla/StyleColorInlines.h" // for StyleRGBA
-#include "nsCoord.h"         // for nscoord
-#include "nsTArray.h"        // for nsTArray
+#include "mozilla/RefPtr.h"             // for RefPtr
+#include "mozilla/StyleColorInlines.h"  // for StyleRGBA
+#include "nsCoord.h"                    // for nscoord
+#include "nsTArray.h"                   // for nsTArray
 
 struct gfxFontStyle;
 
 // Font structure.
 struct nsFont final {
   typedef mozilla::FontStretch FontStretch;
   typedef mozilla::FontSlantStyle FontSlantStyle;
   typedef mozilla::FontWeight FontWeight;
--- a/gfx/thebes/gfxFontFamilyList.h
+++ b/gfx/thebes/gfxFontFamilyList.h
@@ -44,19 +44,17 @@ struct FontFamilyName final {
   }
 
   FontFamilyName(const FontFamilyName&) = default;
 
   bool IsNamed() const { return !!mName; }
 
   bool IsGeneric() const { return !IsNamed(); }
 
-  bool IsQuoted() const {
-    return mSyntax == StyleFontFamilyNameSyntax::Quoted;
-  }
+  bool IsQuoted() const { return mSyntax == StyleFontFamilyNameSyntax::Quoted; }
 
   void AppendToString(nsACString& aFamilyList, bool aQuotes = true) const {
     if (IsNamed()) {
       if (mSyntax == Syntax::Identifiers) {
         return aFamilyList.Append(nsAtomCString(mName));
       }
       if (aQuotes) {
         aFamilyList.Append('"');
--- a/gfx/thebes/gfxPlatformGtk.cpp
+++ b/gfx/thebes/gfxPlatformGtk.cpp
@@ -324,19 +324,17 @@ uint32_t gfxPlatformGtk::MaxGenericSubst
     if (mMaxGenericSubstitutions < 0) {
       mMaxGenericSubstitutions = 3;
     }
   }
 
   return uint32_t(mMaxGenericSubstitutions);
 }
 
-bool gfxPlatformGtk::AccelerateLayersByDefault() {
-  return true;
-}
+bool gfxPlatformGtk::AccelerateLayersByDefault() { return true; }
 
 void gfxPlatformGtk::GetPlatformCMSOutputProfile(void*& mem, size_t& size) {
   mem = nullptr;
   size = 0;
 
 #ifdef MOZ_X11
   GdkDisplay* display = gdk_display_get_default();
   if (!GDK_IS_X11_DISPLAY(display)) return;
--- a/gfx/thebes/gfxTextRun.cpp
+++ b/gfx/thebes/gfxTextRun.cpp
@@ -1751,19 +1751,18 @@ void gfxFontGroup::AddPlatformFont(const
       aFamilyList.AppendElement(family);
       return;
     }
   }
 
   // Not known in the user font set ==> check system fonts
   gfxPlatformFontList::PlatformFontList()->FindAndAddFamilies(
       aName, &aFamilyList,
-      aQuotedName
-        ? gfxPlatformFontList::FindFamiliesFlags::eQuotedFamilyName
-        : gfxPlatformFontList::FindFamiliesFlags(0),
+      aQuotedName ? gfxPlatformFontList::FindFamiliesFlags::eQuotedFamilyName
+                  : gfxPlatformFontList::FindFamiliesFlags(0),
       &mStyle, mDevToCssSize);
 }
 
 void gfxFontGroup::AddFamilyToFontList(gfxFontFamily* aFamily,
                                        StyleGenericFontFamily aGeneric) {
   if (!aFamily) {
     MOZ_ASSERT_UNREACHABLE("don't try to add a null font family!");
     return;
--- a/gfx/thebes/gfxTextRun.h
+++ b/gfx/thebes/gfxTextRun.h
@@ -1251,18 +1251,17 @@ class gfxFontGroup final : public gfxTex
   // Helper for font-matching:
   // search all faces in a family for a fallback in cases where it's unclear
   // whether the family might have a font for a given character
   gfxFont* FindFallbackFaceForChar(gfxFontFamily* aFamily, uint32_t aCh);
 
   // helper methods for looking up fonts
 
   // lookup and add a font with a given name (i.e. *not* a generic!)
-  void AddPlatformFont(const nsACString& aName,
-                       bool aQuotedName,
+  void AddPlatformFont(const nsACString& aName, bool aQuotedName,
                        nsTArray<FamilyAndGeneric>& aFamilyList);
 
   // do style selection and add entries to list
   void AddFamilyToFontList(gfxFontFamily* aFamily,
                            mozilla::StyleGenericFontFamily aGeneric);
 };
 
 // A "missing font recorder" is to be used during text-run creation to keep
--- a/gfx/vr/VRDisplayHost.h
+++ b/gfx/vr/VRDisplayHost.h
@@ -55,17 +55,16 @@ class VRDisplayHost {
                    const gfx::Rect& aLeftEyeRect,
                    const gfx::Rect& aRightEyeRect);
   void CancelCurrentSubmitTask();
   bool CheckClearDisplayInfoDirty();
   void SetGroupMask(uint32_t aGroupMask);
   bool GetIsConnected();
   void ShutdownSubmitThread();
 
-
   class AutoRestoreRenderState {
    public:
     explicit AutoRestoreRenderState(VRDisplayHost* aDisplay);
     ~AutoRestoreRenderState();
     bool IsSuccess();
 
    private:
     RefPtr<VRDisplayHost> mDisplay;
--- a/gfx/vr/ipc/VRGPUChild.cpp
+++ b/gfx/vr/ipc/VRGPUChild.cpp
@@ -48,19 +48,18 @@ void VRGPUChild::Shutdown() {
   if (sVRGPUChildSingleton && !sVRGPUChildSingleton->IsClosed()) {
     sVRGPUChildSingleton->Close();
   }
   sVRGPUChildSingleton = nullptr;
 }
 
 void VRGPUChild::ActorDestroy(ActorDestroyReason aWhy) {
   VRManager* vm = VRManager::Get();
-  CompositorThreadHolder::Loop()->PostTask(NewRunnableMethod(
-    "VRGPUChild::ActorDestroy",
-    vm, &VRManager::Shutdown));
+  CompositorThreadHolder::Loop()->PostTask(
+      NewRunnableMethod("VRGPUChild::ActorDestroy", vm, &VRManager::Shutdown));
 
   mClosed = true;
 }
 
 bool VRGPUChild::IsClosed() { return mClosed; }
 
 }  // namespace gfx
 }  // namespace mozilla
--- a/ipc/glue/GeckoChildProcessHost.cpp
+++ b/ipc/glue/GeckoChildProcessHost.cpp
@@ -178,18 +178,18 @@ void GeckoChildProcessHost::Destroy() {
 
   using Value = HandlePromise::ResolveOrRejectValue;
   mDestroying = true;
   whenReady->Then(XRE_GetIOMessageLoop()->SerialEventTarget(), __func__,
                   [this](const Value&) { delete this; });
 }
 
 // static
-mozilla::BinPathType GeckoChildProcessHost::GetPathToBinary(FilePath& exePath,
-                                            GeckoProcessType processType) {
+mozilla::BinPathType GeckoChildProcessHost::GetPathToBinary(
+    FilePath& exePath, GeckoProcessType processType) {
   BinPathType pathType = XRE_GetChildProcBinPathType(processType);
 
   if (pathType == BinPathType::Self) {
 #if defined(OS_WIN)
     wchar_t exePathBuf[MAXPATHLEN];
     if (!::GetModuleFileNameW(nullptr, exePathBuf, MAXPATHLEN)) {
       MOZ_CRASH("GetModuleFileNameW failed (FIXME)");
     }
--- a/ipc/glue/ProcessUtils_common.cpp
+++ b/ipc/glue/ProcessUtils_common.cpp
@@ -65,18 +65,17 @@ void SharedPreferenceSerializer::AddShar
   // Record the handle as to-be-shared, and pass it via a command flag. This
   // works because Windows handles are system-wide.
   HANDLE prefsHandle = GetSharedMemoryHandle();
   procHost.AddHandleToShare(prefsHandle);
   procHost.AddHandleToShare(GetPrefMapHandle().get());
   aExtraOpts.push_back("-prefsHandle");
   aExtraOpts.push_back(formatPtrArg(prefsHandle).get());
   aExtraOpts.push_back("-prefMapHandle");
-  aExtraOpts.push_back(
-      formatPtrArg(GetPrefMapHandle().get()).get());
+  aExtraOpts.push_back(formatPtrArg(GetPrefMapHandle().get()).get());
 #else
   // In contrast, Unix fds are per-process. So remap the fd to a fixed one that
   // will be used in the child.
   // XXX: bug 1440207 is about improving how fixed fds are used.
   //
   // Note: on Android, AddFdToRemap() sets up the fd to be passed via a Parcel,
   // and the fixed fd isn't used. However, we still need to mark it for
   // remapping so it doesn't get closed in the child.
@@ -86,17 +85,16 @@ void SharedPreferenceSerializer::AddShar
 
   // Pass the lengths via command line flags.
   aExtraOpts.push_back("-prefsLen");
   aExtraOpts.push_back(formatPtrArg(GetPrefLength()).get());
   aExtraOpts.push_back("-prefMapSize");
   aExtraOpts.push_back(formatPtrArg(GetPrefMapSize()).get());
 }
 
-
 #ifdef ANDROID
 static int gPrefsFd = -1;
 static int gPrefMapFd = -1;
 
 void SetPrefsFd(int aFd) { gPrefsFd = aFd; }
 
 void SetPrefMapFd(int aFd) { gPrefMapFd = aFd; }
 #endif
--- a/js/ipc/WrapperOwner.cpp
+++ b/js/ipc/WrapperOwner.cpp
@@ -106,18 +106,19 @@ class CPOWProxyHandler : public BaseProx
                    JS::ObjectOpResult& result) const override;
   virtual bool call(JSContext* cx, HandleObject proxy,
                     const CallArgs& args) const override;
   virtual bool construct(JSContext* cx, HandleObject proxy,
                          const CallArgs& args) const override;
 
   virtual bool hasOwn(JSContext* cx, HandleObject proxy, HandleId id,
                       bool* bp) const override;
-  virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject proxy,
-                                            MutableHandleIdVector props) const override;
+  virtual bool getOwnEnumerablePropertyKeys(
+      JSContext* cx, HandleObject proxy,
+      MutableHandleIdVector props) const override;
   virtual bool hasInstance(JSContext* cx, HandleObject proxy,
                            MutableHandleValue v, bool* bp) const override;
   virtual bool getBuiltinClass(JSContext* cx, HandleObject obj,
                                js::ESClass* cls) const override;
   virtual bool isArray(JSContext* cx, HandleObject obj,
                        IsArrayAnswer* answer) const override;
   virtual const char* className(JSContext* cx,
                                 HandleObject proxy) const override;
@@ -511,19 +512,18 @@ bool WrapperOwner::set(JSContext* cx, JS
     return ipcfail(cx);
   }
 
   LOG_STACK();
 
   return ok(cx, status, result);
 }
 
-bool CPOWProxyHandler::getOwnEnumerablePropertyKeys(JSContext* cx,
-                                                    HandleObject proxy,
-                                                    MutableHandleIdVector props) const {
+bool CPOWProxyHandler::getOwnEnumerablePropertyKeys(
+    JSContext* cx, HandleObject proxy, MutableHandleIdVector props) const {
   FORWARD(getOwnEnumerablePropertyKeys, (cx, proxy, props), false);
 }
 
 bool WrapperOwner::getOwnEnumerablePropertyKeys(JSContext* cx,
                                                 HandleObject proxy,
                                                 MutableHandleIdVector props) {
   return getPropertyKeys(cx, proxy, JSITER_OWNONLY, props);
 }
@@ -884,17 +884,18 @@ void WrapperOwner::drop(JSObject* obj) {
 
 void WrapperOwner::updatePointer(JSObject* obj, const JSObject* old) {
   ObjectId objId = idOfUnchecked(obj);
   MOZ_ASSERT(hasCPOW(objId, old));
   cpows_.add(objId, obj);
 }
 
 bool WrapperOwner::getPropertyKeys(JSContext* cx, HandleObject proxy,
-                                   uint32_t flags, MutableHandleIdVector props) {
+                                   uint32_t flags,
+                                   MutableHandleIdVector props) {
   ObjectId objId = idOf(proxy);
 
   ReturnStatus status;
   InfallibleTArray<JSIDVariant> ids;
   if (!SendGetPropertyKeys(objId, flags, &status, &ids)) {
     return ipcfail(cx);
   }
 
--- a/js/public/Wrapper.h
+++ b/js/public/Wrapper.h
@@ -81,18 +81,19 @@ class JS_FRIEND_API ForwardingProxyHandl
   virtual bool call(JSContext* cx, HandleObject proxy,
                     const CallArgs& args) const override;
   virtual bool construct(JSContext* cx, HandleObject proxy,
                          const CallArgs& args) const override;
 
   /* SpiderMonkey extensions. */
   virtual bool hasOwn(JSContext* cx, HandleObject proxy, HandleId id,
                       bool* bp) const override;
-  virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject proxy,
-                                            MutableHandleIdVector props) const override;
+  virtual bool getOwnEnumerablePropertyKeys(
+      JSContext* cx, HandleObject proxy,
+      MutableHandleIdVector props) const override;
   virtual bool nativeCall(JSContext* cx, IsAcceptableThis test, NativeImpl impl,
                           const CallArgs& args) const override;
   virtual bool hasInstance(JSContext* cx, HandleObject proxy,
                            MutableHandleValue v, bool* bp) const override;
   virtual bool getBuiltinClass(JSContext* cx, HandleObject proxy,
                                ESClass* cls) const override;
   virtual bool isArray(JSContext* cx, HandleObject proxy,
                        JS::IsArrayAnswer* answer) const override;
@@ -221,18 +222,19 @@ class JS_FRIEND_API CrossCompartmentWrap
   virtual bool call(JSContext* cx, HandleObject wrapper,
                     const CallArgs& args) const override;
   virtual bool construct(JSContext* cx, HandleObject wrapper,
                          const CallArgs& args) const override;
 
   /* SpiderMonkey extensions. */
   virtual bool hasOwn(JSContext* cx, HandleObject wrapper, HandleId id,
                       bool* bp) const override;
-  virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject wrapper,
-                                            MutableHandleIdVector props) const override;
+  virtual bool getOwnEnumerablePropertyKeys(
+      JSContext* cx, HandleObject wrapper,
+      MutableHandleIdVector props) const override;
   virtual bool nativeCall(JSContext* cx, IsAcceptableThis test, NativeImpl impl,
                           const CallArgs& args) const override;
   virtual bool hasInstance(JSContext* cx, HandleObject wrapper,
                            MutableHandleValue v, bool* bp) const override;
   virtual const char* className(JSContext* cx,
                                 HandleObject proxy) const override;
   virtual JSString* fun_toString(JSContext* cx, HandleObject wrapper,
                                  bool isToSource) const override;
@@ -291,18 +293,19 @@ class JS_FRIEND_API OpaqueCrossCompartme
   virtual bool call(JSContext* cx, HandleObject wrapper,
                     const CallArgs& args) const override;
   virtual bool construct(JSContext* cx, HandleObject wrapper,
                          const CallArgs& args) const override;
 
   /* SpiderMonkey extensions. */
   virtual bool hasOwn(JSContext* cx, HandleObject wrapper, HandleId id,
                       bool* bp) const override;
-  virtual bool getOwnEnumerablePropertyKeys(JSContext* cx, HandleObject wrapper,
-                                            MutableHandleIdVector props) const override;
+  virtual bool getOwnEnumerablePropertyKeys(
+      JSContext* cx, HandleObject wrapper,
+      MutableHandleIdVector props) const override;
   virtual bool getBuiltinClass(JSContext* cx, HandleObject wrapper,
                                ESClass* cls) const override;
   virtual bool isArray(JSContext* cx, HandleObject obj,
                        JS::IsArrayAnswer* answer) const override;
   virtual bool hasInstance(JSContext* cx, HandleObject wrapper,
                            MutableHandleValue v, bool* bp) const override;
   virtual const char* className(JSContext* cx,
                                 HandleObject wrapper) const override;
--- a/js/src/builtin/Stream.cpp
+++ b/js/src/builtin/Stream.cpp
@@ -3053,17 +3053,18 @@ static MOZ_MUST_USE bool ReadableStreamD
     }
 
     // Step b: If result is an abrupt completion,
     // and
     // Step e: If enqueueResult is an abrupt completion,
     if (!success) {
       RootedValue exn(cx);
       RootedSavedFrame stack(cx);
-      if (!cx->isExceptionPending() || !GetAndClearExceptionAndStack(cx, &exn, &stack)) {
+      if (!cx->isExceptionPending() ||
+          !GetAndClearExceptionAndStack(cx, &exn, &stack)) {
         // Uncatchable error. Die immediately without erroring the
         // stream.
         return false;
       }
 
       // Step b.i: Perform ! ReadableStreamDefaultControllerError(
       //           controller, result.[[Value]]).
       // Step e.i: Perform ! ReadableStreamDefaultControllerError(
@@ -3877,17 +3878,18 @@ static MOZ_MUST_USE bool ReadableByteStr
     // Step b: If firstPendingPullInto.[[bytesFilled]] > 0,
     if (unwrappedFirstPendingPullInto->bytesFilled() > 0) {
       // Step i: Let e be a new TypeError exception.
       JS_ReportErrorNumberASCII(
           cx, GetErrorMessage, nullptr,
           JSMSG_READABLEBYTESTREAMCONTROLLER_CLOSE_PENDING_PULL);
       RootedValue e(cx);
       RootedSavedFrame stack(cx);
-      if (!cx->isExceptionPending() || !GetAndClearExceptionAndStack(cx, &e, &stack)) {
+      if (!cx->isExceptionPending() ||
+          !GetAndClearExceptionAndStack(cx, &e, &stack)) {
         // Uncatchable error. Die immediately without erroring the
         // stream.
         return false;
       }
 
       // Step ii: Perform ! ReadableByteStreamControllerError(controller, e).
       if (!ReadableStreamControllerError(cx, unwrappedController, e)) {
         return false;
--- a/js/src/builtin/TypedObject.cpp
+++ b/js/src/builtin/TypedObject.cpp
@@ -833,18 +833,18 @@ JSObject* StructMetaTypeDescr::create(JS
   return createFromArrays(cx, structTypePrototype, opaque,
                           /* allowConstruct= */ true, ids, fieldTypeObjs,
                           fieldProps);
 }
 
 /* static */
 StructTypeDescr* StructMetaTypeDescr::createFromArrays(
     JSContext* cx, HandleObject structTypePrototype, bool opaque,
-    bool allowConstruct, HandleIdVector ids, JS::HandleValueVector fieldTypeObjs,
-    Vector<StructFieldProps>& fieldProps) {
+    bool allowConstruct, HandleIdVector ids,
+    JS::HandleValueVector fieldTypeObjs, Vector<StructFieldProps>& fieldProps) {
   StringBuffer stringBuffer(cx);       // Canonical string repr
   RootedValueVector fieldNames(cx);    // Name of each field.
   RootedValueVector fieldOffsets(cx);  // Offset of each field field.
   RootedValueVector fieldMuts(cx);     // Mutability of each field.
   RootedObject userFieldOffsets(cx);   // User-exposed {f:offset} object
   RootedObject userFieldTypes(cx);     // User-exposed {f:descr} object.
   Layout layout;                       // Field offsetter
 
--- a/js/src/frontend/TokenStream.h
+++ b/js/src/frontend/TokenStream.h
@@ -633,18 +633,18 @@ class TokenStreamAnyChars : public Token
   //     x = arg => q       // per spec, this is all one statement, and the
   //     /a/g;              // slashes are division operators
   //
   //     x = arg => {}      // per spec, ASI at the end of this line
   //     /a/g;              // and that's a regexp literal
   //
   // The first program shows why orExpr() has use SlashIsDiv mode when peeking
   // ahead for the next operator after parsing `q`. The second program shows
-  // why matchOrInsertSemicolon() must use SlashIsRegExp mode when scanning ahead
-  // for a semicolon.
+  // why matchOrInsertSemicolon() must use SlashIsRegExp mode when scanning
+  // ahead for a semicolon.
   void allowGettingNextTokenWithSlashIsRegExp() {
 #ifdef DEBUG
     // Check the precondition: Caller already peeked ahead at the next token,
     // in SlashIsDiv mode, and it is *not* a Div token.
     MOZ_ASSERT(hasLookahead());
     const Token& next = nextToken();
     MOZ_ASSERT(next.modifier == SlashIsDiv);
     MOZ_ASSERT(next.type != TokenKind::Div);
--- a/js/src/gc/GCRuntime.h
+++ b/js/src/gc/GCRuntime.h
@@ -305,19 +305,17 @@ class GCRuntime {
 
  public:
   // Internal public interface
   State state() const { return incrementalState; }
   bool isHeapCompacting() const { return state() == State::Compact; }
   bool isForegroundSweeping() const { return state() == State::Sweep; }
   bool isBackgroundSweeping() { return sweepTask.isRunning(); }
   void waitBackgroundSweepEnd();
-  void waitBackgroundAllocEnd() {
-    allocTask.cancelAndWait();
-  }
+  void waitBackgroundAllocEnd() { allocTask.cancelAndWait(); }
   void waitBackgroundFreeEnd();
 
   void lockGC() { lock.lock(); }
 
   void unlockGC() { lock.unlock(); }
 
 #ifdef DEBUG
   bool currentThreadHasLockedGC() const { return lock.ownedByCurrentThread(); }
--- a/js/src/jit/BaselineIC.h
+++ b/js/src/jit/BaselineIC.h
@@ -220,22 +220,22 @@ class ICEntry {
   // A pointer to the first IC stub for this instruction.
   ICStub* firstStub_;
 
   // The PC offset of this IC's bytecode op within the JSScript or
   // ProloguePCOffset if this is a prologue IC.
   uint32_t pcOffset_;
 
 #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
-#ifdef JS_64BIT
+#  ifdef JS_64BIT
   // On 64-bit architectures, we have 32 bits of alignment padding.
   // We fill it with a magic value, and check that value when tracing.
   static const uint32_t EXPECTED_TRACE_MAGIC = 0xdeaddead;
   uint32_t traceMagic_ = EXPECTED_TRACE_MAGIC;
-#endif
+#  endif
 #endif
 
  public:
   // Prologue ICs are Baseline ICs used for function argument/this type
   // monitoring in the script's prologue. Note: the last bytecode op in a script
   // is always a return so UINT32_MAX is never a valid bytecode offset.
   static constexpr uint32_t ProloguePCOffset = UINT32_MAX;
 
--- a/js/src/jit/CacheIR.cpp
+++ b/js/src/jit/CacheIR.cpp
@@ -4718,21 +4718,23 @@ AttachDecision CallIRGenerator::tryAttac
   // Ensure callee is the |String_split| native function.
   ValOperandId calleeValId =
       writer.loadArgumentFixedSlot(ArgumentKind::Callee, argc_);
   ObjOperandId calleeObjId = writer.guardIsObject(calleeValId);
   writer.guardSpecificNativeFunction(calleeObjId,
                                      js::intrinsic_StringSplitString);
 
   // Ensure arg0 is a string.
-  ValOperandId arg0ValId = writer.loadArgumentFixedSlot(ArgumentKind::Arg0, argc_);
+  ValOperandId arg0ValId =
+      writer.loadArgumentFixedSlot(ArgumentKind::Arg0, argc_);
   StringOperandId arg0StrId = writer.guardIsString(arg0ValId);
 
   // Ensure arg1 is a string.
-  ValOperandId arg1ValId = writer.loadArgumentFixedSlot(ArgumentKind::Arg1, argc_);
+  ValOperandId arg1ValId =
+      writer.loadArgumentFixedSlot(ArgumentKind::Arg1, argc_);
   StringOperandId arg1StrId = writer.guardIsString(arg1ValId);
 
   // Call custom string splitter VM-function.
   writer.callStringSplitResult(arg0StrId, arg1StrId, group);
   writer.typeMonitorResult();
 
   cacheIRStubKind_ = BaselineCacheIRStubKind::Monitored;
   trackAttached("StringSplitString");
@@ -4789,17 +4791,18 @@ AttachDecision CallIRGenerator::tryAttac
 
   // Guard callee is the |js::array_push| native function.
   ValOperandId calleeValId =
       writer.loadArgumentFixedSlot(ArgumentKind::Callee, argc_);
   ObjOperandId calleeObjId = writer.guardIsObject(calleeValId);
   writer.guardSpecificNativeFunction(calleeObjId, js::array_push);
 
   // Guard this is an array object.
-  ValOperandId thisValId = writer.loadArgumentFixedSlot(ArgumentKind::This, argc_);
+  ValOperandId thisValId =
+      writer.loadArgumentFixedSlot(ArgumentKind::This, argc_);
   ObjOperandId thisObjId = writer.guardIsObject(thisValId);
 
   // This is a soft assert, documenting the fact that we pass 'true'
   // for needsTypeBarrier when constructing typeCheckInfo_ for CallIRGenerator.
   // Can be removed safely if the assumption becomes false.
   MOZ_ASSERT(typeCheckInfo_.needsTypeBarrier());
 
   // Guard that the group and shape matches.
--- a/js/src/jsapi-tests/testFreshGlobalEvalRedefinition.cpp
+++ b/js/src/jsapi-tests/testFreshGlobalEvalRedefinition.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  * vim: set ts=8 sts=2 et sw=2 tw=80:
  */
 /* 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 "mozilla/ArrayUtils.h"  // mozilla::ArrayLength
-#include "mozilla/Utf8.h"  // mozilla::Utf8Unit
+#include "mozilla/Utf8.h"        // mozilla::Utf8Unit
 
 #include "js/CompilationAndEvaluation.h"  // JS::Evaluate
 #include "js/SourceText.h"                // JS::Source{Ownership,Text}
 #include "jsapi-tests/tests.h"
 
 static bool GlobalResolve(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
                           bool* resolvedp) {
   return JS_ResolveStandardClass(cx, obj, id, resolvedp);
--- a/js/src/jsapi-tests/testSavedStacks.cpp
+++ b/js/src/jsapi-tests/testSavedStacks.cpp
@@ -293,18 +293,17 @@ BEGIN_TEST(testSavedStacks_selfHostedFra
   lin = str->ensureLinear(cx);
   CHECK(lin);
   CHECK(js::StringEqualsAscii(lin, "filename.js"));
 
   return true;
 }
 END_TEST(testSavedStacks_selfHostedFrames)
 
-BEGIN_TEST(test_JS_GetPendingExceptionStack)
-{
+BEGIN_TEST(test_JS_GetPendingExceptionStack) {
   CHECK(js::DefineTestingFunctions(cx, global, false, false));
 
   JSPrincipals* principals = cx->realm()->principals();
 
   static const char sourceText[] =
       //          1         2         3
       // 123456789012345678901234567890123456789
       "(function one() {                      \n"   // 1
@@ -338,52 +337,52 @@ BEGIN_TEST(test_JS_GetPendingExceptionSt
   CHECK(val.isInt32());
   CHECK(val.toInt32() == 5);
 
   struct {
     uint32_t line;
     uint32_t column;
     const char* source;
     const char* functionDisplayName;
-  } expected[] = {
-    { 4, 7, "filename.js", "three" },
-    { 5, 6, "filename.js", "two" },
-    { 6, 4, "filename.js", "one" },
-    { 7, 2, "filename.js", nullptr }
-  };
+  } expected[] = {{4, 7, "filename.js", "three"},
+                  {5, 6, "filename.js", "two"},
+                  {6, 4, "filename.js", "one"},
+                  {7, 2, "filename.js", nullptr}};
 
   size_t i = 0;
-  for (JS::Handle<js::SavedFrame*> frame : js::SavedFrame::RootedRange(cx, savedFrameStack)) {
+  for (JS::Handle<js::SavedFrame*> frame :
+       js::SavedFrame::RootedRange(cx, savedFrameStack)) {
     CHECK(i < 4);
 
     // Line
     uint32_t line = 123;
-    JS::SavedFrameResult result = JS::GetSavedFrameLine(cx, principals, frame, &line,
-                                                        JS::SavedFrameSelfHosted::Exclude);
+    JS::SavedFrameResult result = JS::GetSavedFrameLine(
+        cx, principals, frame, &line, JS::SavedFrameSelfHosted::Exclude);
     CHECK(result == JS::SavedFrameResult::Ok);
     CHECK_EQUAL(line, expected[i].line);
 
     // Column
     uint32_t column = 123;
     result = JS::GetSavedFrameColumn(cx, principals, frame, &column,
                                      JS::SavedFrameSelfHosted::Exclude);
     CHECK(result == JS::SavedFrameResult::Ok);
     CHECK_EQUAL(column, expected[i].column);
 
     // Source
     JS::RootedString str(cx);
-    result = JS::GetSavedFrameSource(cx, principals, frame, &str, JS::SavedFrameSelfHosted::Exclude);
+    result = JS::GetSavedFrameSource(cx, principals, frame, &str,
+                                     JS::SavedFrameSelfHosted::Exclude);
     CHECK(result == JS::SavedFrameResult::Ok);
     JSLinearString* linear = str->ensureLinear(cx);
     CHECK(linear);
     CHECK(js::StringEqualsAscii(linear, expected[i].source));
 
     // Function display name
-    result = JS::GetSavedFrameFunctionDisplayName(cx, principals, frame, &str,
-                                                  JS::SavedFrameSelfHosted::Exclude);
+    result = JS::GetSavedFrameFunctionDisplayName(
+        cx, principals, frame, &str, JS::SavedFrameSelfHosted::Exclude);
     CHECK(result == JS::SavedFrameResult::Ok);
     if (auto expectedName = expected[i].functionDisplayName) {
       CHECK(str);
       linear = str->ensureLinear(cx);
       CHECK(linear);
       CHECK(js::StringEqualsAscii(linear, expectedName));
     } else {
       CHECK(!str);
--- a/js/src/jsapi-tests/testScriptObject.cpp
+++ b/js/src/jsapi-tests/testScriptObject.cpp
@@ -3,17 +3,17 @@
  */
 /* 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 "mozilla/Utf8.h"  // mozilla::Utf8Unit
 
 #include "js/CompilationAndEvaluation.h"  // JS::Compile{,DontInflate,Utf8{FileDontInflate,Path}}
-#include "js/SourceText.h"                // JS::Source{Ownership,Text}
+#include "js/SourceText.h"  // JS::Source{Ownership,Text}
 #include "jsapi-tests/tests.h"
 
 struct ScriptObjectFixture : public JSAPITest {
   static const int code_size;
   static const char code[];
   static char16_t uc_code[];
 
   ScriptObjectFixture() {
--- a/js/src/jsapi-tests/testXDR.cpp
+++ b/js/src/jsapi-tests/testXDR.cpp
@@ -7,17 +7,17 @@
 #include "mozilla/ArrayUtils.h"  // mozilla::ArrayLength
 #include "mozilla/Utf8.h"        // mozilla::Utf8Unit
 
 #include "jsfriendapi.h"
 
 #include "builtin/String.h"
 #include "js/BuildId.h"  // JS::BuildIdCharVector, JS::SetProcessBuildIdOp
 #include "js/CompilationAndEvaluation.h"  // JS::CompileDontInflate
-#include "js/SourceText.h"  // JS::Source{Ownership,Text}
+#include "js/SourceText.h"                // JS::Source{Ownership,Text}
 #include "js/Transcoding.h"
 #include "jsapi-tests/tests.h"
 #include "vm/JSScript.h"
 
 #include "vm/JSScript-inl.h"
 
 static bool GetBuildId(JS::BuildIdCharVector* buildId) {
   const char buildid[] = "testXDR";
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -979,20 +979,19 @@ static bool EnumerateStandardClasses(JSC
   if (!EnumerateStandardClassesInTable(
           cx, global, properties, builtin_property_names, includeResolved)) {
     return false;
   }
 
   return true;
 }
 
-JS_PUBLIC_API bool JS_NewEnumerateStandardClasses(JSContext* cx,
-                                                  JS::HandleObject obj,
-                                                  JS::MutableHandleIdVector properties,
-                                                  bool enumerableOnly) {
+JS_PUBLIC_API bool JS_NewEnumerateStandardClasses(
+    JSContext* cx, JS::HandleObject obj, JS::MutableHandleIdVector properties,
+    bool enumerableOnly) {
   return EnumerateStandardClasses(cx, obj, properties, enumerableOnly, false);
 }
 
 JS_PUBLIC_API bool JS_NewEnumerateStandardClassesIncludingResolved(
     JSContext* cx, JS::HandleObject obj, JS::MutableHandleIdVector properties,
     bool enumerableOnly) {
   return EnumerateStandardClasses(cx, obj, properties, enumerableOnly, true);
 }
@@ -4987,19 +4986,17 @@ JS_PUBLIC_API void JS_SetPendingExceptio
   }
 }
 
 JS_PUBLIC_API void JS_ClearPendingException(JSContext* cx) {
   AssertHeapIsIdle();
   cx->clearPendingException();
 }
 
-JS_PUBLIC_API JSObject*
-JS::GetPendingExceptionStack(JSContext* cx)
-{
+JS_PUBLIC_API JSObject* JS::GetPendingExceptionStack(JSContext* cx) {
   AssertHeapIsIdle();
   CHECK_THREAD(cx);
   return cx->getPendingExceptionStack();
 }
 
 JS::AutoSaveExceptionState::AutoSaveExceptionState(JSContext* cx)
     : context(cx),
       wasPropagatingForcedReturn(cx->propagatingForcedReturn_),
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -2776,30 +2776,30 @@ extern JS_PUBLIC_API bool SetForEach(JSC
 
 extern JS_PUBLIC_API bool JS_IsExceptionPending(JSContext* cx);
 
 extern JS_PUBLIC_API bool JS_GetPendingException(JSContext* cx,
                                                  JS::MutableHandleValue vp);
 
 namespace JS {
 
-enum class ExceptionStackBehavior: bool {
+enum class ExceptionStackBehavior : bool {
   // Do not capture any stack.
   DoNotCapture,
 
   // Capture the current JS stack when setting the exception. It may be
   // retrieved by JS::GetPendingExceptionStack.
   Capture
 };
 
-} // namespace JS
-
-extern JS_PUBLIC_API void JS_SetPendingException(JSContext* cx,
-                                                 JS::HandleValue v,
-                                                 JS::ExceptionStackBehavior behavior = JS::ExceptionStackBehavior::Capture);
+}  // namespace JS
+
+extern JS_PUBLIC_API void JS_SetPendingException(
+    JSContext* cx, JS::HandleValue v,
+    JS::ExceptionStackBehavior behavior = JS::ExceptionStackBehavior::Capture);
 
 extern JS_PUBLIC_API void JS_ClearPendingException(JSContext* cx);
 
 namespace JS {
 
 /**
  * Save and later restore the current exception state of a given JSContext.
  * This is useful for implementing behavior in C++ that's like try/catch
--- a/js/src/jsfriendapi.h
+++ b/js/src/jsfriendapi.h
@@ -955,17 +955,18 @@ inline void CopyFlatStringChars(char16_t
  *     JSITER_SYMBOLSONLY - Exclude non-symbol property keys.
  *
  * This is the closest C++ API we have to `Reflect.ownKeys(obj)`, or
  * equivalently, the ES6 [[OwnPropertyKeys]] internal method. Pass
  * `JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS` as flags to get
  * results that match the output of Reflect.ownKeys.
  */
 JS_FRIEND_API bool GetPropertyKeys(JSContext* cx, JS::HandleObject obj,
-                                   unsigned flags, JS::MutableHandleIdVector props);
+                                   unsigned flags,
+                                   JS::MutableHandleIdVector props);
 
 JS_FRIEND_API bool AppendUnique(JSContext* cx, JS::MutableHandleIdVector base,
                                 JS::HandleIdVector others);
 
 /**
  * Determine whether the given string is an array index in the sense of
  * <https://tc39.github.io/ecma262/#array-index>.
  *
--- a/js/src/proxy/BaseProxyHandler.cpp
+++ b/js/src/proxy/BaseProxyHandler.cpp
@@ -223,19 +223,18 @@ bool js::SetPropertyIgnoringNamedGetter(
   }
   RootedValue setterValue(cx, ObjectValue(*setter));
   if (!CallSetter(cx, receiver, setterValue, v)) {
     return false;
   }
   return result.succeed();
 }
 
-bool BaseProxyHandler::getOwnEnumerablePropertyKeys(JSContext* cx,
-                                                    HandleObject proxy,
-                                                    MutableHandleIdVector props) const {
+bool BaseProxyHandler::getOwnEnumerablePropertyKeys(
+    JSContext* cx, HandleObject proxy, MutableHandleIdVector props) const {
   assertEnteredPolicy(cx, proxy, JSID_VOID, ENUMERATE);
   MOZ_ASSERT(props.length() == 0);
 
   if (!ownPropertyKeys(cx, proxy, props)) {
     return false;
   }
 
   /* Select only the enumerable properties through in-place iteration. */
--- a/js/src/proxy/CrossCompartmentWrapper.cpp
+++ b/js/src/proxy/CrossCompartmentWrapper.cpp
@@ -55,19 +55,18 @@ bool CrossCompartmentWrapper::defineProp
                                              HandleObject wrapper, HandleId id,
                                              Handle<PropertyDescriptor> desc,
                                              ObjectOpResult& result) const {
   Rooted<PropertyDescriptor> desc2(cx, desc);
   PIERCE(cx, wrapper, MarkAtoms(cx, id) && cx->compartment()->wrap(cx, &desc2),
          Wrapper::defineProperty(cx, wrapper, id, desc2, result), NOTHING);
 }
 
-bool CrossCompartmentWrapper::ownPropertyKeys(JSContext* cx,
-                                              HandleObject wrapper,
-                                              MutableHandleIdVector props) const {
+bool CrossCompartmentWrapper::ownPropertyKeys(
+    JSContext* cx, HandleObject wrapper, MutableHandleIdVector props) const {
   PIERCE(cx, wrapper, NOTHING, Wrapper::ownPropertyKeys(cx, wrapper, props),
          MarkAtoms(cx, props));
 }
 
 bool CrossCompartmentWrapper::delete_(JSContext* cx, HandleObject wrapper,
                                       HandleId id,
                                       ObjectOpResult& result) const {
   PIERCE(cx, wrapper, MarkAtoms(cx, id),
--- a/js/src/proxy/OpaqueCrossCompartmentWrapper.cpp
+++ b/js/src/proxy/OpaqueCrossCompartmentWrapper.cpp
@@ -18,30 +18,29 @@ bool OpaqueCrossCompartmentWrapper::getO
 }
 
 bool OpaqueCrossCompartmentWrapper::defineProperty(
     JSContext* cx, HandleObject wrapper, HandleId id,
     Handle<PropertyDescriptor> desc, ObjectOpResult& result) const {
   return result.succeed();
 }
 
-bool OpaqueCrossCompartmentWrapper::ownPropertyKeys(JSContext* cx,
-                                                    HandleObject wrapper,
-                                                    MutableHandleIdVector props) const {
+bool OpaqueCrossCompartmentWrapper::ownPropertyKeys(
+    JSContext* cx, HandleObject wrapper, MutableHandleIdVector props) const {
   return true;
 }
 
 bool OpaqueCrossCompartmentWrapper::delete_(JSContext* cx, HandleObject wrapper,
                                             HandleId id,
                                             ObjectOpResult& result) const {
   return result.succeed();
 }
 
-bool OpaqueCrossCompartmentWrapper::enumerate(JSContext* cx, HandleObject proxy,
-                                              MutableHandleIdVector props) const {
+bool OpaqueCrossCompartmentWrapper::enumerate(
+    JSContext* cx, HandleObject proxy, MutableHandleIdVector props) const {
   return BaseProxyHandler::enumerate(cx, proxy, props);
 }
 
 bool OpaqueCrossCompartmentWrapper::getPrototype(
     JSContext* cx, HandleObject proxy, MutableHandleObject protop) const {
   protop.set(nullptr);
   return true;
 }
--- a/js/src/proxy/Proxy.cpp
+++ b/js/src/proxy/Proxy.cpp
@@ -438,17 +438,18 @@ bool Proxy::getOwnEnumerablePropertyKeys
   AutoEnterPolicy policy(cx, handler, proxy, JSID_VOIDHANDLE,
                          BaseProxyHandler::ENUMERATE, true);
   if (!policy.allowed()) {
     return policy.returnValue();
   }
   return handler->getOwnEnumerablePropertyKeys(cx, proxy, props);
 }
 
-bool Proxy::enumerate(JSContext* cx, HandleObject proxy, MutableHandleIdVector props) {
+bool Proxy::enumerate(JSContext* cx, HandleObject proxy,
+                      MutableHandleIdVector props) {
   if (!CheckRecursionLimit(cx)) {
     return false;
   }
 
   const BaseProxyHandler* handler = proxy->as<ProxyObject>().handler();
   if (handler->hasPrototype()) {
     if (!Proxy::getOwnEnumerablePropertyKeys(cx, proxy, props)) {
       return false;
--- a/js/src/proxy/Proxy.h
+++ b/js/src/proxy/Proxy.h
@@ -31,17 +31,18 @@ class Proxy {
       MutableHandle<JS::PropertyDescriptor> desc);
   static bool defineProperty(JSContext* cx, HandleObject proxy, HandleId id,
                              Handle<JS::PropertyDescriptor> desc,
                              ObjectOpResult& result);
   static bool ownPropertyKeys(JSContext* cx, HandleObject proxy,
                               MutableHandleIdVector props);
   static bool delete_(JSContext* cx, HandleObject proxy, HandleId id,
                       ObjectOpResult& result);
-  static bool enumerate(JSContext* cx, HandleObject proxy, MutableHandleIdVector props);
+  static bool enumerate(JSContext* cx, HandleObject proxy,
+                        MutableHandleIdVector props);
   static bool isExtensible(JSContext* cx, HandleObject proxy, bool* extensible);
   static bool preventExtensions(JSContext* cx, HandleObject proxy,
                                 ObjectOpResult& result);
   static bool getPrototype(JSContext* cx, HandleObject proxy,
                            MutableHandleObject protop);
   static bool setPrototype(JSContext* cx, HandleObject proxy,
                            HandleObject proto, ObjectOpResult& result);
   static bool getPrototypeIfOrdinary(JSContext* cx, HandleObject proxy,
--- a/js/src/proxy/Wrapper.cpp
+++ b/js/src/proxy/Wrapper.cpp
@@ -54,18 +54,18 @@ bool ForwardingProxyHandler::definePrope
                                             HandleId id,
                                             Handle<PropertyDescriptor> desc,
                                             ObjectOpResult& result) const {
   assertEnteredPolicy(cx, proxy, id, SET);
   RootedObject target(cx, proxy->as<ProxyObject>().target());
   return DefineProperty(cx, target, id, desc, result);
 }
 
-bool ForwardingProxyHandler::ownPropertyKeys(JSContext* cx, HandleObject proxy,
-                                             MutableHandleIdVector props) const {
+bool ForwardingProxyHandler::ownPropertyKeys(
+    JSContext* cx, HandleObject proxy, MutableHandleIdVector props) const {
   assertEnteredPolicy(cx, proxy, JSID_VOID, ENUMERATE);
   RootedObject target(cx, proxy->as<ProxyObject>().target());
   return GetPropertyKeys(
       cx, target, JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS, props);
 }
 
 bool ForwardingProxyHandler::delete_(JSContext* cx, HandleObject proxy,
                                      HandleId id,
--- a/js/src/util/StringBuffer.h
+++ b/js/src/util/StringBuffer.h
@@ -273,18 +273,17 @@ class StringBuffer {
    * exactly the characters in this buffer (inflated to TwoByte), it is *not*
    * null-terminated unless the last appended character was '\0'.
    */
   char16_t* stealChars();
 };
 
 class JSStringBuilder : public StringBuffer {
  public:
-  explicit JSStringBuilder(JSContext* cx)
-      : StringBuffer(cx) {}
+  explicit JSStringBuilder(JSContext* cx) : StringBuffer(cx) {}
 
   /*
    * Creates a string from the characters in this buffer, then (regardless
    * whether string creation succeeded or failed) empties the buffer.
    */
   JSFlatString* finishString();
 };
 
--- a/js/src/vm/EnvironmentObject.h
+++ b/js/src/vm/EnvironmentObject.h
@@ -433,17 +433,18 @@ class ModuleEnvironmentObject : public E
                           HandleValue v, HandleValue receiver,
                           JS::ObjectOpResult& result);
   static bool getOwnPropertyDescriptor(JSContext* cx, HandleObject obj,
                                        HandleId id,
                                        MutableHandle<PropertyDescriptor> desc);
   static bool deleteProperty(JSContext* cx, HandleObject obj, HandleId id,
                              ObjectOpResult& result);
   static bool newEnumerate(JSContext* cx, HandleObject obj,
-                           MutableHandleIdVector properties, bool enumerableOnly);
+                           MutableHandleIdVector properties,
+                           bool enumerableOnly);
 };
 
 typedef Rooted<ModuleEnvironmentObject*> RootedModuleEnvironmentObject;
 typedef Handle<ModuleEnvironmentObject*> HandleModuleEnvironmentObject;
 typedef MutableHandle<ModuleEnvironmentObject*>
     MutableHandleModuleEnvironmentObject;
 
 class WasmInstanceEnvironmentObject : public EnvironmentObject {
--- a/js/src/vm/ForOfIterator.cpp
+++ b/js/src/vm/ForOfIterator.cpp
@@ -158,17 +158,18 @@ bool ForOfIterator::next(MutableHandleVa
 // ES 2017 draft 0f10dba4ad18de92d47d421f378233a2eae8f077 7.4.6.
 // When completion.[[Type]] is throw.
 void ForOfIterator::closeThrow() {
   MOZ_ASSERT(iterator);
 
   RootedValue completionException(cx_);
   RootedSavedFrame completionExceptionStack(cx_);
   if (cx_->isExceptionPending()) {
-    if (!GetAndClearExceptionAndStack(cx_, &completionException, &completionExceptionStack)) {
+    if (!GetAndClearExceptionAndStack(cx_, &completionException,
+                                      &completionExceptionStack)) {
       completionException.setUndefined();
       completionExceptionStack = nullptr;
     }
   }
 
   // Steps 1-2 (implicit)
 
   // Step 3 (partial).
--- a/js/src/vm/Interpreter.h
+++ b/js/src/vm/Interpreter.h
@@ -542,17 +542,18 @@ JSObject* SingletonObjectLiteralOperatio
 JSObject* ImportMetaOperation(JSContext* cx, HandleScript script);
 
 JSObject* BuiltinProtoOperation(JSContext* cx, jsbytecode* pc);
 
 bool ThrowMsgOperation(JSContext* cx, const unsigned errorNum);
 
 bool GetAndClearException(JSContext* cx, MutableHandleValue res);
 
-bool GetAndClearExceptionAndStack(JSContext* cx, MutableHandleValue res, MutableHandleSavedFrame stack);
+bool GetAndClearExceptionAndStack(JSContext* cx, MutableHandleValue res,
+                                  MutableHandleSavedFrame stack);
 
 bool DeleteNameOperation(JSContext* cx, HandlePropertyName name,
                          HandleObject scopeObj, MutableHandleValue res);
 
 bool ImplicitThisOperation(JSContext* cx, HandleObject scopeObj,
                            HandlePropertyName name, MutableHandleValue res);
 
 bool InitPropGetterSetterOperation(JSContext* cx, jsbytecode* pc,
--- a/js/src/vm/Iteration.cpp
+++ b/js/src/vm/Iteration.cpp
@@ -538,17 +538,18 @@ static bool Snapshot(JSContext* cx, Hand
   }
 
 #endif /* JS_MORE_DETERMINISTIC */
 
   return true;
 }
 
 JS_FRIEND_API bool js::GetPropertyKeys(JSContext* cx, HandleObject obj,
-                                       unsigned flags, MutableHandleIdVector props) {
+                                       unsigned flags,
+                                       MutableHandleIdVector props) {
   return Snapshot(cx, obj,
                   flags & (JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS |
                            JSITER_SYMBOLSONLY),
                   props);
 }
 
 static inline void RegisterEnumerator(ObjectRealm& realm, NativeIterator* ni) {
   // Register non-escaping native enumerators (for-in) with the current
@@ -587,18 +588,18 @@ static PropertyIteratorObject* NewProper
   // inside the nursery when deciding whether a barrier is necessary.
   MOZ_ASSERT(!js::gc::IsInsideNursery(res));
 
   MOZ_ASSERT(res->numFixedSlots() == PropertyIteratorObject::NUM_FIXED_SLOTS);
   return res;
 }
 
 static PropertyIteratorObject* CreatePropertyIterator(
-    JSContext* cx, Handle<JSObject*> objBeingIterated,
-    HandleIdVector props, uint32_t numGuards, uint32_t guardKey) {
+    JSContext* cx, Handle<JSObject*> objBeingIterated, HandleIdVector props,
+    uint32_t numGuards, uint32_t guardKey) {
   Rooted<PropertyIteratorObject*> propIter(cx, NewPropertyIteratorObject(cx));
   if (!propIter) {
     return nullptr;
   }
 
   static_assert(sizeof(ReceiverGuard) == 2 * sizeof(GCPtrFlatString),
                 "NativeIterators are allocated in space for 1) themselves, "
                 "2) the properties a NativeIterator iterates (as "
--- a/js/src/vm/JSContext-inl.h
+++ b/js/src/vm/JSContext-inl.h
@@ -297,17 +297,18 @@ inline js::LifoAlloc& JSContext::typeLif
 }
 
 inline js::Nursery& JSContext::nursery() { return runtime()->gc.nursery(); }
 
 inline void JSContext::minorGC(JS::GCReason reason) {
   runtime()->gc.minorGC(reason);
 }
 
-inline void JSContext::setPendingException(JS::HandleValue v, js::HandleSavedFrame stack) {
+inline void JSContext::setPendingException(JS::HandleValue v,
+                                           js::HandleSavedFrame stack) {
 #if defined(NIGHTLY_BUILD)
   do {
     // Do not intercept exceptions if we are already
     // in the exception interceptor. That would lead
     // to infinite recursion.
     if (this->runtime()->errorInterception.isExecuting) {
       break;
     }
--- a/js/src/vm/JSContext.cpp
+++ b/js/src/vm/JSContext.cpp
@@ -1347,17 +1347,19 @@ void JSContext::setRuntime(JSRuntime* rt
 
   runtime_ = rt;
 }
 
 static const size_t MAX_REPORTED_STACK_DEPTH = 1u << 7;
 
 void JSContext::setPendingExceptionAndCaptureStack(HandleValue value) {
   RootedObject stack(this);
-  if (!CaptureCurrentStack(this, &stack, JS::StackCapture(JS::MaxFrames(MAX_REPORTED_STACK_DEPTH)))) {
+  if (!CaptureCurrentStack(
+          this, &stack,
+          JS::StackCapture(JS::MaxFrames(MAX_REPORTED_STACK_DEPTH)))) {
     clearPendingException();
   }
 
   RootedSavedFrame nstack(this);
   if (stack) {
     nstack = &stack->as<SavedFrame>();
   }
   setPendingException(value, nstack);
--- a/js/src/vm/StructuredClone.cpp
+++ b/js/src/vm/StructuredClone.cpp
@@ -1324,18 +1324,18 @@ bool JSStructuredCloneWriter::startObjec
                               JSMSG_NEED_DIET, "object graph to serialize");
     return false;
   }
 
   return true;
 }
 
 static bool TryAppendNativeProperties(JSContext* cx, HandleObject obj,
-                                      MutableHandleIdVector entries, size_t* properties,
-                                      bool* optimized) {
+                                      MutableHandleIdVector entries,
+                                      size_t* properties, bool* optimized) {
   *optimized = false;
 
   if (!obj->isNative()) {
     return true;
   }
 
   HandleNativeObject nobj = obj.as<NativeObject>();
   if (nobj->isIndexed() || nobj->is<TypedArrayObject>() ||
--- a/js/src/wasm/WasmJS.cpp
+++ b/js/src/wasm/WasmJS.cpp
@@ -236,17 +236,17 @@ static bool GetProperty(JSContext* cx, H
     return false;
   }
 
   RootedId id(cx, AtomToId(atom));
   return GetProperty(cx, obj, obj, id, v);
 }
 
 bool js::wasm::GetImports(JSContext* cx, const Module& module,
-                       HandleObject importObj, ImportValues* imports) {
+                          HandleObject importObj, ImportValues* imports) {
   if (!module.imports().empty() && !importObj) {
     return ThrowBadImportArg(cx);
   }
 
   const Metadata& metadata = module.metadata();
 
   uint32_t globalIndex = 0;
   const GlobalDescVector& globals = metadata.globals;
--- a/js/xpconnect/public/xpc_make_class.h
+++ b/js/xpconnect/public/xpc_make_class.h
@@ -25,17 +25,18 @@ bool XPC_WN_MaybeResolvingDeleteProperty
 bool XPC_WN_CannotDeletePropertyStub(JSContext* cx, JS::HandleObject obj,
                                      JS::HandleId id,
                                      JS::ObjectOpResult& result);
 
 bool XPC_WN_Helper_Enumerate(JSContext* cx, JS::HandleObject obj);
 bool XPC_WN_Shared_Enumerate(JSContext* cx, JS::HandleObject obj);
 
 bool XPC_WN_NewEnumerate(JSContext* cx, JS::HandleObject obj,
-                         JS::MutableHandleIdVector properties, bool enumerableOnly);
+                         JS::MutableHandleIdVector properties,
+                         bool enumerableOnly);
 
 bool XPC_WN_Helper_Resolve(JSContext* cx, JS::HandleObject obj, JS::HandleId id,
                            bool* resolvedp);
 
 void XPC_WN_Helper_Finalize(js::FreeOp* fop, JSObject* obj);
 void XPC_WN_NoHelper_Finalize(js::FreeOp* fop, JSObject* obj);
 
 bool XPC_WN_Helper_Call(JSContext* cx, unsigned argc, JS::Value* vp);
--- a/js/xpconnect/src/Sandbox.cpp
+++ b/js/xpconnect/src/Sandbox.cpp
@@ -790,17 +790,18 @@ bool SandboxProxyHandler::get(JSContext*
 bool SandboxProxyHandler::set(JSContext* cx, JS::Handle<JSObject*> proxy,
                               JS::Handle<jsid> id, JS::Handle<Value> v,
                               JS::Handle<Value> receiver,
                               JS::ObjectOpResult& result) const {
   return BaseProxyHandler::set(cx, proxy, id, v, receiver, result);
 }
 
 bool SandboxProxyHandler::getOwnEnumerablePropertyKeys(
-    JSContext* cx, JS::Handle<JSObject*> proxy, MutableHandleIdVector props) const {
+    JSContext* cx, JS::Handle<JSObject*> proxy,
+    MutableHandleIdVector props) const {
   return BaseProxyHandler::getOwnEnumerablePropertyKeys(cx, proxy, props);
 }
 
 bool SandboxProxyHandler::enumerate(JSContext* cx, JS::Handle<JSObject*> proxy,
                                     JS::MutableHandleIdVector props) const {
   return BaseProxyHandler::enumerate(cx, proxy, props);
 }
 
--- a/js/xpconnect/src/XPCComponents.cpp
+++ b/js/xpconnect/src/XPCComponents.cpp
@@ -1342,17 +1342,18 @@ nsXPCComponents_Utils::ReportError(Handl
   RootedObject errorObj(cx, error.isObject() ? &error.toObject() : nullptr);
   JSErrorReport* err = errorObj ? JS_ErrorFromException(cx, errorObj) : nullptr;
 
   nsCOMPtr<nsIScriptError> scripterr;
 
   if (errorObj) {
     JS::RootedObject stackVal(cx);
     JS::RootedObject stackGlobal(cx);
-    FindExceptionStackForConsoleReport(win, error, nullptr, &stackVal, &stackGlobal);
+    FindExceptionStackForConsoleReport(win, error, nullptr, &stackVal,
+                                       &stackGlobal);
     if (stackVal) {
       scripterr = new nsScriptErrorWithStack(stackVal, stackGlobal);
     }
   }
 
   nsString fileName;
   uint32_t lineNo = 0;
 
--- a/js/xpconnect/src/XPCRuntimeService.cpp
+++ b/js/xpconnect/src/XPCRuntimeService.cpp
@@ -56,17 +56,18 @@ BackstagePass::Resolve(nsIXPConnectWrapp
   JS::RootedId id(cx, idArg);
   *_retval =
       WebIDLGlobalNameHash::ResolveForSystemGlobal(cx, obj, id, resolvedp);
   return *_retval ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 BackstagePass::NewEnumerate(nsIXPConnectWrappedNative* wrapper, JSContext* cx,
-                            JSObject* objArg, JS::MutableHandleIdVector properties,
+                            JSObject* objArg,
+                            JS::MutableHandleIdVector properties,
                             bool enumerableOnly, bool* _retval) {
   JS::RootedObject obj(cx, objArg);
   *_retval = WebIDLGlobalNameHash::NewEnumerateSystemGlobal(cx, obj, properties,
                                                             enumerableOnly);
   return *_retval ? NS_OK : NS_ERROR_FAILURE;
 }
 
 /***************************************************************************/
--- a/js/xpconnect/src/XPCWrappedNativeJSOps.cpp
+++ b/js/xpconnect/src/XPCWrappedNativeJSOps.cpp
@@ -845,17 +845,18 @@ bool XPC_WN_Helper_Enumerate(JSContext* 
     return Throw(rv, cx);
   }
   return retval;
 }
 
 /***************************************************************************/
 
 bool XPC_WN_NewEnumerate(JSContext* cx, HandleObject obj,
-                         MutableHandleIdVector properties, bool enumerableOnly) {
+                         MutableHandleIdVector properties,
+                         bool enumerableOnly) {
   XPCCallContext ccx(cx, obj);
   XPCWrappedNative* wrapper = ccx.GetWrapper();
   THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper);
 
   nsCOMPtr<nsIXPCScriptable> scr = wrapper->GetScriptable();
   if (!scr || !scr->WantNewEnumerate()) {
     return Throw(NS_ERROR_XPC_BAD_OP_ON_WN_PROTO, cx);
   }
--- a/js/xpconnect/wrappers/FilteringWrapper.cpp
+++ b/js/xpconnect/wrappers/FilteringWrapper.cpp
@@ -71,17 +71,18 @@ bool AppendCrossOriginWhitelistedPropNam
   for (auto code : sCrossOriginWhitelistedSymbolCodes) {
     props.infallibleAppend(SYMBOL_TO_JSID(JS::GetWellKnownSymbol(cx, code)));
   }
 
   return true;
 }
 
 template <typename Policy>
-static bool Filter(JSContext* cx, HandleObject wrapper, MutableHandleIdVector props) {
+static bool Filter(JSContext* cx, HandleObject wrapper,
+                   MutableHandleIdVector props) {
   size_t w = 0;
   RootedId id(cx);
   for (size_t n = 0; n < props.length(); ++n) {
     id = props[n];
     if (Policy::check(cx, wrapper, id, Wrapper::GET) ||
         Policy::check(cx, wrapper, id, Wrapper::SET)) {
       props[w++].set(id);
     } else if (JS_IsExceptionPending(cx)) {
@@ -157,19 +158,19 @@ template <typename Base, typename Policy
 bool FilteringWrapper<Base, Policy>::getOwnEnumerablePropertyKeys(
     JSContext* cx, HandleObject wrapper, MutableHandleIdVector props) const {
   assertEnteredPolicy(cx, wrapper, JSID_VOID, BaseProxyHandler::ENUMERATE);
   return Base::getOwnEnumerablePropertyKeys(cx, wrapper, props) &&
          Filter<Policy>(cx, wrapper, props);
 }
 
 template <typename Base, typename Policy>
-bool FilteringWrapper<Base, Policy>::enumerate(JSContext* cx,
-                                               HandleObject wrapper,
-                                               JS::MutableHandleIdVector props) const {
+bool FilteringWrapper<Base, Policy>::enumerate(
+    JSContext* cx, HandleObject wrapper,
+    JS::MutableHandleIdVector props) const {
   assertEnteredPolicy(cx, wrapper, JSID_VOID, BaseProxyHandler::ENUMERATE);
   // Trigger the default proxy enumerate trap, which will use
   // js::GetPropertyKeys for the list of (censored) ids.
   return js::BaseProxyHandler::enumerate(cx, wrapper, props);
 }
 
 template <typename Base, typename Policy>
 bool FilteringWrapper<Base, Policy>::call(JSContext* cx,
--- a/js/xpconnect/wrappers/XrayWrapper.cpp
+++ b/js/xpconnect/wrappers/XrayWrapper.cpp
@@ -1708,17 +1708,18 @@ bool DOMXrayTraits::defineProperty(JSCon
     }
   }
 
   JS::Rooted<JSObject*> obj(cx, getTargetObject(wrapper));
   return XrayDefineProperty(cx, wrapper, obj, id, desc, result, defined);
 }
 
 bool DOMXrayTraits::enumerateNames(JSContext* cx, HandleObject wrapper,
-                                   unsigned flags, MutableHandleIdVector props) {
+                                   unsigned flags,
+                                   MutableHandleIdVector props) {
   // Put the indexed properties for a window first.
   nsGlobalWindowInner* win = AsWindow(cx, wrapper);
   if (win) {
     uint32_t length = win->Length();
     if (!props.reserve(props.length() + length)) {
       return false;
     }
     JS::RootedId indexId(cx);
@@ -2027,19 +2028,18 @@ bool XrayWrapper<Base, Traits>::definePr
   if (!RecreateLostWaivers(cx, desc.address(), &wrappedDesc)) {
     return false;
   }
 
   return JS_DefinePropertyById(cx, expandoObject, id, wrappedDesc, result);
 }
 
 template <typename Base, typename Traits>
-bool XrayWrapper<Base, Traits>::ownPropertyKeys(JSContext* cx,
-                                                HandleObject wrapper,
-                                                MutableHandleIdVector props) const {
+bool XrayWrapper<Base, Traits>::ownPropertyKeys(
+    JSContext* cx, HandleObject wrapper, MutableHandleIdVector props) const {
   assertEnteredPolicy(cx, wrapper, JSID_VOID, BaseProxyHandler::ENUMERATE);
   return getPropertyKeys(
       cx, wrapper, JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS, props);
 }
 
 template <typename Base, typename Traits>
 bool XrayWrapper<Base, Traits>::delete_(JSContext* cx, HandleObject wrapper,
                                         HandleId id,
@@ -2129,18 +2129,19 @@ bool XrayWrapper<Base, Traits>::hasOwn(J
 template <typename Base, typename Traits>
 bool XrayWrapper<Base, Traits>::getOwnEnumerablePropertyKeys(
     JSContext* cx, HandleObject wrapper, MutableHandleIdVector props) const {
   // Skip our Base if it isn't already ProxyHandler.
   return js::BaseProxyHandler::getOwnEnumerablePropertyKeys(cx, wrapper, props);
 }
 
 template <typename Base, typename Traits>
-bool XrayWrapper<Base, Traits>::enumerate(JSContext* cx, HandleObject wrapper,
-                                          JS::MutableHandleIdVector props) const {
+bool XrayWrapper<Base, Traits>::enumerate(
+    JSContext* cx, HandleObject wrapper,
+    JS::MutableHandleIdVector props) const {
   MOZ_CRASH("Shouldn't be called: we return true for hasPrototype()");
 }
 
 template <typename Base, typename Traits>
 bool XrayWrapper<Base, Traits>::call(JSContext* cx, HandleObject wrapper,
                                      const JS::CallArgs& args) const {
   assertEnteredPolicy(cx, wrapper, JSID_VOID, BaseProxyHandler::CALL);
   // Hard cast the singleton since SecurityWrapper doesn't have one.
@@ -2287,20 +2288,19 @@ bool XrayWrapper<Base, Traits>::setImmut
   // Xray's [[Prototype]] immutable.  We can revisit this (or maybe give all
   // Xrays immutable [[Prototype]], because who does this, really?) later if
   // necessary.
   *succeeded = false;
   return true;
 }
 
 template <typename Base, typename Traits>
-bool XrayWrapper<Base, Traits>::getPropertyKeys(JSContext* cx,
-                                                HandleObject wrapper,
-                                                unsigned flags,
-                                                MutableHandleIdVector props) const {
+bool XrayWrapper<Base, Traits>::getPropertyKeys(
+    JSContext* cx, HandleObject wrapper, unsigned flags,
+    MutableHandleIdVector props) const {
   assertEnteredPolicy(cx, wrapper, JSID_VOID, BaseProxyHandler::ENUMERATE);
 
   // Enumerate expando properties first. Note that the expando object lives
   // in the target compartment.
   RootedObject target(cx, Traits::getTargetObject(wrapper));
   RootedObject expando(cx);
   if (!Traits::singleton.getExpandoObject(cx, target, wrapper, &expando)) {
     return false;
--- a/layout/base/nsCounterManager.h
+++ b/layout/base/nsCounterManager.h
@@ -113,22 +113,22 @@ struct nsCounterChangeNode : public nsCo
   // the naming convention here.
   // |aPropIndex| is the index of the value within the list in the
   // 'counter-increment', 'counter-reset' or 'counter-set' property.
   nsCounterChangeNode(nsIFrame* aPseudoFrame, nsCounterNode::Type aChangeType,
                       int32_t aChangeValue,
                       int32_t aPropIndex)
       : nsCounterNode(  // Fake a content index for resets, increments and sets
                         // that comes before all the real content, with
-                        // the resets first, in order, and then the increments and
-                        // then the sets.
-            aPropIndex + (aChangeType == RESET
-                              ? (INT32_MIN)
-                              : (aChangeType == INCREMENT ? ((INT32_MIN / 3) * 2)
-                                                          : INT32_MIN / 3)),
+                        // the resets first, in order, and then the increments
+                        // and then the sets.
+            aPropIndex + (aChangeType == RESET ? (INT32_MIN)
+                                               : (aChangeType == INCREMENT
+                                                      ? ((INT32_MIN / 3) * 2)
+                                                      : INT32_MIN / 3)),
             aChangeType),
         mChangeValue(aChangeValue) {
     NS_ASSERTION(aPropIndex >= 0, "out of range");
     NS_ASSERTION(
         aChangeType == INCREMENT || aChangeType == SET || aChangeType == RESET,
         "bad type");
     mPseudoFrame = aPseudoFrame;
     CheckFrameAssertions();
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -4694,18 +4694,19 @@ bool nsBlockFrame::DrainOverflowLines() 
     prevBlock->ClearLineCursor();
     FrameLines* overflowLines = prevBlock->RemoveOverflowLines();
     if (overflowLines) {
       // Make all the frames on the overflow line list mine.
       ReparentFrames(overflowLines->mFrames, prevBlock, this,
                      ReparentingDirection::Forwards);
 
       // Collect overflow containers from our [Excess]OverflowContainers lists
-      // that are continuations from the frames we picked up from our prev-in-flow.
-      // We'll append these to mFrames to ensure the continuations are ordered.
+      // that are continuations from the frames we picked up from our
+      // prev-in-flow. We'll append these to mFrames to ensure the continuations
+      // are ordered.
       auto HasOverflowContainers = [this]() -> bool {
         return GetPropTableFrames(OverflowContainersProperty()) ||
                GetPropTableFrames(ExcessOverflowContainersProperty());
       };
       nsFrameList ocContinuations;
       if (HasOverflowContainers()) {
         for (auto* f : overflowLines->mFrames) {
           auto* cont = f;
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -3712,18 +3712,19 @@ void ScrollFrameHelper::BuildDisplayList
     aBuilder->ForceLayerForScrollParent();
   }
 
   if (couldBuildLayer) {
     // Make sure that APZ will dispatch events back to content so we can
     // create a displayport for this frame. We'll add the item later on.
     if (!mWillBuildScrollableLayer) {
       if (aBuilder->BuildCompositorHitTestInfo()) {
-        CompositorHitTestInfo info(CompositorHitTestFlags::eVisibleToHitTest,
-                                   CompositorHitTestFlags::eInactiveScrollframe);
+        CompositorHitTestInfo info(
+            CompositorHitTestFlags::eVisibleToHitTest,
+            CompositorHitTestFlags::eInactiveScrollframe);
         // If the scroll frame has non-default overscroll-behavior, instruct
         // APZ to require a target confirmation before processing events that
         // hit this scroll frame (that is, to drop the events if a
         // confirmation does not arrive within the timeout period). Otherwise,
         // APZ's fallback behaviour of scrolling the enclosing scroll frame
         // would violate the specified overscroll-behavior.
         ScrollStyles scrollStyles = GetScrollStylesFromFrame();
         if (scrollStyles.mOverscrollBehaviorX !=
--- a/layout/generic/nsImageFrame.cpp
+++ b/layout/generic/nsImageFrame.cpp
@@ -2301,17 +2301,17 @@ Maybe<nsIFrame::Cursor> nsImageFrame::Ge
   TranslateEventCoords(aPoint, p);
   HTMLAreaElement* area = map->GetArea(p.x, p.y);
   if (!area) {
     return nsFrame::GetCursor(aPoint);
   }
 
   // Use the cursor from the style of the *area* element.
   RefPtr<ComputedStyle> areaStyle =
-    PresShell()->StyleSet()->ResolveStyleLazily(*area);
+      PresShell()->StyleSet()->ResolveStyleLazily(*area);
   StyleCursorKind kind = areaStyle->StyleUI()->mCursor;
   if (kind == StyleCursorKind::Auto) {
     kind = StyleCursorKind::Default;
   }
   return Some(Cursor{kind, AllowCustomCursorImage::Yes, std::move(areaStyle)});
 }
 
 nsresult nsImageFrame::AttributeChanged(int32_t aNameSpaceID,
--- a/layout/style/ServoStyleSet.h
+++ b/layout/style/ServoStyleSet.h
@@ -175,18 +175,17 @@ class ServoStyleSet {
 
   // Resolves style for a (possibly-pseudo) Element without assuming that the
   // style has been resolved. If the element was unstyled and a new style
   // was resolved, it is not stored in the DOM. (That is, the element remains
   // unstyled.)
   //
   // TODO(emilio): Element argument should be `const`.
   already_AddRefed<ComputedStyle> ResolveStyleLazily(
-      dom::Element&,
-      PseudoStyleType = PseudoStyleType::NotPseudo,
+      dom::Element&, PseudoStyleType = PseudoStyleType::NotPseudo,
       StyleRuleInclusion = StyleRuleInclusion::All);
 
   // Get a ComputedStyle for an anonymous box. The pseudo type must be an
   // inheriting anon box.
   already_AddRefed<ComputedStyle> ResolveInheritingAnonymousBoxStyle(
       PseudoStyleType, ComputedStyle* aParentStyle);
 
   // Get a ComputedStyle for an anonymous box. The pseudo type must be
--- a/layout/style/StyleColor.cpp
+++ b/layout/style/StyleColor.cpp
@@ -65,18 +65,18 @@ nscolor StyleColor::CalcColor(const Styl
   if (IsNumeric()) {
     return AsNumeric().ToColor();
   }
   if (IsCurrentColor()) {
     return aForegroundColor.ToColor();
   }
   MOZ_ASSERT(IsComplex());
   const auto& complex = AsComplex();
-  return LinearBlendColors(complex.color, complex.ratios.bg,
-                           aForegroundColor, complex.ratios.fg);
+  return LinearBlendColors(complex.color, complex.ratios.bg, aForegroundColor,
+                           complex.ratios.fg);
 }
 
 template <>
 nscolor StyleColor::CalcColor(const ComputedStyle& aStyle) const {
   // Common case that is numeric color, which is pure background, we
   // can skip resolving StyleColor().
   // TODO(djg): Is this optimization worth it?
   if (IsNumeric()) {
--- a/layout/style/nsStyleStruct.cpp
+++ b/layout/style/nsStyleStruct.cpp
@@ -1693,18 +1693,18 @@ nsChangeHint nsStyleTableBorder::CalcDif
   }
 }
 
 // --------------------
 // nsStyleColor
 //
 
 static StyleRGBA DefaultColor(const Document& aDocument) {
-  return
-    StyleRGBA::FromColor(PreferenceSheet::PrefsFor(aDocument).mDefaultColor);
+  return StyleRGBA::FromColor(
+      PreferenceSheet::PrefsFor(aDocument).mDefaultColor);
 }
 
 nsStyleColor::nsStyleColor(const Document& aDocument)
     : mColor(DefaultColor(aDocument)) {
   MOZ_COUNT_CTOR(nsStyleColor);
 }
 
 nsStyleColor::nsStyleColor(const nsStyleColor& aSource)
--- a/layout/xul/nsMenuPopupFrame.cpp
+++ b/layout/xul/nsMenuPopupFrame.cpp
@@ -158,18 +158,18 @@ void nsMenuPopupFrame::Init(nsIContent* 
     mPopupType = ePopupTypeTooltip;
   }
 
   nsCOMPtr<nsIDocShellTreeItem> dsti = PresContext()->GetDocShell();
   if (dsti && dsti->ItemType() == nsIDocShellTreeItem::typeChrome) {
     mInContentShell = false;
   }
 
-  // Support incontentshell=false attribute to allow popups to be displayed outside of the
-  // content shell. Chrome only.
+  // Support incontentshell=false attribute to allow popups to be displayed
+  // outside of the content shell. Chrome only.
   if (aContent->NodePrincipal()->IsSystemPrincipal()) {
     if (aContent->AsElement()->AttrValueIs(kNameSpaceID_None,
                                            nsGkAtoms::incontentshell,
                                            nsGkAtoms::_true, eCaseMatters)) {
       mInContentShell = true;
     } else if (aContent->AsElement()->AttrValueIs(
                    kNameSpaceID_None, nsGkAtoms::incontentshell,
                    nsGkAtoms::_false, eCaseMatters)) {
--- a/memory/build/mozjemalloc.cpp
+++ b/memory/build/mozjemalloc.cpp
@@ -2428,23 +2428,23 @@ void arena_t::Purge(bool aAll) {
 
 #ifdef MALLOC_DECOMMIT
         pages_decommit((void*)(uintptr_t(chunk) + (i << gPageSize2Pow)),
                        (npages << gPageSize2Pow));
 #endif
         mStats.committed -= npages;
 
 #ifndef MALLOC_DECOMMIT
-#ifdef XP_SOLARIS
+#  ifdef XP_SOLARIS
         posix_madvise((void*)(uintptr_t(chunk) + (i << gPageSize2Pow)),
-                (npages << gPageSize2Pow), MADV_FREE);
-#else
+                      (npages << gPageSize2Pow), MADV_FREE);
+#  else
         madvise((void*)(uintptr_t(chunk) + (i << gPageSize2Pow)),
                 (npages << gPageSize2Pow), MADV_FREE);
-#endif
+#  endif
 #  ifdef MALLOC_DOUBLE_PURGE
         madvised = true;
 #  endif
 #endif
         if (mNumDirty <= (dirty_max >> 1)) {
           break;
         }
       }
--- a/netwerk/base/nsURLParsers.cpp
+++ b/netwerk/base/nsURLParsers.cpp
@@ -554,17 +554,18 @@ nsAuthURLParser::ParseServerInfo(const c
     // serverinfo = <hostname>
     SET_RESULT(hostname, 0, serverinfoLen);
     if (port) *port = -1;
   }
 
   // In case of IPv6 address check its validity
   if (*hostnameLen > 1 && *(serverinfo + *hostnamePos) == '[' &&
       *(serverinfo + *hostnamePos + *hostnameLen - 1) == ']' &&
-      !net_IsValidIPv6Addr(Substring(serverinfo + *hostnamePos + 1, *hostnameLen - 2)))
+      !net_IsValidIPv6Addr(
+          Substring(serverinfo + *hostnamePos + 1, *hostnameLen - 2)))
     return NS_ERROR_MALFORMED_URI;
 
   return NS_OK;
 }
 
 void nsAuthURLParser::ParseAfterScheme(const char *spec, int32_t specLen,
                                        uint32_t *authPos, int32_t *authLen,
                                        uint32_t *pathPos, int32_t *pathLen) {
--- a/security/manager/ssl/SSLServerCertVerification.cpp
+++ b/security/manager/ssl/SSLServerCertVerification.cpp
@@ -953,18 +953,17 @@ void GatherBaselineRequirementsTelemetry
         commonNameInSubjectAltNames |=
             TryMatchingWildcardSubjectAltName(commonName.get(), altName);
       }
       // net_IsValidHostName appears to return true for valid IP addresses,
       // which would be invalid for a DNS name.
       // Note that the net_IsValidHostName check will catch things like
       // "a.*.example.com".
       if (!net_IsValidHostName(altNameWithoutWildcard) ||
-          net_IsValidIPv4Addr(altName) ||
-          net_IsValidIPv6Addr(altName)) {
+          net_IsValidIPv4Addr(altName) || net_IsValidIPv6Addr(altName)) {
         MOZ_LOG(gPIPNSSLog, LogLevel::Debug,
                 ("BR telemetry: DNSName '%s' not valid (for '%s')\n",
                  altName.get(), commonName.get()));
         malformedDNSNameOrIPAddressPresent = true;
       }
       if (!altName.Contains('.')) {
         nonFQDNPresent = true;
       }
--- a/security/manager/ssl/nsKeygenHandler.cpp
+++ b/security/manager/ssl/nsKeygenHandler.cpp
@@ -695,18 +695,17 @@ nsresult nsKeygenFormProcessor::ProcessV
                       keyParamsValue);
 }
 
 nsresult nsKeygenFormProcessor::ProcessValueIPC(const nsAString& aOldValue,
                                                 const nsAString& aChallenge,
                                                 const nsAString& aKeyType,
                                                 const nsAString& aKeyParams,
                                                 nsAString& newValue) {
-  return GetPublicKey(aOldValue, aChallenge, aKeyType,
-                      newValue, aKeyParams);
+  return GetPublicKey(aOldValue, aChallenge, aKeyType, newValue, aKeyParams);
 }
 
 nsresult nsKeygenFormProcessor::ProvideContent(const nsAString& aFormType,
                                                nsTArray<nsString>& aContent,
                                                nsAString& aAttribute) {
   if (Compare(aFormType, NS_LITERAL_STRING("SELECT"),
               nsCaseInsensitiveStringComparator()) == 0) {
     for (size_t i = 0; i < number_of_key_size_choices; ++i) {
--- a/testing/gtest/mozilla/GTestRunner.cpp
+++ b/testing/gtest/mozilla/GTestRunner.cpp
@@ -23,19 +23,20 @@ using ::testing::TestCase;
 using ::testing::TestEventListeners;
 using ::testing::TestInfo;
 using ::testing::TestPartResult;
 using ::testing::UnitTest;
 
 namespace mozilla {
 
 #ifdef ANDROID
-  #define MOZ_STDOUT_PRINT(...) __android_log_print(ANDROID_LOG_INFO, "gtest", __VA_ARGS__);
+#  define MOZ_STDOUT_PRINT(...) \
+    __android_log_print(ANDROID_LOG_INFO, "gtest", __VA_ARGS__);
 #else
-  #define MOZ_STDOUT_PRINT(...) printf(__VA_ARGS__);
+#  define MOZ_STDOUT_PRINT(...) printf(__VA_ARGS__);
 #endif
 
 #define MOZ_PRINT(...)              \
   MOZ_STDOUT_PRINT(__VA_ARGS__);    \
   if (mLogFile) {                   \
     fprintf(mLogFile, __VA_ARGS__); \
   }
 
@@ -48,43 +49,43 @@ class MozillaPrinter : public EmptyTestE
       mLogFile = fopen(path, "w");
     }
   }
   virtual void OnTestProgramStart(const UnitTest& /* aUnitTest */) override {
     MOZ_PRINT("TEST-INFO | GTest unit test starting\n");
   }
   virtual void OnTestProgramEnd(const UnitTest& aUnitTest) override {
     MOZ_PRINT("TEST-%s | GTest unit test: %s\n",
-           aUnitTest.Passed() ? "PASS" : "UNEXPECTED-FAIL",
-           aUnitTest.Passed() ? "passed" : "failed");
+              aUnitTest.Passed() ? "PASS" : "UNEXPECTED-FAIL",
+              aUnitTest.Passed() ? "passed" : "failed");
     MOZ_PRINT("Passed: %d\n", aUnitTest.successful_test_count());
     MOZ_PRINT("Failed: %d\n", aUnitTest.failed_test_count());
     if (mLogFile) {
       fclose(mLogFile);
       mLogFile = nullptr;
     }
   }
   virtual void OnTestStart(const TestInfo& aTestInfo) override {
     mTestInfo = &aTestInfo;
     MOZ_PRINT("TEST-START | %s.%s\n", mTestInfo->test_case_name(),
-           mTestInfo->name());
+              mTestInfo->name());
   }
   virtual void OnTestPartResult(
       const TestPartResult& aTestPartResult) override {
     MOZ_PRINT("TEST-%s | %s.%s | %s @ %s:%i\n",
-           !aTestPartResult.failed() ? "PASS" : "UNEXPECTED-FAIL",
-           mTestInfo ? mTestInfo->test_case_name() : "?",
-           mTestInfo ? mTestInfo->name() : "?", aTestPartResult.summary(),
-           aTestPartResult.file_name(), aTestPartResult.line_number());
+              !aTestPartResult.failed() ? "PASS" : "UNEXPECTED-FAIL",
+              mTestInfo ? mTestInfo->test_case_name() : "?",
+              mTestInfo ? mTestInfo->name() : "?", aTestPartResult.summary(),
+              aTestPartResult.file_name(), aTestPartResult.line_number());
   }
   virtual void OnTestEnd(const TestInfo& aTestInfo) override {
     MOZ_PRINT("TEST-%s | %s.%s | test completed (time: %llims)\n",
-           aTestInfo.result()->Passed() ? "PASS" : "UNEXPECTED-FAIL",
-           aTestInfo.test_case_name(), aTestInfo.name(),
-           aTestInfo.result()->elapsed_time());
+              aTestInfo.result()->Passed() ? "PASS" : "UNEXPECTED-FAIL",
+              aTestInfo.test_case_name(), aTestInfo.name(),
+              aTestInfo.result()->elapsed_time());
     MOZ_ASSERT(&aTestInfo == mTestInfo);
     mTestInfo = nullptr;
   }
 
   const TestInfo* mTestInfo;
   FILE* mLogFile;
 };
 
@@ -129,18 +130,18 @@ int RunGTestFunc(int* argc, char** argv)
                                       getter_AddRefs(file));
         if (NS_FAILED(rv)) {
           printf_stderr("Ignoring invalid MOZ_GTEST_MINIDUMPS_PATH\n");
         }
       }
       if (!file) {
         nsCOMPtr<nsIProperties> dirsvc =
             do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
-        nsresult rv = dirsvc->Get(NS_OS_CURRENT_WORKING_DIR, NS_GET_IID(nsIFile),
-                                  getter_AddRefs(file));
+        nsresult rv = dirsvc->Get(NS_OS_CURRENT_WORKING_DIR,
+                                  NS_GET_IID(nsIFile), getter_AddRefs(file));
         MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
       }
       crashreporter->SetEnabled(true);
       crashreporter->SetMinidumpPath(file);
     }
   }
 
   return RUN_ALL_TESTS();
--- a/toolkit/components/startup/StartupTimeline.h
+++ b/toolkit/components/startup/StartupTimeline.h
@@ -1,14 +1,14 @@
 /* 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/. */
 
 #ifdef mozilla_StartupTimeline_Event
-  // clang-format off
+// clang-format off
   mozilla_StartupTimeline_Event(PROCESS_CREATION, "process")
   mozilla_StartupTimeline_Event(START, "start")
   mozilla_StartupTimeline_Event(MAIN, "main")
   mozilla_StartupTimeline_Event(SELECT_PROFILE, "selectProfile")
   mozilla_StartupTimeline_Event(AFTER_PROFILE_LOCKED, "afterProfileLocked")
 
   // Record the beginning and end of startup crash detection to compare with
   // crash stats to know whether detection should be improved to start or end
@@ -22,17 +22,17 @@
   mozilla_StartupTimeline_Event(LINKER_INITIALIZED, "linkerInitialized")
   mozilla_StartupTimeline_Event(LIBRARIES_LOADED, "librariesLoaded")
   mozilla_StartupTimeline_Event(FIRST_LOAD_URI, "firstLoadURI")
 
   // The following are actually shutdown events, used to monitor the duration
   // of shutdown
   mozilla_StartupTimeline_Event(QUIT_APPLICATION, "quitApplication")
   mozilla_StartupTimeline_Event(PROFILE_BEFORE_CHANGE, "profileBeforeChange")
-  // clang-format on
+// clang-format on
 #else
 
 #  ifndef mozilla_StartupTimeline
 #    define mozilla_StartupTimeline
 
 #    include "mozilla/TimeStamp.h"
 #    include "nscore.h"
 
--- a/toolkit/components/url-classifier/Classifier.cpp
+++ b/toolkit/components/url-classifier/Classifier.cpp
@@ -415,17 +415,18 @@ nsresult Classifier::CheckURIFragments(
 
   if (LOG_ENABLED()) {
     uint32_t urlIdx = 0;
     for (uint32_t i = 1; i < aSpecFragments.Length(); i++) {
       if (aSpecFragments[urlIdx].Length() < aSpecFragments[i].Length()) {
         urlIdx = i;
       }
     }
-    LOG(("Checking table %s, URL is %s", aTable.BeginReading(), aSpecFragments[urlIdx].get()));
+    LOG(("Checking table %s, URL is %s", aTable.BeginReading(),
+         aSpecFragments[urlIdx].get()));
   }
 
   RefPtr<LookupCache> cache = GetLookupCache(aTable);
   if (NS_WARN_IF(!cache)) {
     return NS_ERROR_FAILURE;
   }
 
   // Now check each lookup fragment against the entries in the DB.
@@ -441,20 +442,20 @@ nsresult Classifier::CheckURIFragments(
 
     if (has) {
       RefPtr<LookupResult> result = new LookupResult;
       aResults.AppendElement(result);
 
       if (LOG_ENABLED()) {
         nsAutoCString checking;
         lookupHash.ToHexString(checking);
-        LOG(("Found a result in fragment %s, hash %s (%X)", aSpecFragments[i].get(),
-             checking.get(), lookupHash.ToUint32()));
-        LOG(("Result %s, match %d-bytes prefix", confirmed ? "confirmed." : "Not confirmed.",
-             matchLength));
+        LOG(("Found a result in fragment %s, hash %s (%X)",
+             aSpecFragments[i].get(), checking.get(), lookupHash.ToUint32()));
+        LOG(("Result %s, match %d-bytes prefix",
+             confirmed ? "confirmed." : "Not confirmed.", matchLength));
       }
 
       result->hash.complete = lookupHash;
       result->mConfirmed = confirmed;
       result->mTableName.Assign(cache->TableName());
       result->mPartialHashLength = confirmed ? COMPLETE_SIZE : matchLength;
       result->mProtocolV2 = LookupCache::Cast<LookupCacheV2>(cache);
     }
--- a/toolkit/components/url-classifier/tests/gtest/TestLookupCacheV4.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestLookupCacheV4.cpp
@@ -120,17 +120,18 @@ TEST(UrlClassifierLookupCacheV4, LoadOld
   RefPtr<LookupCache> cache = classifier->GetLookupCache(GTEST_TABLE, false);
 
   RefPtr<LookupCacheV4> cacheV4 = LookupCache::Cast<LookupCacheV4>(cache);
   CheckContent(cacheV4, array);
 
   oldPsetFile->Remove(false);
 }
 
-TEST(UrlClassifierLookupCacheV4, BuildAPI) {
+TEST(UrlClassifierLookupCacheV4, BuildAPI)
+{
   _PrefixArray init = {_Prefix("alph")};
   RefPtr<LookupCacheV4> cache = SetupLookupCache<LookupCacheV4>(init);
 
   _PrefixArray update = {_Prefix("beta")};
   PrefixStringMap map;
   SetupPrefixMap(update, map);
 
   cache->Build(map);
--- a/toolkit/crashreporter/client/crashreporter_gtk_common.cpp
+++ b/toolkit/crashreporter/client/crashreporter_gtk_common.cpp
@@ -102,17 +102,17 @@ static gboolean ReportCompleted(gpointer
   gtk_widget_hide(gThrobber);
   string str =
       success ? gStrings[ST_REPORTSUBMITSUCCESS] : gStrings[ST_SUBMITFAILED];
   gtk_label_set_text(GTK_LABEL(gProgressLabel), str.c_str());
   g_timeout_add(5000, CloseApp, 0);
   return FALSE;
 }
 
-#  define HTTP_PROXY_DIR "/system/http_proxy"
+#define HTTP_PROXY_DIR "/system/http_proxy"
 
 void LoadProxyinfo() {
   class GConfClient;
   typedef GConfClient* (*_gconf_default_fn)();
   typedef gboolean (*_gconf_bool_fn)(GConfClient*, const gchar*, GError**);
   typedef gint (*_gconf_int_fn)(GConfClient*, const gchar*, GError**);
   typedef gchar* (*_gconf_string_fn)(GConfClient*, const gchar*, GError**);
 
--- a/toolkit/library/gtest/static/TestUCRTDepends.cpp
+++ b/toolkit/library/gtest/static/TestUCRTDepends.cpp
@@ -32,17 +32,18 @@ static LPWSTR GetModuleFileDir(HMODULE m
     return nullptr;  // at least one path separator must be present
   }
   *basename++ = L'\0';
   return basename;
 }
 
 // Make sure that Universal CRT forwarder DLLs are not in app directory if it
 // is in Api Sets.
-TEST(TestUCRTDepends, AppDir) {
+TEST(TestUCRTDepends, AppDir)
+{
   WCHAR appdir[MAX_PATH];
   ASSERT_TRUE(GetModuleFileDir(nullptr, appdir, MAX_PATH));
 
   WCHAR path[MAX_PATH + ArrayLength(pattern)];
   swprintf(path, L"%s%s", appdir, pattern);
 
   WIN32_FIND_DATAW wfd;
   HANDLE hFind = FindFirstFileW(path, &wfd);
@@ -90,17 +91,18 @@ TEST(TestUCRTDepends, AppDir) {
   } while (FindNextFileW(hFind, &wfd));
   EXPECT_EQ(GetLastError(), ERROR_NO_MORE_FILES);
   BOOL ret = FindClose(hFind);
   EXPECT_TRUE(ret);
 }
 
 // Make sure that we do not depend on Universal CRT forwarder DLLs in the
 // system directory.
-TEST(TestUCRTDepends, SystemDir) {
+TEST(TestUCRTDepends, SystemDir)
+{
   WCHAR appdir[MAX_PATH];
   ASSERT_TRUE(GetModuleFileDir(nullptr, appdir, MAX_PATH));
 
   WCHAR path[MAX_PATH + ArrayLength(pattern)];
   UINT chars = GetSystemDirectoryW(path, MAX_PATH);
   ASSERT_TRUE(chars > 0 && chars < MAX_PATH);
   wcscat(path, pattern);
 
--- a/toolkit/xre/nsAppRunner.cpp
+++ b/toolkit/xre/nsAppRunner.cpp
@@ -1259,18 +1259,17 @@ static already_AddRefed<nsIFactory> Prof
   return factory.forget();
 }
 
 static const mozilla::Module::CIDEntry kXRECIDs[] = {
     {&kProfileServiceCID, false, ProfileServiceFactoryConstructor, nullptr},
     {nullptr}};
 
 static const mozilla::Module::ContractIDEntry kXREContracts[] = {
-    {NS_PROFILESERVICE_CONTRACTID, &kProfileServiceCID},
-    {nullptr}};
+    {NS_PROFILESERVICE_CONTRACTID, &kProfileServiceCID}, {nullptr}};
 
 extern const mozilla::Module kXREModule = {mozilla::Module::kVersion, kXRECIDs,
                                            kXREContracts};
 
 nsresult ScopedXPCOMStartup::Initialize() {
   NS_ASSERTION(gDirServiceProvider, "Should not get here!");
 
   nsresult rv;
@@ -5060,27 +5059,28 @@ void OverrideDefaultLocaleIfNeeded() {
 static bool gRunSelfAsContentProc = false;
 
 void XRE_EnableSameExecutableForContentProc() {
   if (!PR_GetEnv("MOZ_SEPARATE_CHILD_PROCESS")) {
     gRunSelfAsContentProc = true;
   }
 }
 
-mozilla::BinPathType XRE_GetChildProcBinPathType(GeckoProcessType aProcessType) {
+mozilla::BinPathType XRE_GetChildProcBinPathType(
+    GeckoProcessType aProcessType) {
   MOZ_ASSERT(aProcessType != GeckoProcessType_Default);
 
   if (!gRunSelfAsContentProc) {
     return BinPathType::PluginContainer;
   }
 
   switch (aProcessType) {
 #define GECKO_PROCESS_TYPE(enum_name, string_name, xre_name, bin_type) \
-    case GeckoProcessType_##enum_name:                                 \
-      return BinPathType::bin_type;
+  case GeckoProcessType_##enum_name:                                   \
+    return BinPathType::bin_type;
 #include "mozilla/GeckoProcessTypes.h"
 #undef GECKO_PROCESS_TYPE
     default:
       return BinPathType::PluginContainer;
   }
 }
 
 // Because rust doesn't handle weak symbols, this function wraps the weak
--- a/widget/android/nsWindow.cpp
+++ b/widget/android/nsWindow.cpp
@@ -467,17 +467,19 @@ class nsWindow::NPZCSupport final
           "NPZCSupport::OnDetach",
           [npzc, disposer = RefPtr<Runnable>(aDisposer)] {
             npzc->SetAttached(false);
             disposer->Run();
           }));
     }
   }
 
-  const PanZoomController::NativeProvider::Ref& GetJavaNPZC() const { return mNPZC; }
+  const PanZoomController::NativeProvider::Ref& GetJavaNPZC() const {
+    return mNPZC;
+  }
 
  public:
   void SetIsLongpressEnabled(bool aIsLongpressEnabled) {
     RefPtr<IAPZCTreeManager> controller;
 
     if (LockedWindowPtr window{mWindow}) {
       controller = window->mAPZC;
     }
@@ -646,25 +648,23 @@ class nsWindow::NPZCSupport final
     PostInputEvent([input, guid, blockId, status](nsWindow* window) {
       WidgetMouseEvent mouseEvent = input.ToWidgetMouseEvent(window);
       window->ProcessUntransformedAPZEvent(&mouseEvent, guid, blockId, status);
     });
 
     return true;
   }
 
-  bool HandleMotionEvent(const PanZoomController::NativeProvider::LocalRef& aInstance,
-                         int32_t aAction, int32_t aActionIndex, int64_t aTime,
-                         int32_t aMetaState, float aScreenX, float aScreenY,
-                         jni::IntArray::Param aPointerId,
-                         jni::FloatArray::Param aX, jni::FloatArray::Param aY,
-                         jni::FloatArray::Param aOrientation,
-                         jni::FloatArray::Param aPressure,
-                         jni::FloatArray::Param aToolMajor,
-                         jni::FloatArray::Param aToolMinor) {
+  bool HandleMotionEvent(
+      const PanZoomController::NativeProvider::LocalRef& aInstance,
+      int32_t aAction, int32_t aActionIndex, int64_t aTime, int32_t aMetaState,
+      float aScreenX, float aScreenY, jni::IntArray::Param aPointerId,
+      jni::FloatArray::Param aX, jni::FloatArray::Param aY,
+      jni::FloatArray::Param aOrientation, jni::FloatArray::Param aPressure,
+      jni::FloatArray::Param aToolMajor, jni::FloatArray::Param aToolMinor) {
     MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
 
     RefPtr<IAPZCTreeManager> controller;
 
     if (LockedWindowPtr window{mWindow}) {
       controller = window->mAPZC;
     }
 
@@ -934,23 +934,23 @@ class nsWindow::LayerViewSupport final
     // called before the first AttachNPZC() gets here. Just detach the current
     // instance since that's what happens in GeckoViewSupport::Transfer() as
     // well.
     if (mWindow->mNPZCSupport) {
       mWindow->mNPZCSupport.Detach(mWindow->mNPZCSupport->GetJavaNPZC());
     }
 
     auto npzc = PanZoomController::NativeProvider::LocalRef(
-        jni::GetGeckoThreadEnv(), PanZoomController::NativeProvider::Ref::From(aNPZC));
+        jni::GetGeckoThreadEnv(),
+        PanZoomController::NativeProvider::Ref::From(aNPZC));
     mWindow->mNPZCSupport.Attach(npzc, mWindow, npzc);
 
     DispatchToUiThread("LayerViewSupport::AttachNPZC",
-                       [npzc = PanZoomController::NativeProvider::GlobalRef(npzc)] {
-                         npzc->SetAttached(true);
-                       });
+                       [npzc = PanZoomController::NativeProvider::GlobalRef(
+                            npzc)] { npzc->SetAttached(true); });
   }
 
   void OnBoundsChanged(int32_t aLeft, int32_t aTop, int32_t aWidth,
                        int32_t aHeight) {
     MOZ_ASSERT(NS_IsMainThread());
     if (!mWindow) {
       return;  // Already shut down.
     }
@@ -2120,42 +2120,41 @@ nsresult nsWindow::SynthesizeNativeMouse
   mozilla::widget::AutoObserverNotifier notifier(aObserver, "mouseevent");
 
   MOZ_ASSERT(mNPZCSupport);
   const auto& npzc = mNPZCSupport->GetJavaNPZC();
   const auto& bounds = FindTopLevel()->mBounds;
   aPoint.x -= bounds.x;
   aPoint.y -= bounds.y;
 
-  DispatchToUiThread(
-      "nsWindow::SynthesizeNativeMouseEvent",
-      [npzc = PanZoomController::NativeProvider::GlobalRef(npzc),
-       aNativeMessage, aPoint] {
-        npzc->SynthesizeNativeMouseEvent(aNativeMessage, aPoint.x, aPoint.y);
-      });
+  DispatchToUiThread("nsWindow::SynthesizeNativeMouseEvent",
+                     [npzc = PanZoomController::NativeProvider::GlobalRef(npzc),
+                      aNativeMessage, aPoint] {
+                       npzc->SynthesizeNativeMouseEvent(aNativeMessage,
+                                                        aPoint.x, aPoint.y);
+                     });
   return NS_OK;
 }
 
 nsresult nsWindow::SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
                                              nsIObserver* aObserver) {
   mozilla::widget::AutoObserverNotifier notifier(aObserver, "mouseevent");
 
   MOZ_ASSERT(mNPZCSupport);
   const auto& npzc = mNPZCSupport->GetJavaNPZC();
   const auto& bounds = FindTopLevel()->mBounds;
   aPoint.x -= bounds.x;
   aPoint.y -= bounds.y;
 
-  DispatchToUiThread("nsWindow::SynthesizeNativeMouseMove",
-                     [npzc = PanZoomController::NativeProvider::GlobalRef(npzc),
-                      aPoint] {
-                       npzc->SynthesizeNativeMouseEvent(
-                           sdk::MotionEvent::ACTION_HOVER_MOVE, aPoint.x,
-                           aPoint.y);
-                     });
+  DispatchToUiThread(
+      "nsWindow::SynthesizeNativeMouseMove",
+      [npzc = PanZoomController::NativeProvider::GlobalRef(npzc), aPoint] {
+        npzc->SynthesizeNativeMouseEvent(sdk::MotionEvent::ACTION_HOVER_MOVE,
+                                         aPoint.x, aPoint.y);
+      });
   return NS_OK;
 }
 
 bool nsWindow::WidgetPaintsBackground() {
   static bool sWidgetPaintsBackground = true;
   static bool sWidgetPaintsBackgroundPrefCached = false;
 
   if (!sWidgetPaintsBackgroundPrefCached) {
--- a/widget/cocoa/nsAppShell.mm
+++ b/widget/cocoa/nsAppShell.mm
@@ -287,19 +287,18 @@ nsresult nsAppShell::Init() {
 
   // mAutoreleasePools is used as a stack of NSAutoreleasePool objects created
   // by |this|.  CFArray is used instead of NSArray because NSArray wants to
   // retain each object you add to it, and you can't retain an
   // NSAutoreleasePool.
   mAutoreleasePools = ::CFArrayCreateMutable(nullptr, 0, nullptr);
   NS_ENSURE_STATE(mAutoreleasePools);
 
-  bool isNSApplicationProcessType =
-      (XRE_GetProcessType() != GeckoProcessType_RDD) &&
-      (XRE_GetProcessType() != GeckoProcessType_Socket);
+  bool isNSApplicationProcessType = (XRE_GetProcessType() != GeckoProcessType_RDD) &&
+                                    (XRE_GetProcessType() != GeckoProcessType_Socket);
 
   if (isNSApplicationProcessType) {
     // Get the path of the nib file, which lives in the GRE location
     nsCOMPtr<nsIFile> nibFile;
     nsresult rv = NS_GetSpecialDirectory(NS_GRE_DIR, getter_AddRefs(nibFile));
     NS_ENSURE_SUCCESS(rv, rv);
 
     nibFile->AppendNative(NS_LITERAL_CSTRING("res"));
--- a/widget/cocoa/nsTouchBarUpdater.mm
+++ b/widget/cocoa/nsTouchBarUpdater.mm
@@ -17,17 +17,18 @@
 @interface BaseWindow (NSTouchBarProvider)
 @property(strong) NSTouchBar* touchBar;
 @end
 #endif
 
 NS_IMPL_ISUPPORTS(nsTouchBarUpdater, nsITouchBarUpdater);
 
 NS_IMETHODIMP
-nsTouchBarUpdater::UpdateTouchBarInputs(nsIBaseWindow* aWindow, const nsTArray<RefPtr<nsITouchBarInput>>& aInputs) {
+nsTouchBarUpdater::UpdateTouchBarInputs(nsIBaseWindow* aWindow,
+                                        const nsTArray<RefPtr<nsITouchBarInput>>& aInputs) {
   nsCOMPtr<nsIWidget> widget = nullptr;
   aWindow->GetMainWidget(getter_AddRefs(widget));
   if (!widget) {
     return NS_ERROR_FAILURE;
   }
   BaseWindow* cocoaWin = (BaseWindow*)widget->GetNativeData(NS_NATIVE_WINDOW);
   if (!cocoaWin) {
     return NS_ERROR_FAILURE;
--- a/widget/cocoa/nsWidgetFactory.mm
+++ b/widget/cocoa/nsWidgetFactory.mm
@@ -195,16 +195,17 @@ static void nsWidgetCocoaModuleDtor() {
   WidgetUtils::Shutdown();
 
   NativeKeyBindings::Shutdown();
   nsLookAndFeel::Shutdown();
   nsToolkit::Shutdown();
   nsAppShellShutdown();
 }
 
-extern const mozilla::Module kWidgetModule = {mozilla::Module::kVersion,
-                                              kWidgetCIDs,
-                                              kWidgetContracts,
-                                              NULL,
-                                              NULL,
-                                              nsAppShellInit,
-                                              nsWidgetCocoaModuleDtor,
-                                              mozilla::Module::ALLOW_IN_GPU_RDD_VR_AND_SOCKET_PROCESS};
+extern const mozilla::Module kWidgetModule = {
+    mozilla::Module::kVersion,
+    kWidgetCIDs,
+    kWidgetContracts,
+    NULL,
+    NULL,
+    nsAppShellInit,
+    nsWidgetCocoaModuleDtor,
+    mozilla::Module::ALLOW_IN_GPU_RDD_VR_AND_SOCKET_PROCESS};
--- a/widget/gtk/WindowSurfaceWayland.cpp
+++ b/widget/gtk/WindowSurfaceWayland.cpp
@@ -624,31 +624,32 @@ static void WaylandBufferDelayCommitHand
   } else {
     // Referenced WindowSurfaceWayland is already deleted.
     // Do nothing but just release the mDelayedCommitHandle allocated at
     // WindowSurfaceWayland::CommitWaylandBuffer().
     free(aSurface);
   }
 }
 
-void WindowSurfaceWayland::CalcRectScale(LayoutDeviceIntRect& aRect, int aScale) {
+void WindowSurfaceWayland::CalcRectScale(LayoutDeviceIntRect& aRect,
+                                         int aScale) {
   if (aRect.x & 0x1) {
     aRect.width += 1;
   }
   aRect.x = aRect.x / aScale;
 
   if (aRect.y & 0x1) {
     aRect.height += 1;
   }
   aRect.y = aRect.y / aScale;
 
-  aRect.width = (aRect.width & 0x1) ? aRect.width / aScale + 1 :
-                                      aRect.width / aScale;
-  aRect.height = (aRect.height & 0x1) ? aRect.height / aScale + 1 :
-                                        aRect.height / aScale;
+  aRect.width =
+      (aRect.width & 0x1) ? aRect.width / aScale + 1 : aRect.width / aScale;
+  aRect.height =
+      (aRect.height & 0x1) ? aRect.height / aScale + 1 : aRect.height / aScale;
 }
 
 void WindowSurfaceWayland::CommitWaylandBuffer() {
   MOZ_ASSERT(mPendingCommit, "Committing empty surface!");
 
   if (mWaitToFullScreenUpdate) {
     return;
   }
--- a/widget/gtk/nsWaylandDisplay.cpp
+++ b/widget/gtk/nsWaylandDisplay.cpp
@@ -111,18 +111,17 @@ void nsWaylandDisplay::SetPrimarySelecti
     gtk_primary_selection_device_manager *aPrimarySelectionDeviceManager) {
   mPrimarySelectionDeviceManager = aPrimarySelectionDeviceManager;
 }
 
 static void global_registry_handler(void *data, wl_registry *registry,
                                     uint32_t id, const char *interface,
                                     uint32_t version) {
   auto display = reinterpret_cast<nsWaylandDisplay *>(data);
-  if (!display)
-    return;
+  if (!display) return;
 
   if (strcmp(interface, "wl_shm") == 0) {
     auto shm = static_cast<wl_shm *>(
         wl_registry_bind(registry, id, &wl_shm_interface, 1));
     wl_proxy_set_queue((struct wl_proxy *)shm, display->GetEventQueue());
     display->SetShm(shm);
   } else if (strcmp(interface, "wl_data_device_manager") == 0) {
     int data_device_manager_version = MIN(version, 3);
@@ -163,17 +162,17 @@ bool nsWaylandDisplay::DisplayLoop() {
   wl_display_dispatch_queue_pending(mDisplay, mEventQueue);
   return true;
 }
 
 bool nsWaylandDisplay::Matches(wl_display *aDisplay) {
   return mThreadId == PR_GetCurrentThread() && aDisplay == mDisplay;
 }
 
-nsWaylandDisplay::nsWaylandDisplay(wl_display* aDisplay)
+nsWaylandDisplay::nsWaylandDisplay(wl_display *aDisplay)
     : mThreadId(PR_GetCurrentThread()),
       mDisplay(aDisplay),
       mEventQueue(nullptr),
       mDataDeviceManager(nullptr),
       mSubcompositor(nullptr),
       mSeat(nullptr),
       mShm(nullptr),
       mPrimarySelectionDeviceManager(nullptr),
--- a/widget/gtk/nsWaylandDisplay.h
+++ b/widget/gtk/nsWaylandDisplay.h
@@ -42,26 +42,26 @@ class nsWaylandDisplay {
 
   void SetShm(wl_shm* aShm);
   void SetSubcompositor(wl_subcompositor* aSubcompositor);
   void SetDataDeviceManager(wl_data_device_manager* aDataDeviceManager);
   void SetSeat(wl_seat* aSeat);
   void SetPrimarySelectionDeviceManager(
       gtk_primary_selection_device_manager* aPrimarySelectionDeviceManager);
 
-private:
+ private:
   PRThread* mThreadId;
   wl_display* mDisplay;
   wl_event_queue* mEventQueue;
   wl_data_device_manager* mDataDeviceManager;
   wl_subcompositor* mSubcompositor;
   wl_seat* mSeat;
   wl_shm* mShm;
   gtk_primary_selection_device_manager* mPrimarySelectionDeviceManager;
-  wl_registry *mRegistry;
+  wl_registry* mRegistry;
 };
 
 nsWaylandDisplay* WaylandDisplayGet(GdkDisplay* aGdkDisplay = nullptr);
 
 }  // namespace widget
 }  // namespace mozilla
 
 #endif  // __MOZ_WAYLAND_REGISTRY_H__
--- a/xpcom/build/GeckoProcessTypes.h
+++ b/xpcom/build/GeckoProcessTypes.h
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
-// GECKO_PROCESS_TYPE(enum-name, string-name, XRE_Is${NAME}Process, process-bin-type)
-// Note that string-name is exposed to various things like telemetry
-// and the crash reporter, so it should not be changed casually.
+// GECKO_PROCESS_TYPE(enum-name, string-name, XRE_Is${NAME}Process,
+// process-bin-type) Note that string-name is exposed to various things like
+// telemetry and the crash reporter, so it should not be changed casually.
 //
 // process-bin-type should be either Self or PluginContainer, and determines
 // whether the child process may be started using the same binary as the parent
 // process, or whether to use plugin-container (Note that whether or not this
 // value is actually obeyed depends on platform and build configuration. Do not
 // use this value directly, but rather use XRE_GetChildProcBinPathType to
 // resolve this).
 //
@@ -30,9 +30,10 @@ GECKO_PROCESS_TYPE(GMPlugin, "gmplugin",
 // GPU and compositor process.
 GECKO_PROCESS_TYPE(GPU, "gpu", GPU, Self)
 // VR process.
 GECKO_PROCESS_TYPE(VR, "vr", VR, Self)
 // Remote Data Decoder process.
 GECKO_PROCESS_TYPE(RDD, "rdd", RDD, Self)
 // Socket process
 GECKO_PROCESS_TYPE(Socket, "socket", Socket, Self)
-GECKO_PROCESS_TYPE(RemoteSandboxBroker, "sandbox", RemoteSandboxBroker, PluginContainer)
+GECKO_PROCESS_TYPE(RemoteSandboxBroker, "sandbox", RemoteSandboxBroker,
+                   PluginContainer)
--- a/xpcom/components/Module.h
+++ b/xpcom/components/Module.h
@@ -59,18 +59,18 @@ struct Module {
         ALLOW_IN_GPU_PROCESS | ALLOW_IN_SOCKET_PROCESS,
     ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS =
         ALLOW_IN_GPU_PROCESS | ALLOW_IN_VR_PROCESS | ALLOW_IN_SOCKET_PROCESS,
     ALLOW_IN_RDD_AND_SOCKET_PROCESS =
         ALLOW_IN_RDD_PROCESS | ALLOW_IN_SOCKET_PROCESS,
     ALLOW_IN_GPU_RDD_AND_SOCKET_PROCESS =
         ALLOW_IN_GPU_PROCESS | ALLOW_IN_RDD_PROCESS | ALLOW_IN_SOCKET_PROCESS,
     ALLOW_IN_GPU_RDD_VR_AND_SOCKET_PROCESS =
-        ALLOW_IN_GPU_PROCESS | ALLOW_IN_RDD_PROCESS |
-        ALLOW_IN_VR_PROCESS | ALLOW_IN_SOCKET_PROCESS
+        ALLOW_IN_GPU_PROCESS | ALLOW_IN_RDD_PROCESS | ALLOW_IN_VR_PROCESS |
+        ALLOW_IN_SOCKET_PROCESS
   };
 
   static constexpr size_t kMaxProcessSelector =
       size_t(ProcessSelector::ALLOW_IN_GPU_RDD_VR_AND_SOCKET_PROCESS);
 
   /**
    * The constructor callback is an implementation detail of the default binary
    * loader and may be null.