Bug 1512961 - Reformat recent changes to the Google coding style r=Ehsan
authorSylvestre Ledru <sledru@mozilla.com>
Mon, 10 Dec 2018 19:23:16 +0000
changeset 506837 8869368a3f30f51879322b4aebd66d03a35ea2ce
parent 506836 616d351dbe7b95077c1b8e167405a7793c97f0d4
child 506838 12a45aafbff81839a4152a473887adef03fe2517
push id10547
push userffxbld-merge
push dateMon, 21 Jan 2019 13:03:58 +0000
treeherdermozilla-beta@24ec1916bffe [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersEhsan
bugs1512961
milestone65.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 1512961 - Reformat recent changes to the Google coding style r=Ehsan # ignore-this-changeset Differential Revision: https://phabricator.services.mozilla.com/D14060
accessible/android/ProxyAccessibleWrap.cpp
accessible/android/SessionAccessibility.cpp
dom/base/Element.h
dom/ipc/WindowGlobalChild.cpp
dom/ipc/WindowGlobalChild.h
dom/ipc/WindowGlobalParent.cpp
dom/ipc/WindowGlobalParent.h
dom/media/systemservices/video_engine/platform_uithread.cc
image/AnimationFrameBuffer.cpp
ipc/glue/InProcessChild.cpp
ipc/glue/InProcessChild.h
ipc/glue/InProcessImpl.cpp
ipc/glue/InProcessParent.cpp
ipc/glue/InProcessParent.h
js/public/TraceKind.h
js/src/jit/arm64/Lowering-arm64.cpp
js/src/jsapi.h
js/src/util/StructuredSpewer.cpp
layout/base/ScrollStyles.h
layout/generic/nsGfxScrollFrame.cpp
layout/printing/nsPrintJob.cpp
layout/xul/nsLeafBoxFrame.cpp
layout/xul/tree/nsTreeBodyFrame.cpp
media/libdav1d/config/other/config.h
netwerk/base/NetworkConnectivityService.cpp
toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
toolkit/recordreplay/HashTable.cpp
toolkit/recordreplay/ProcessRedirectDarwin.cpp
widget/gtk/mozcontainer.cpp
xpcom/ds/PLDHashTable.h
--- a/accessible/android/ProxyAccessibleWrap.cpp
+++ b/accessible/android/ProxyAccessibleWrap.cpp
@@ -75,25 +75,21 @@ void ProxyAccessibleWrap::Value(nsString
 uint64_t ProxyAccessibleWrap::State() { return Proxy()->State(); }
 
 nsIntRect ProxyAccessibleWrap::Bounds() const { return Proxy()->Bounds(); }
 
 void ProxyAccessibleWrap::ScrollTo(uint32_t aHow) const {
   Proxy()->ScrollTo(aHow);
 }
 
-uint8_t
-ProxyAccessibleWrap::ActionCount() const
-{
+uint8_t ProxyAccessibleWrap::ActionCount() const {
   return Proxy()->ActionCount();
 }
 
-bool
-ProxyAccessibleWrap::DoAction(uint8_t aIndex) const
-{
+bool ProxyAccessibleWrap::DoAction(uint8_t aIndex) const {
   return Proxy()->DoAction(aIndex);
 }
 
 // Other
 
 void ProxyAccessibleWrap::SetTextContents(const nsAString& aText) {
   Proxy()->ReplaceText(PromiseFlatString(aText));
 }
--- a/accessible/android/SessionAccessibility.cpp
+++ b/accessible/android/SessionAccessibility.cpp
@@ -327,17 +327,18 @@ void SessionAccessibility::SendSelectedE
 void SessionAccessibility::ReplaceViewportCache(
     const nsTArray<AccessibleWrap*>& aAccessibles,
     const nsTArray<BatchData>& aData) {
   auto infos = jni::ObjectArray::New<java::GeckoBundle>(aAccessibles.Length());
   for (size_t i = 0; i < aAccessibles.Length(); i++) {
     AccessibleWrap* acc = aAccessibles.ElementAt(i);
     if (aData.Length() == aAccessibles.Length()) {
       const BatchData& data = aData.ElementAt(i);
-      auto bundle = acc->ToSmallBundle(data.State(), data.Bounds(), data.ActionCount());
+      auto bundle =
+          acc->ToSmallBundle(data.State(), data.Bounds(), data.ActionCount());
       infos->SetElement(i, bundle);
     } else {
       infos->SetElement(i, acc->ToSmallBundle());
     }
   }
 
   mSessionAccessibility->ReplaceViewportCache(infos);
 }
--- a/dom/base/Element.h
+++ b/dom/base/Element.h
@@ -1892,17 +1892,17 @@ class Element : public FragmentOrElement
   // Data members
   EventStates mState;
   // Per-node data managed by Servo.
   //
   // There should not be data on nodes that are in the flattened tree, or
   // descendants of display: none elements.
   mozilla::RustCell<ServoNodeData*> mServoData;
 
-protected:
+ protected:
   // Array containing all attributes for this element
   AttrArray mAttrs;
 };
 
 class RemoveFromBindingManagerRunnable : public mozilla::Runnable {
  public:
   RemoveFromBindingManagerRunnable(nsBindingManager* aManager,
                                    nsIContent* aContent, nsIDocument* aDoc);
--- a/dom/ipc/WindowGlobalChild.cpp
+++ b/dom/ipc/WindowGlobalChild.cpp
@@ -12,53 +12,50 @@
 namespace mozilla {
 namespace dom {
 
 typedef nsRefPtrHashtable<nsUint64HashKey, WindowGlobalChild> WGCByIdMap;
 static StaticAutoPtr<WGCByIdMap> gWindowGlobalChildById;
 
 WindowGlobalChild::WindowGlobalChild(nsGlobalWindowInner* aWindow,
                                      dom::BrowsingContext* aBrowsingContext)
-  : mWindowGlobal(aWindow)
-  , mBrowsingContext(aBrowsingContext)
-  , mInnerWindowId(aWindow->WindowID())
-  , mOuterWindowId(aWindow->GetOuterWindow()->WindowID())
-  , mIPCClosed(true)
-{
-}
+    : mWindowGlobal(aWindow),
+      mBrowsingContext(aBrowsingContext),
+      mInnerWindowId(aWindow->WindowID()),
+      mOuterWindowId(aWindow->GetOuterWindow()->WindowID()),
+      mIPCClosed(true) {}
 
-already_AddRefed<WindowGlobalChild>
-WindowGlobalChild::Create(nsGlobalWindowInner* aWindow)
-{
+already_AddRefed<WindowGlobalChild> WindowGlobalChild::Create(
+    nsGlobalWindowInner* aWindow) {
   nsCOMPtr<nsIPrincipal> principal = aWindow->GetPrincipal();
   MOZ_ASSERT(principal);
 
   RefPtr<nsDocShell> docshell = nsDocShell::Cast(aWindow->GetDocShell());
   MOZ_ASSERT(docshell);
 
   // Initalize our WindowGlobalChild object.
   RefPtr<dom::BrowsingContext> bc = docshell->GetBrowsingContext();
   RefPtr<WindowGlobalChild> wgc = new WindowGlobalChild(aWindow, bc);
 
   WindowGlobalInit init(principal,
                         BrowsingContextId(wgc->BrowsingContext()->Id()),
-                        wgc->mInnerWindowId,
-                        wgc->mOuterWindowId);
+                        wgc->mInnerWindowId, wgc->mOuterWindowId);
 
   // Send the link constructor over PInProcessChild or PBrowser.
   if (XRE_IsParentProcess()) {
     InProcessChild* ipc = InProcessChild::Singleton();
     if (!ipc) {
       return nullptr;
     }
 
     // Note: ref is released in DeallocPWindowGlobalChild
     ipc->SendPWindowGlobalConstructor(do_AddRef(wgc).take(), init);
   } else {
-    RefPtr<TabChild> tabChild = TabChild::GetFrom(static_cast<mozIDOMWindow*>(aWindow));
+    RefPtr<TabChild> tabChild =
+        TabChild::GetFrom(static_cast<mozIDOMWindow*>(aWindow));
     MOZ_ASSERT(tabChild);
 
     // Note: ref is released in DeallocPWindowGlobalChild
     tabChild->SendPWindowGlobalConstructor(do_AddRef(wgc).take(), init);
   }
   wgc->mIPCClosed = false;
 
   // Register this WindowGlobal in the gWindowGlobalParentsById map.
@@ -69,67 +66,54 @@ WindowGlobalChild::Create(nsGlobalWindow
   auto entry = gWindowGlobalChildById->LookupForAdd(wgc->mInnerWindowId);
   MOZ_RELEASE_ASSERT(!entry, "Duplicate WindowGlobalChild entry for ID!");
   entry.OrInsert([&] { return wgc; });
 
   return wgc.forget();
 }
 
 /* static */ already_AddRefed<WindowGlobalChild>
-WindowGlobalChild::GetByInnerWindowId(uint64_t aInnerWindowId)
-{
+WindowGlobalChild::GetByInnerWindowId(uint64_t aInnerWindowId) {
   if (!gWindowGlobalChildById) {
     return nullptr;
   }
   return gWindowGlobalChildById->Get(aInnerWindowId);
 }
 
-bool
-WindowGlobalChild::IsCurrentGlobal()
-{
+bool WindowGlobalChild::IsCurrentGlobal() {
   return !mIPCClosed && mWindowGlobal->IsCurrentInnerWindow();
 }
 
-already_AddRefed<WindowGlobalParent>
-WindowGlobalChild::GetParentActor()
-{
+already_AddRefed<WindowGlobalParent> WindowGlobalChild::GetParentActor() {
   if (mIPCClosed) {
     return nullptr;
   }
   IProtocol* otherSide = InProcessChild::ParentActorFor(this);
   return do_AddRef(static_cast<WindowGlobalParent*>(otherSide));
 }
 
-void
-WindowGlobalChild::ActorDestroy(ActorDestroyReason aWhy)
-{
+void WindowGlobalChild::ActorDestroy(ActorDestroyReason aWhy) {
   mIPCClosed = true;
   gWindowGlobalChildById->Remove(mInnerWindowId);
 }
 
-WindowGlobalChild::~WindowGlobalChild()
-{
+WindowGlobalChild::~WindowGlobalChild() {
   MOZ_ASSERT(!gWindowGlobalChildById ||
              !gWindowGlobalChildById->Contains(mInnerWindowId));
 }
 
-JSObject*
-WindowGlobalChild::WrapObject(JSContext* aCx,
-                               JS::Handle<JSObject*> aGivenProto)
-{
+JSObject* WindowGlobalChild::WrapObject(JSContext* aCx,
+                                        JS::Handle<JSObject*> aGivenProto) {
   return WindowGlobalChild_Binding::Wrap(aCx, this, aGivenProto);
 }
 
-nsISupports*
-WindowGlobalChild::GetParentObject()
-{
+nsISupports* WindowGlobalChild::GetParentObject() {
   return xpc::NativeGlobal(xpc::PrivilegedJunkScope());
 }
 
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WindowGlobalChild,
-                                      mWindowGlobal,
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WindowGlobalChild, mWindowGlobal,
                                       mBrowsingContext)
 
 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(WindowGlobalChild, AddRef)
 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(WindowGlobalChild, Release)
 
-} // namespace dom
-} // namespace mozilla
+}  // namespace dom
+}  // namespace mozilla
--- a/dom/ipc/WindowGlobalChild.h
+++ b/dom/ipc/WindowGlobalChild.h
@@ -10,37 +10,35 @@
 #include "mozilla/RefPtr.h"
 #include "mozilla/dom/PWindowGlobalChild.h"
 #include "nsWrapperCache.h"
 
 class nsGlobalWindowInner;
 class nsDocShell;
 
 namespace mozilla {
-namespace dom  {
+namespace dom {
 
 class BrowsingContext;
 class WindowGlobalParent;
 
 /**
  * Actor for a single nsGlobalWindowInner. This actor is used to communicate
  * information to the parent process asynchronously.
  */
-class WindowGlobalChild : public nsWrapperCache
-                        , public PWindowGlobalChild
-{
-public:
+class WindowGlobalChild : public nsWrapperCache, public PWindowGlobalChild {
+ public:
   NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(WindowGlobalChild)
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(WindowGlobalChild)
 
-  static already_AddRefed<WindowGlobalChild>
-  GetByInnerWindowId(uint64_t aInnerWindowId);
+  static already_AddRefed<WindowGlobalChild> GetByInnerWindowId(
+      uint64_t aInnerWindowId);
 
-  static already_AddRefed<WindowGlobalChild>
-  GetByInnerWindowId(const GlobalObject& aGlobal, uint64_t aInnerWindowId) {
+  static already_AddRefed<WindowGlobalChild> GetByInnerWindowId(
+      const GlobalObject& aGlobal, uint64_t aInnerWindowId) {
     return GetByInnerWindowId(aInnerWindowId);
   }
 
   dom::BrowsingContext* BrowsingContext() { return mBrowsingContext; }
   nsGlobalWindowInner* WindowGlobal() { return mWindowGlobal; }
 
   // Has this actor been shut down
   bool IsClosed() { return mIPCClosed; }
@@ -55,33 +53,33 @@ public:
 
   bool IsCurrentGlobal();
 
   // Get the other side of this actor if it is an in-process actor. Returns
   // |nullptr| if the actor has been torn down, or is not in-process.
   already_AddRefed<WindowGlobalParent> GetParentActor();
 
   // Create and initialize the WindowGlobalChild object.
-  static already_AddRefed<WindowGlobalChild>
-  Create(nsGlobalWindowInner* aWindow);
+  static already_AddRefed<WindowGlobalChild> Create(
+      nsGlobalWindowInner* aWindow);
 
   nsISupports* GetParentObject();
   JSObject* WrapObject(JSContext* aCx,
                        JS::Handle<JSObject*> aGivenProto) override;
 
-protected:
+ protected:
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 
-private:
+ private:
   WindowGlobalChild(nsGlobalWindowInner* aWindow, dom::BrowsingContext* aBc);
   ~WindowGlobalChild();
 
   RefPtr<nsGlobalWindowInner> mWindowGlobal;
   RefPtr<dom::BrowsingContext> mBrowsingContext;
   uint64_t mInnerWindowId;
   uint64_t mOuterWindowId;
   bool mIPCClosed;
 };
 
-} // namespace dom
-} // namespace mozilla
+}  // namespace dom
+}  // namespace mozilla
 
-#endif // !defined(mozilla_dom_WindowGlobalChild_h)
+#endif  // !defined(mozilla_dom_WindowGlobalChild_h)
--- a/dom/ipc/WindowGlobalParent.cpp
+++ b/dom/ipc/WindowGlobalParent.cpp
@@ -14,33 +14,31 @@ using namespace mozilla::ipc;
 namespace mozilla {
 namespace dom {
 
 typedef nsRefPtrHashtable<nsUint64HashKey, WindowGlobalParent> WGPByIdMap;
 static StaticAutoPtr<WGPByIdMap> gWindowGlobalParentsById;
 
 WindowGlobalParent::WindowGlobalParent(const WindowGlobalInit& aInit,
                                        bool aInProcess)
-  : mDocumentPrincipal(aInit.principal())
-  , mInnerWindowId(aInit.innerWindowId())
-  , mOuterWindowId(aInit.outerWindowId())
-  , mInProcess(aInProcess)
-  , mIPCClosed(true)  // Closed until WGP::Init
+    : mDocumentPrincipal(aInit.principal()),
+      mInnerWindowId(aInit.innerWindowId()),
+      mOuterWindowId(aInit.outerWindowId()),
+      mInProcess(aInProcess),
+      mIPCClosed(true)  // Closed until WGP::Init
 {
   MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess(), "Parent process only");
   MOZ_RELEASE_ASSERT(mDocumentPrincipal, "Must have a valid principal");
 
   // NOTE: mBrowsingContext initialized in Init()
   MOZ_RELEASE_ASSERT(aInit.browsingContextId() != 0,
                      "Must be made in BrowsingContext");
 }
 
-void
-WindowGlobalParent::Init(const WindowGlobalInit& aInit)
-{
+void WindowGlobalParent::Init(const WindowGlobalInit& aInit) {
   MOZ_ASSERT(Manager(), "Should have a manager!");
   MOZ_ASSERT(!mFrameLoader, "Cannot Init() a WindowGlobalParent twice!");
 
   MOZ_ASSERT(mIPCClosed, "IPC shouldn't be open yet");
   mIPCClosed = false;
 
   // Register this WindowGlobal in the gWindowGlobalParentsById map.
   if (!gWindowGlobalParentsById) {
@@ -72,17 +70,18 @@ WindowGlobalParent::Init(const WindowGlo
   RefPtr<Element> frameElement;
   if (mInProcess) {
     // In the in-process case, we can get it from the other side's
     // WindowGlobalChild.
     MOZ_ASSERT(Manager()->GetProtocolTypeId() == PInProcessMsgStart);
     RefPtr<WindowGlobalChild> otherSide = GetChildActor();
     if (otherSide && otherSide->WindowGlobal()) {
       // Get the toplevel window from the other side.
-      RefPtr<nsDocShell> docShell = nsDocShell::Cast(otherSide->WindowGlobal()->GetDocShell());
+      RefPtr<nsDocShell> docShell =
+          nsDocShell::Cast(otherSide->WindowGlobal()->GetDocShell());
       if (docShell) {
         docShell->GetTopFrameElement(getter_AddRefs(frameElement));
       }
     }
   } else {
     // In the cross-process case, we can get the frame element from our manager.
     MOZ_ASSERT(Manager()->GetProtocolTypeId() == PBrowserMsgStart);
     frameElement = static_cast<TabParent*>(Manager())->GetOwnerElement();
@@ -92,84 +91,67 @@ WindowGlobalParent::Init(const WindowGlo
   // nsFrameLoader if we are a chrome document.
   nsCOMPtr<nsIFrameLoaderOwner> flOwner = do_QueryInterface(frameElement);
   if (flOwner) {
     mFrameLoader = flOwner->GetFrameLoader();
   }
 }
 
 /* static */ already_AddRefed<WindowGlobalParent>
-WindowGlobalParent::GetByInnerWindowId(uint64_t aInnerWindowId)
-{
+WindowGlobalParent::GetByInnerWindowId(uint64_t aInnerWindowId) {
   if (!gWindowGlobalParentsById) {
     return nullptr;
   }
   return gWindowGlobalParentsById->Get(aInnerWindowId);
 }
 
-already_AddRefed<WindowGlobalChild>
-WindowGlobalParent::GetChildActor()
-{
+already_AddRefed<WindowGlobalChild> WindowGlobalParent::GetChildActor() {
   if (mIPCClosed) {
     return nullptr;
   }
   IProtocol* otherSide = InProcessParent::ChildActorFor(this);
   return do_AddRef(static_cast<WindowGlobalChild*>(otherSide));
 }
 
-IPCResult
-WindowGlobalParent::RecvUpdateDocumentURI(nsIURI* aURI)
-{
+IPCResult WindowGlobalParent::RecvUpdateDocumentURI(nsIURI* aURI) {
   // XXX(nika): Assert that the URI change was one which makes sense (either
   // about:blank -> a real URI, or a legal push/popstate URI change?)
   mDocumentURI = aURI;
   return IPC_OK();
 }
 
-IPCResult
-WindowGlobalParent::RecvBecomeCurrentWindowGlobal()
-{
+IPCResult WindowGlobalParent::RecvBecomeCurrentWindowGlobal() {
   mBrowsingContext->SetCurrentWindowGlobal(this);
   return IPC_OK();
 }
 
-bool
-WindowGlobalParent::IsCurrentGlobal()
-{
+bool WindowGlobalParent::IsCurrentGlobal() {
   return !mIPCClosed && mBrowsingContext->GetCurrentWindowGlobal() == this;
 }
 
-void
-WindowGlobalParent::ActorDestroy(ActorDestroyReason aWhy)
-{
+void WindowGlobalParent::ActorDestroy(ActorDestroyReason aWhy) {
   mIPCClosed = true;
   gWindowGlobalParentsById->Remove(mInnerWindowId);
   mBrowsingContext->UnregisterWindowGlobal(this);
 }
 
-WindowGlobalParent::~WindowGlobalParent()
-{
+WindowGlobalParent::~WindowGlobalParent() {
   MOZ_ASSERT(!gWindowGlobalParentsById ||
              !gWindowGlobalParentsById->Contains(mInnerWindowId));
 }
 
-JSObject*
-WindowGlobalParent::WrapObject(JSContext* aCx,
-                               JS::Handle<JSObject*> aGivenProto)
-{
+JSObject* WindowGlobalParent::WrapObject(JSContext* aCx,
+                                         JS::Handle<JSObject*> aGivenProto) {
   return WindowGlobalParent_Binding::Wrap(aCx, this, aGivenProto);
 }
 
-nsISupports*
-WindowGlobalParent::GetParentObject()
-{
+nsISupports* WindowGlobalParent::GetParentObject() {
   return xpc::NativeGlobal(xpc::PrivilegedJunkScope());
 }
 
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WindowGlobalParent,
-                                      mFrameLoader,
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WindowGlobalParent, mFrameLoader,
                                       mBrowsingContext)
 
 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(WindowGlobalParent, AddRef)
 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(WindowGlobalParent, Release)
 
-} // namespace dom
-} // namespace mozilla
+}  // namespace dom
+}  // namespace mozilla
--- a/dom/ipc/WindowGlobalParent.h
+++ b/dom/ipc/WindowGlobalParent.h
@@ -11,36 +11,35 @@
 #include "mozilla/dom/PWindowGlobalParent.h"
 #include "nsWrapperCache.h"
 
 class nsIPrincipal;
 class nsIURI;
 class nsFrameLoader;
 
 namespace mozilla {
-namespace dom  {
+namespace dom {
 
 class ChromeBrowsingContext;
 class WindowGlobalChild;
 
 /**
  * A handle in the parent process to a specific nsGlobalWindowInner object.
  */
-class WindowGlobalParent final : public nsWrapperCache
-                               , public PWindowGlobalParent
-{
-public:
+class WindowGlobalParent final : public nsWrapperCache,
+                                 public PWindowGlobalParent {
+ public:
   NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(WindowGlobalParent)
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(WindowGlobalParent)
 
-  static already_AddRefed<WindowGlobalParent>
-  GetByInnerWindowId(uint64_t aInnerWindowId);
+  static already_AddRefed<WindowGlobalParent> GetByInnerWindowId(
+      uint64_t aInnerWindowId);
 
-  static already_AddRefed<WindowGlobalParent>
-  GetByInnerWindowId(const GlobalObject& aGlobal, uint64_t aInnerWindowId) {
+  static already_AddRefed<WindowGlobalParent> GetByInnerWindowId(
+      const GlobalObject& aGlobal, uint64_t aInnerWindowId) {
     return GetByInnerWindowId(aInnerWindowId);
   }
 
   // Has this actor been shut down
   bool IsClosed() { return mIPCClosed; }
 
   // Check if this actor is managed by PInProcess, as-in the document is loaded
   // in-process.
@@ -80,34 +79,34 @@ public:
   // Initialize the mFrameLoader fields for a created WindowGlobalParent. Must
   // be called after setting the Manager actor.
   void Init(const WindowGlobalInit& aInit);
 
   nsISupports* GetParentObject();
   JSObject* WrapObject(JSContext* aCx,
                        JS::Handle<JSObject*> aGivenProto) override;
 
-protected:
+ protected:
   // IPC messages
   mozilla::ipc::IPCResult RecvUpdateDocumentURI(nsIURI* aURI) override;
   mozilla::ipc::IPCResult RecvBecomeCurrentWindowGlobal() override;
 
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
-private:
+ private:
   ~WindowGlobalParent();
 
   // NOTE: This document principal doesn't reflect possible |document.domain|
   // mutations which may have been made in the actual document.
   nsCOMPtr<nsIPrincipal> mDocumentPrincipal;
   nsCOMPtr<nsIURI> mDocumentURI;
   RefPtr<nsFrameLoader> mFrameLoader;
   RefPtr<ChromeBrowsingContext> mBrowsingContext;
   uint64_t mInnerWindowId;
   uint64_t mOuterWindowId;
   bool mInProcess;
   bool mIPCClosed;
 };
 
-} // namespace dom
-} // namespace mozilla
+}  // namespace dom
+}  // namespace mozilla
 
-#endif // !defined(mozilla_dom_WindowGlobalParent_h)
+#endif  // !defined(mozilla_dom_WindowGlobalParent_h)
--- a/dom/media/systemservices/video_engine/platform_uithread.cc
+++ b/dom/media/systemservices/video_engine/platform_uithread.cc
@@ -9,17 +9,18 @@
  */
 
 #include "platform_uithread.h"
 
 namespace rtc {
 
 #if defined(WEBRTC_WIN)
 // For use in ThreadWindowsUI callbacks
-static UINT static_reg_windows_msg = RegisterWindowMessageW(L"WebrtcWindowsUIThreadEvent");
+static UINT static_reg_windows_msg =
+    RegisterWindowMessageW(L"WebrtcWindowsUIThreadEvent");
 // timer id used in delayed callbacks
 static const UINT_PTR kTimerId = 1;
 static const wchar_t kThisProperty[] = L"ThreadWindowsUIPtr";
 static const wchar_t kThreadWindow[] = L"WebrtcWindowsUIThread";
 
 bool PlatformUIThread::InternalInit() {
   // Create an event window for use in generating callbacks to capture
   // objects.
@@ -29,19 +30,18 @@ bool PlatformUIThread::InternalInit() {
     HMODULE hModule = GetModuleHandle(NULL);
     if (!GetClassInfoW(hModule, kThreadWindow, &wc)) {
       ZeroMemory(&wc, sizeof(WNDCLASSW));
       wc.hInstance = hModule;
       wc.lpfnWndProc = EventWindowProc;
       wc.lpszClassName = kThreadWindow;
       RegisterClassW(&wc);
     }
-    hwnd_ = CreateWindowW(kThreadWindow, L"",
-                          0, 0, 0, 0, 0,
-                          NULL, NULL, hModule, NULL);
+    hwnd_ = CreateWindowW(kThreadWindow, L"", 0, 0, 0, 0, 0, NULL, NULL,
+                          hModule, NULL);
     RTC_DCHECK(hwnd_);
     SetPropW(hwnd_, kThisProperty, this);
 
     if (timeout_) {
       // if someone set the timer before we started
       RequestCallbackTimer(timeout_);
     }
   }
@@ -84,17 +84,17 @@ void PlatformUIThread::Stop() {
   PostMessage(hwnd_, WM_CLOSE, 0, 0);
 
   hwnd_ = NULL;
 
   PlatformThread::Stop();
 }
 
 void PlatformUIThread::Run() {
-  RTC_CHECK(InternalInit()); // always evaluates
+  RTC_CHECK(InternalInit());  // always evaluates
   do {
     // The interface contract of Start/Stop is that for a successful call to
     // Start, there should be at least one call to the run function.  So we
     // call the function before checking |stop_|.
     run_function_deprecated_(obj_);
 
     // Alertable sleep to permit RaiseFlag to run and update |stop_|.
     if (MsgWaitForMultipleObjectsEx(0, nullptr, INFINITE, QS_ALLINPUT,
@@ -118,25 +118,27 @@ void PlatformUIThread::NativeEventCallba
   if (!run_function_deprecated_) {
     stop_ = true;
     return;
   }
   run_function_deprecated_(obj_);
 }
 
 /* static */
-LRESULT CALLBACK
-PlatformUIThread::EventWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+LRESULT CALLBACK PlatformUIThread::EventWindowProc(HWND hwnd, UINT uMsg,
+                                                   WPARAM wParam,
+                                                   LPARAM lParam) {
   if (uMsg == WM_DESTROY) {
     RemovePropW(hwnd, kThisProperty);
     PostQuitMessage(0);
     return 0;
   }
 
-  PlatformUIThread *twui = static_cast<PlatformUIThread*>(GetPropW(hwnd, kThisProperty));
+  PlatformUIThread *twui =
+      static_cast<PlatformUIThread *>(GetPropW(hwnd, kThisProperty));
   if (!twui) {
     return DefWindowProc(hwnd, uMsg, wParam, lParam);
   }
 
   if ((uMsg == static_reg_windows_msg && uMsg != WM_NULL) ||
       (uMsg == WM_TIMER && wParam == kTimerId)) {
     twui->NativeEventCallback();
     return 0;
--- a/image/AnimationFrameBuffer.cpp
+++ b/image/AnimationFrameBuffer.cpp
@@ -463,15 +463,15 @@ RawAccessFrameRef AnimationFrameRecyclin
 
 bool AnimationFrameRecyclingQueue::MarkComplete(
     const gfx::IntRect& aFirstFrameRefreshArea) {
   bool continueDecoding =
       AnimationFrameDiscardingQueue::MarkComplete(aFirstFrameRefreshArea);
 
   // If we encounter a redecode error, just make the first frame refresh area to
   // be the full frame, because we don't really know what we can safely recycle.
-  mFirstFrameRefreshArea = mRedecodeError ? mFirstFrame->GetRect()
-                                          : aFirstFrameRefreshArea;
+  mFirstFrameRefreshArea =
+      mRedecodeError ? mFirstFrame->GetRect() : aFirstFrameRefreshArea;
   return continueDecoding;
 }
 
 }  // namespace image
 }  // namespace mozilla
--- a/ipc/glue/InProcessChild.cpp
+++ b/ipc/glue/InProcessChild.cpp
@@ -7,25 +7,22 @@
 #include "mozilla/ipc/InProcessChild.h"
 #include "mozilla/dom/WindowGlobalChild.h"
 
 using namespace mozilla::dom;
 
 namespace mozilla {
 namespace ipc {
 
-PWindowGlobalChild*
-InProcessChild::AllocPWindowGlobalChild(const WindowGlobalInit& aInit)
-{
+PWindowGlobalChild* InProcessChild::AllocPWindowGlobalChild(
+    const WindowGlobalInit& aInit) {
   MOZ_ASSERT_UNREACHABLE("PWindowGlobalChild should not be created manually");
   return nullptr;
 }
 
-bool
-InProcessChild::DeallocPWindowGlobalChild(PWindowGlobalChild* aActor)
-{
+bool InProcessChild::DeallocPWindowGlobalChild(PWindowGlobalChild* aActor) {
   // Free IPC-held reference
   static_cast<WindowGlobalChild*>(aActor)->Release();
   return true;
 }
 
-} // namespace ipc
-} // namespace mozilla
+}  // namespace ipc
+}  // namespace mozilla
--- a/ipc/glue/InProcessChild.h
+++ b/ipc/glue/InProcessChild.h
@@ -9,58 +9,57 @@
 
 #include "mozilla/ipc/PInProcessChild.h"
 #include "mozilla/StaticPtr.h"
 
 namespace mozilla {
 namespace dom {
 class PWindowGlobalParent;
 class PWindowGlobalChild;
-} // namespace dom
+}  // namespace dom
 
 namespace ipc {
 
 class InProcessParent;
 
 /**
  * The `InProcessChild` class represents the child half of a main-thread to
  * main-thread actor.
  *
  * The `PInProcess` actor should be used as an alternate manager to `PContent`
  * for async actors which want to communicate uniformly between Content->Chrome
  * and Chrome->Chrome situations.
  */
-class InProcessChild : public PInProcessChild
-{
-public:
+class InProcessChild : public PInProcessChild {
+ public:
   friend class InProcessParent;
 
   NS_INLINE_DECL_REFCOUNTING(InProcessChild)
 
   // Get the singleton instance of this actor.
   static InProcessChild* Singleton();
 
   // Get the parent side of the in-process child actor |aActor|. If |aActor| is
   // not an in-process actor, or is not connected, this method will return
   // |nullptr|.
   static IProtocol* ParentActorFor(IProtocol* aActor);
 
-protected:
-  virtual mozilla::dom::PWindowGlobalChild*
-  AllocPWindowGlobalChild(const WindowGlobalInit& aInit) override;
+ protected:
+  virtual mozilla::dom::PWindowGlobalChild* AllocPWindowGlobalChild(
+      const WindowGlobalInit& aInit) override;
 
-  virtual bool
-  DeallocPWindowGlobalChild(mozilla::dom::PWindowGlobalChild* aActor) override;
+  virtual bool DeallocPWindowGlobalChild(
+      mozilla::dom::PWindowGlobalChild* aActor) override;
 
-private:
+ private:
   // NOTE: PInProcess lifecycle management is declared as staic methods and
   // state on InProcessParent, and implemented in InProcessImpl.cpp.
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
   virtual void DeallocPInProcessChild() override;
   ~InProcessChild() = default;
 
   static StaticRefPtr<InProcessChild> sSingleton;
 };
 
-} // namespace ipc
-} // namespace mozilla
+}  // namespace ipc
+}  // namespace mozilla
 
-#endif // defined(mozilla_ipc_InProcessChild_h)
+#endif  // defined(mozilla_ipc_InProcessChild_h)
--- a/ipc/glue/InProcessImpl.cpp
+++ b/ipc/glue/InProcessImpl.cpp
@@ -14,44 +14,39 @@
 
 namespace mozilla {
 namespace ipc {
 
 StaticRefPtr<InProcessParent> InProcessParent::sSingleton;
 StaticRefPtr<InProcessChild> InProcessChild::sSingleton;
 bool InProcessParent::sShutdown = false;
 
-
 //////////////////////////////////////////
 // InProcess actor lifecycle management //
 //////////////////////////////////////////
 
-/* static */ InProcessChild*
-InProcessChild::Singleton() {
+/* static */ InProcessChild* InProcessChild::Singleton() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!sSingleton) {
     InProcessParent::Startup();
   }
   return sSingleton;
 }
 
-/* static */ InProcessParent*
-InProcessParent::Singleton() {
+/* static */ InProcessParent* InProcessParent::Singleton() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!sSingleton) {
     InProcessParent::Startup();
   }
   return sSingleton;
 }
 
-/* static */ void
-InProcessParent::Startup()
-{
+/* static */ void InProcessParent::Startup() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (sShutdown) {
     NS_WARNING("Could not get in-process actor while shutting down!");
     return;
   }
 
   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
@@ -82,20 +77,17 @@ InProcessParent::Startup()
   parent.get()->AddRef();
   child.get()->AddRef();
 
   // Stash global references to fetch the other side of the reference.
   InProcessParent::sSingleton = parent.forget();
   InProcessChild::sSingleton = child.forget();
 }
 
-
-/* static */ void
-InProcessParent::Shutdown()
-{
+/* static */ void InProcessParent::Shutdown() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (!sSingleton || sShutdown) {
     return;
   }
 
   sShutdown = true;
 
@@ -104,69 +96,59 @@ InProcessParent::Shutdown()
   InProcessChild::sSingleton = nullptr;
 
   // Calling `Close` on the actor will cause the `Dealloc` methods to be called,
   // freeing the remaining references.
   parent->Close();
 }
 
 NS_IMETHODIMP
-InProcessParent::Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData)
-{
+InProcessParent::Observe(nsISupports* aSubject, const char* aTopic,
+                         const char16_t* aData) {
   MOZ_ASSERT(!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID));
   InProcessParent::Shutdown();
   return NS_OK;
 }
 
-void
-InProcessParent::ActorDestroy(ActorDestroyReason aWhy)
-{
+void InProcessParent::ActorDestroy(ActorDestroyReason aWhy) {
   InProcessParent::Shutdown();
 }
 
-void
-InProcessChild::ActorDestroy(ActorDestroyReason aWhy)
-{
+void InProcessChild::ActorDestroy(ActorDestroyReason aWhy) {
   InProcessParent::Shutdown();
 }
 
-void
-InProcessParent::DeallocPInProcessParent()
-{
+void InProcessParent::DeallocPInProcessParent() {
   MOZ_ASSERT(!InProcessParent::sSingleton);
-  Release(); // Release the reference taken in InProcessParent::Startup.
+  Release();  // Release the reference taken in InProcessParent::Startup.
 }
 
-void
-InProcessChild::DeallocPInProcessChild()
-{
+void InProcessChild::DeallocPInProcessChild() {
   MOZ_ASSERT(!InProcessChild::sSingleton);
-  Release(); // Release the reference taken in InProcessParent::Startup.
+  Release();  // Release the reference taken in InProcessParent::Startup.
 }
 
 ////////////////////////////////
 // In-Process Actor Utilities //
 ////////////////////////////////
 
 // Helper method for implementing ParentActorFor and ChildActorFor.
-static IProtocol*
-GetOtherInProcessActor(IProtocol* aActor)
-{
+static IProtocol* GetOtherInProcessActor(IProtocol* aActor) {
   MOZ_ASSERT(aActor->GetSide() != UnknownSide, "bad unknown side");
 
   // Discover the manager of aActor which is PInProcess.
   IProtocol* current = aActor;
   while (current) {
     if (current->GetProtocolTypeId() == PInProcessMsgStart) {
-      break; // Found the correct actor.
+      break;  // Found the correct actor.
     }
     current = current->Manager();
   }
   if (!current) {
-    return nullptr; // Not a PInProcess actor, return |nullptr|
+    return nullptr;  // Not a PInProcess actor, return |nullptr|
   }
 
   MOZ_ASSERT(current->GetSide() == aActor->GetSide(), "side changed?");
   MOZ_ASSERT_IF(aActor->GetSide() == ParentSide,
                 current == InProcessParent::Singleton());
   MOZ_ASSERT_IF(aActor->GetSide() == ChildSide,
                 current == InProcessChild::Singleton());
 
@@ -189,24 +171,20 @@ GetOtherInProcessActor(IProtocol* aActor
     MOZ_ASSERT(otherActor->GetSide() != aActor->GetSide(), "Wrong side!");
     MOZ_ASSERT(otherActor->GetProtocolTypeId() == aActor->GetProtocolTypeId(),
                "Wrong type of protocol!");
   }
 
   return otherActor;
 }
 
-/* static */ IProtocol*
-InProcessParent::ChildActorFor(IProtocol* aActor)
-{
+/* static */ IProtocol* InProcessParent::ChildActorFor(IProtocol* aActor) {
   MOZ_ASSERT(aActor && aActor->GetSide() == ParentSide);
   return GetOtherInProcessActor(aActor);
 }
 
-/* static */ IProtocol*
-InProcessChild::ParentActorFor(IProtocol* aActor)
-{
+/* static */ IProtocol* InProcessChild::ParentActorFor(IProtocol* aActor) {
   MOZ_ASSERT(aActor && aActor->GetSide() == ChildSide);
   return GetOtherInProcessActor(aActor);
 }
 
-} // namespace ipc
-} // namespace mozilla
+}  // namespace ipc
+}  // namespace mozilla
--- a/ipc/glue/InProcessParent.cpp
+++ b/ipc/glue/InProcessParent.cpp
@@ -9,33 +9,28 @@
 
 using namespace mozilla::dom;
 
 namespace mozilla {
 namespace ipc {
 
 NS_IMPL_ISUPPORTS(InProcessParent, nsIObserver)
 
-IPCResult
-InProcessParent::RecvPWindowGlobalConstructor(PWindowGlobalParent* aActor,
-                                              const WindowGlobalInit& aInit)
-{
+IPCResult InProcessParent::RecvPWindowGlobalConstructor(
+    PWindowGlobalParent* aActor, const WindowGlobalInit& aInit) {
   static_cast<WindowGlobalParent*>(aActor)->Init(aInit);
   return IPC_OK();
 }
 
-PWindowGlobalParent*
-InProcessParent::AllocPWindowGlobalParent(const WindowGlobalInit& aInit)
-{
+PWindowGlobalParent* InProcessParent::AllocPWindowGlobalParent(
+    const WindowGlobalInit& aInit) {
   // Reference freed in DeallocPWindowGlobalParent.
   return do_AddRef(new WindowGlobalParent(aInit, /* inproc */ true)).take();
 }
 
-bool
-InProcessParent::DeallocPWindowGlobalParent(PWindowGlobalParent* aActor)
-{
+bool InProcessParent::DeallocPWindowGlobalParent(PWindowGlobalParent* aActor) {
   // Free IPC-held reference.
   static_cast<WindowGlobalParent*>(aActor)->Release();
   return true;
 }
 
-} // namespace ipc
-} // namespace mozilla
\ No newline at end of file
+}  // namespace ipc
+}  // namespace mozilla
\ No newline at end of file
--- a/ipc/glue/InProcessParent.h
+++ b/ipc/glue/InProcessParent.h
@@ -9,68 +9,65 @@
 
 #include "mozilla/ipc/PInProcessParent.h"
 #include "mozilla/StaticPtr.h"
 
 namespace mozilla {
 namespace dom {
 class PWindowGlobalParent;
 class PWindowGlobalChild;
-} // namespace dom
+}  // namespace dom
 
 namespace ipc {
 
 class InProcessChild;
 
 /**
  * The `InProcessParent` class represents the parent half of a main-thread to
  * main-thread actor.
  *
  * The `PInProcess` actor should be used as an alternate manager to `PContent`
  * for async actors which want to communicate uniformly between Content->Chrome
  * and Chrome->Chrome situations.
  */
-class InProcessParent : public nsIObserver
-                      , public PInProcessParent
-{
-public:
+class InProcessParent : public nsIObserver, public PInProcessParent {
+ public:
   friend class InProcessChild;
 
   NS_DECL_ISUPPORTS
   NS_DECL_NSIOBSERVER
 
   // Get the singleton instance of this actor.
   static InProcessParent* Singleton();
 
   // Get the child side of the in-process child actor |aActor|. If |aActor| is
   // not an in-process actor, or is not connected, this method will return
   // |nullptr|.
   static IProtocol* ChildActorFor(IProtocol* aActor);
 
-protected:
-  virtual mozilla::dom::PWindowGlobalParent*
-  AllocPWindowGlobalParent(const WindowGlobalInit& aInit) override;
+ protected:
+  virtual mozilla::dom::PWindowGlobalParent* AllocPWindowGlobalParent(
+      const WindowGlobalInit& aInit) override;
 
-  virtual bool
-  DeallocPWindowGlobalParent(mozilla::dom::PWindowGlobalParent* aActor) override;
+  virtual bool DeallocPWindowGlobalParent(
+      mozilla::dom::PWindowGlobalParent* aActor) override;
 
-  virtual IPCResult
-  RecvPWindowGlobalConstructor(mozilla::dom::PWindowGlobalParent* aActor,
-                               const WindowGlobalInit& aInit) override;
+  virtual IPCResult RecvPWindowGlobalConstructor(
+      mozilla::dom::PWindowGlobalParent* aActor,
+      const WindowGlobalInit& aInit) override;
 
-private:
+ private:
   // Lifecycle management is implemented in InProcessImpl.cpp
   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
   virtual void DeallocPInProcessParent() override;
   ~InProcessParent() = default;
 
   static void Startup();
   static void Shutdown();
 
   static StaticRefPtr<InProcessParent> sSingleton;
   static bool sShutdown;
 };
 
+}  // namespace ipc
+}  // namespace mozilla
 
-} // namespace ipc
-} // namespace mozilla
-
-#endif // defined(mozilla_ipc_InProcessParent_h)
+#endif  // defined(mozilla_ipc_InProcessParent_h)
--- a/js/public/TraceKind.h
+++ b/js/public/TraceKind.h
@@ -105,22 +105,21 @@ struct MapTypeToTraceKind {
   D(RegExpShared, js::RegExpShared, true)
 
 // Returns true if the JS::TraceKind is one the cycle collector cares about.
 // Everything used as WeakMap key should be listed here, to represent the key
 // in cycle collector's graph, otherwise the key is considered to be pointed
 // from somewhere unknown, and results in leaking the subgraph which contains
 // the key.
 // See the comments in NoteWeakMapsTracer::trace for more details.
-inline constexpr bool IsCCTraceKind(JS::TraceKind aKind)
-{
+inline constexpr bool IsCCTraceKind(JS::TraceKind aKind) {
   switch (aKind) {
 #define JS_EXPAND_DEF(name, _, isCCTraceKind) \
-    case JS::TraceKind::name: \
-      return isCCTraceKind;
+  case JS::TraceKind::name:                   \
+    return isCCTraceKind;
     JS_FOR_EACH_TRACEKIND(JS_EXPAND_DEF);
 #undef JS_EXPAND_DEF
     default:
       return false;
   }
 }
 
 // Map from all public types to their trace kind.
--- a/js/src/jit/arm64/Lowering-arm64.cpp
+++ b/js/src/jit/arm64/Lowering-arm64.cpp
@@ -210,19 +210,19 @@ void LIRGeneratorARM64::lowerDivI(MDiv* 
   if (div->fallible()) {
     assignSnapshot(lir, Bailout_DoubleOutput);
   }
   define(lir, div);
 }
 
 void LIRGeneratorARM64::lowerMulI(MMul* mul, MDefinition* lhs,
                                   MDefinition* rhs) {
-  LMulI* lir = new(alloc()) LMulI;
+  LMulI* lir = new (alloc()) LMulI;
   if (mul->fallible()) {
-      assignSnapshot(lir, Bailout_DoubleOutput);
+    assignSnapshot(lir, Bailout_DoubleOutput);
   }
   lowerForALU(lir, mul, lhs, rhs);
 }
 
 void LIRGeneratorARM64::lowerModI(MMod* mod) { MOZ_CRASH("lowerModI"); }
 
 void LIRGeneratorARM64::lowerDivI64(MDiv* div) { MOZ_CRASH("NYI"); }
 
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -1460,17 +1460,17 @@ extern JS_PUBLIC_API bool OrdinaryHasIns
                                               HandleObject objArg,
                                               HandleValue v, bool* bp);
 
 // Implementation of
 // https://www.ecma-international.org/ecma-262/6.0/#sec-instanceofoperator
 // This is almost identical to JS_HasInstance, except the latter may call a
 // custom hasInstance class op instead of InstanceofOperator.
 extern JS_PUBLIC_API bool InstanceofOperator(JSContext* cx, HandleObject obj,
-                                              HandleValue v, bool* bp);
+                                             HandleValue v, bool* bp);
 
 }  // namespace JS
 
 extern JS_PUBLIC_API void* JS_GetPrivate(JSObject* obj);
 
 extern JS_PUBLIC_API void JS_SetPrivate(JSObject* obj, void* data);
 
 extern JS_PUBLIC_API void* JS_GetInstancePrivate(JSContext* cx,
--- a/js/src/util/StructuredSpewer.cpp
+++ b/js/src/util/StructuredSpewer.cpp
@@ -171,17 +171,17 @@ void StructuredSpewer::parseSpewFlags(co
     selectedChannels_.enableChannel(SpewChannel::name); \
   }
 
   STRUCTURED_CHANNEL_LIST(CHECK_CHANNEL)
 
 #undef CHECK_CHANNEL
 
   if (ContainsFlag(flags, "help")) {
-     printf(
+    printf(
         "\n"
         "usage: SPEW=option,option,option,... where options can be:\n"
         "\n"
         "  help               Dump this help message\n"
         "  all|*              Enable all the below channels\n"
         "  channel[,channel]  Enable the selected channels from below\n"
         "\n"
         " Channels: \n"
@@ -203,17 +203,17 @@ void StructuredSpewer::parseSpewFlags(co
         "\n"
         "        A JSScript matches the filter string is found in the\n"
         "        signature\n"
         "\n"
         "   SPEW_UPLOAD: If this variable is set as well as MOZ_UPLOAD_DIR,\n"
         "        output goes to $MOZ_UPLOAD_DIR/spew_output* to ease usage\n"
         "        with Treeherder.\n"
 
-        );
+    );
     exit(0);
   }
 }
 
 AutoStructuredSpewer::AutoStructuredSpewer(JSContext* cx, SpewChannel channel,
                                            JSScript* script)
     : printer_(mozilla::Nothing()) {
   if (!cx->spewer().enabled(cx, script, channel)) {
--- a/layout/base/ScrollStyles.h
+++ b/layout/base/ScrollStyles.h
@@ -4,17 +4,17 @@
  * 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/. */
 
 #ifndef mozilla_ScrollStyles_h
 #define mozilla_ScrollStyles_h
 
 #include <stdint.h>
 #include "nsStyleConsts.h"
-#include "nsStyleCoord.h"   // for nsStyleCoord
+#include "nsStyleCoord.h"  // for nsStyleCoord
 #include "mozilla/dom/WindowBinding.h"
 
 // Forward declarations
 struct nsStyleDisplay;
 
 namespace mozilla {
 
 struct ScrollStyles {
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -1588,17 +1588,17 @@ nsXULScrollFrame::DoXULLayout(nsBoxLayou
 
 NS_QUERYFRAME_HEAD(nsXULScrollFrame)
   NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
   NS_QUERYFRAME_ENTRY(nsIScrollableFrame)
   NS_QUERYFRAME_ENTRY(nsIStatefulFrame)
   NS_QUERYFRAME_ENTRY(nsIScrollbarMediator)
 NS_QUERYFRAME_TAIL_INHERITING(nsBoxFrame)
 
-//-------------------- Helper ----------------------
+  //-------------------- Helper ----------------------
 
 #define SMOOTH_SCROLL_PREF_NAME "general.smoothScroll"
 
 // AsyncSmoothMSDScroll has ref counting.
 class ScrollFrameHelper::AsyncSmoothMSDScroll final
     : public nsARefreshObserver {
  public:
   AsyncSmoothMSDScroll(const nsPoint& aInitialPosition,
--- a/layout/printing/nsPrintJob.cpp
+++ b/layout/printing/nsPrintJob.cpp
@@ -41,17 +41,17 @@ static const char sPrintSettingsServiceC
 // Printing Events
 #include "nsPrintPreviewListener.h"
 #include "nsThreadUtils.h"
 
 // Printing
 #include "nsIWebBrowserPrint.h"
 
 // Print Preview
-#include "imgIContainer.h"       // image animation mode constants
+#include "imgIContainer.h"  // image animation mode constants
 
 // Print Progress
 #include "nsIPrintProgress.h"
 #include "nsIPrintProgressParams.h"
 #include "nsIObserver.h"
 
 // Print error dialog
 #include "nsIPrompt.h"
--- a/layout/xul/nsLeafBoxFrame.cpp
+++ b/layout/xul/nsLeafBoxFrame.cpp
@@ -87,18 +87,17 @@ void nsLeafBoxFrame::BuildDisplayList(ns
                                       const nsDisplayListSet& aLists) {
   // REVIEW: GetFrameForPoint used to not report events for the background
   // layer, whereas this code will put an event receiver for this frame in the
   // BlockBorderBackground() list. But I don't see any need to preserve
   // that anomalous behaviour. The important thing I'm preserving is that
   // leaf boxes continue to receive events in the foreground layer.
   DisplayBorderBackgroundOutline(aBuilder, aLists);
 
-  if (!aBuilder->IsForEventDelivery() || !IsVisibleForPainting())
-    return;
+  if (!aBuilder->IsForEventDelivery() || !IsVisibleForPainting()) return;
 
   aLists.Content()->AppendToTop(
       MakeDisplayItem<nsDisplayEventReceiver>(aBuilder, this));
 }
 
 /* virtual */ nscoord nsLeafBoxFrame::GetMinISize(
     gfxContext* aRenderingContext) {
   nscoord result;
--- a/layout/xul/tree/nsTreeBodyFrame.cpp
+++ b/layout/xul/tree/nsTreeBodyFrame.cpp
@@ -2559,18 +2559,17 @@ class nsDisplayTreeBody final : public n
     return GetBounds(aBuilder, &snap);
   }
 };
 
 // Painting routines
 void nsTreeBodyFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
                                        const nsDisplayListSet& aLists) {
   // REVIEW: why did we paint if we were collapsed? that makes no sense!
-  if (!IsVisibleForPainting())
-    return;  // We're invisible.  Don't paint.
+  if (!IsVisibleForPainting()) return;  // We're invisible.  Don't paint.
 
   // Handles painting our background, border, and outline.
   nsLeafBoxFrame::BuildDisplayList(aBuilder, aLists);
 
   // Bail out now if there's no view or we can't run script because the
   // document is a zombie
   if (!mView || !GetContent()->GetComposedDoc()->GetWindow()) return;
 
--- a/media/libdav1d/config/other/config.h
+++ b/media/libdav1d/config/other/config.h
@@ -19,9 +19,8 @@
 
 #define CONFIG_8BPC 1
 
 #define HAVE_ASM 0
 
 #define HAVE_POSIX_MEMALIGN 1
 
 #define HAVE_UNISTD_H 1
-
--- a/netwerk/base/NetworkConnectivityService.cpp
+++ b/netwerk/base/NetworkConnectivityService.cpp
@@ -78,18 +78,17 @@ void NetworkConnectivityService::Perform
 
   mIPv4 = UNKNOWN;
   mIPv6 = UNKNOWN;
 
   RecheckDNS();
   RecheckIPConnectivity();
 }
 
-static inline void NotifyObservers(const char *aTopic)
-{
+static inline void NotifyObservers(const char *aTopic) {
   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
   obs->NotifyObservers(nullptr, aTopic, nullptr);
 }
 
 NS_IMETHODIMP
 NetworkConnectivityService::OnLookupComplete(nsICancelable *aRequest,
                                              nsIDNSRecord *aRecord,
                                              nsresult aStatus) {
--- a/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
+++ b/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
@@ -1768,23 +1768,24 @@ nsUrlClassifierDBService::AsyncClassifyL
         }
         tables.Append(aExtraTablesByPrefs[i]);
       }
     }
 
     if (!tables.IsEmpty()) {
       nsCOMPtr<nsIURIClassifierCallback> callback(aCallback);
       nsCOMPtr<nsIRunnable> cbRunnable = NS_NewRunnableFunction(
-        "nsUrlClassifierDBService::AsyncClassifyLocalWithTables",
-        [callback, tables]() -> void {
-          callback->OnClassifyComplete(NS_OK, // Not used.
-                                       tables,
-                                       EmptyCString(),  // provider. (Not used)
-                                       EmptyCString()); // prefix. (Not used)
-        });
+          "nsUrlClassifierDBService::AsyncClassifyLocalWithTables",
+          [callback, tables]() -> void {
+            callback->OnClassifyComplete(
+                NS_OK,  // Not used.
+                tables,
+                EmptyCString(),   // provider. (Not used)
+                EmptyCString());  // prefix. (Not used)
+          });
 
       NS_DispatchToMainThread(cbRunnable);
       return NS_OK;
     }
   }
 
   nsAutoCString key;
   // Canonicalize the url
--- a/toolkit/recordreplay/HashTable.cpp
+++ b/toolkit/recordreplay/HashTable.cpp
@@ -106,18 +106,17 @@ class StableHashTableInfo {
  public:
   StableHashTableInfo()
       : mLastKey(nullptr),
         mLastNewHash(0),
         mHashGenerator(0),
         mCallbackStorage(nullptr),
         mDestroyed(false),
         mTable(nullptr),
-        mCallbackHash(0)
-  {
+        mCallbackHash(0) {
     // Use AllocateMemory, as the result will have RWX permissions.
     mCallbackStorage =
         (uint8_t*)AllocateMemory(CallbackStorageCapacity, MemoryKind::Tracked);
 
     MarkValid();
   }
 
   ~StableHashTableInfo() {
@@ -137,17 +136,18 @@ class StableHashTableInfo {
 
   void CheckIntegrity(void* aTable) {
     MOZ_RELEASE_ASSERT(aTable);
     if (!mTable) {
       mTable = aTable;
       mCallbackHash = HashBytes(mCallbackStorage, mCallbackStorageSize);
     } else {
       MOZ_RELEASE_ASSERT(mTable == aTable);
-      MOZ_RELEASE_ASSERT(mCallbackHash == HashBytes(mCallbackStorage, mCallbackStorageSize));
+      MOZ_RELEASE_ASSERT(mCallbackHash ==
+                         HashBytes(mCallbackStorage, mCallbackStorageSize));
     }
   }
 
   void AddKey(HashNumber aOriginalHash, const void* aKey, HashNumber aNewHash) {
     HashToKeyMap::iterator iter = mHashToKey.find(aOriginalHash);
     if (iter == mHashToKey.end()) {
       iter = mHashToKey
                  .insert(HashToKeyMap::value_type(aOriginalHash,
@@ -207,18 +207,17 @@ class StableHashTableInfo {
 
   class Assembler : public recordreplay::Assembler {
    public:
     StableHashTableInfo& mInfo;
 
     explicit Assembler(StableHashTableInfo& aInfo)
         : recordreplay::Assembler(aInfo.mCallbackStorage,
                                   CallbackStorageCapacity),
-          mInfo(aInfo)
-    {}
+          mInfo(aInfo) {}
 
     ~Assembler() {
       mInfo.mCallbackStorageSize = Current() - mInfo.mCallbackStorage;
     }
   };
 
   // Use the callback storage buffer to create a new function T which has one
   // fewer argument than S and calls S with aArgument bound to the last
@@ -419,17 +418,17 @@ void GeneratePLHashTableCallbacks(PLHash
   *aAllocOps = &gWrapPLHashAllocOps;
   *aAllocPrivate = info;
 }
 
 void DestroyPLHashTableCallbacks(void* aAllocPrivate) {
   PLHashTableInfo* info = PLHashTableInfo::MaybeFromPrivate(aAllocPrivate);
   if (info) {
     info->MarkDestroyed();
-    //delete info;
+    // delete info;
   }
 }
 
 void CheckPLHashTable(PLHashTable* aTable) {
   PLHashTableInfo* info = PLHashTableInfo::MaybeFromPrivate(aTable->allocPriv);
   if (info) {
     info->CheckIntegrity(aTable);
   }
--- a/toolkit/recordreplay/ProcessRedirectDarwin.cpp
+++ b/toolkit/recordreplay/ProcessRedirectDarwin.cpp
@@ -2501,73 +2501,73 @@ static SystemRedirection gSystemRedirect
 // unpredictable effects of inlining, diagnostic redirections may not be called
 // whenever the associated function is invoked, and should not be used to
 // modify Gecko's behavior.
 //
 // The address of the function to redirect is specified directly here, as we
 // cannot use dlsym() to lookup symbols that are not externally visible.
 
 // Functions which are not overloaded.
-#define FOR_EACH_DIAGNOSTIC_REDIRECTION(MACRO)                   \
-  MACRO(PL_HashTableAdd, Preamble_PLHashTable)                   \
-  MACRO(PL_HashTableRemove, Preamble_PLHashTable)                \
-  MACRO(PL_HashTableLookup, Preamble_PLHashTable)                \
-  MACRO(PL_HashTableLookupConst, Preamble_PLHashTable)           \
-  MACRO(PL_HashTableEnumerateEntries, Preamble_PLHashTable)      \
-  MACRO(PL_HashTableRawAdd, Preamble_PLHashTable)                \
-  MACRO(PL_HashTableRawRemove, Preamble_PLHashTable)             \
-  MACRO(PL_HashTableRawLookup, Preamble_PLHashTable)             \
+#define FOR_EACH_DIAGNOSTIC_REDIRECTION(MACRO)              \
+  MACRO(PL_HashTableAdd, Preamble_PLHashTable)              \
+  MACRO(PL_HashTableRemove, Preamble_PLHashTable)           \
+  MACRO(PL_HashTableLookup, Preamble_PLHashTable)           \
+  MACRO(PL_HashTableLookupConst, Preamble_PLHashTable)      \
+  MACRO(PL_HashTableEnumerateEntries, Preamble_PLHashTable) \
+  MACRO(PL_HashTableRawAdd, Preamble_PLHashTable)           \
+  MACRO(PL_HashTableRawRemove, Preamble_PLHashTable)        \
+  MACRO(PL_HashTableRawLookup, Preamble_PLHashTable)        \
   MACRO(PL_HashTableRawLookupConst, Preamble_PLHashTable)
 
 // Member functions which need a type specification to resolve overloading.
-#define FOR_EACH_DIAGNOSTIC_MEMBER_PTR_WITH_TYPE_REDIRECTION(MACRO) \
+#define FOR_EACH_DIAGNOSTIC_MEMBER_PTR_WITH_TYPE_REDIRECTION(MACRO)         \
   MACRO(PLDHashEntryHdr* (PLDHashTable::*)(const void*, const fallible_t&), \
         &PLDHashTable::Add, Preamble_PLDHashTable)
 
 // Member functions which are not overloaded.
-#define FOR_EACH_DIAGNOSTIC_MEMBER_PTR_REDIRECTION(MACRO)        \
-  MACRO(&PLDHashTable::Clear, Preamble_PLDHashTable)             \
-  MACRO(&PLDHashTable::Remove, Preamble_PLDHashTable)            \
+#define FOR_EACH_DIAGNOSTIC_MEMBER_PTR_REDIRECTION(MACRO) \
+  MACRO(&PLDHashTable::Clear, Preamble_PLDHashTable)      \
+  MACRO(&PLDHashTable::Remove, Preamble_PLDHashTable)     \
   MACRO(&PLDHashTable::RemoveEntry, Preamble_PLDHashTable)
 
-static PreambleResult
-Preamble_PLHashTable(CallArguments* aArguments)
-{
+static PreambleResult Preamble_PLHashTable(CallArguments* aArguments) {
   CheckPLHashTable(aArguments->Arg<0, PLHashTable*>());
   return PreambleResult::IgnoreRedirect;
 }
 
-static PreambleResult
-Preamble_PLDHashTable(CallArguments* aArguments)
-{
+static PreambleResult Preamble_PLDHashTable(CallArguments* aArguments) {
   CheckPLDHashTable(aArguments->Arg<0, PLDHashTable*>());
   return PreambleResult::IgnoreRedirect;
 }
 
 #define MAKE_DIAGNOSTIC_ENTRY_WITH_TYPE(aType, aAddress, aPreamble) \
-  { #aAddress, nullptr, nullptr, nullptr, aPreamble },
+  {#aAddress, nullptr, nullptr, nullptr, aPreamble},
 
 #define MAKE_DIAGNOSTIC_ENTRY(aAddress, aPreamble) \
-  { #aAddress, nullptr, nullptr, nullptr, aPreamble },
+  {#aAddress, nullptr, nullptr, nullptr, aPreamble},
 
 static Redirection gDiagnosticRedirections[] = {
+  // clang-format off
   FOR_EACH_DIAGNOSTIC_REDIRECTION(MAKE_DIAGNOSTIC_ENTRY)
   FOR_EACH_DIAGNOSTIC_MEMBER_PTR_WITH_TYPE_REDIRECTION(MAKE_DIAGNOSTIC_ENTRY_WITH_TYPE)
   FOR_EACH_DIAGNOSTIC_MEMBER_PTR_REDIRECTION(MAKE_DIAGNOSTIC_ENTRY)
+  // clang-format on
 };
 
+
 #undef MAKE_DIAGNOSTIC_ENTRY_WITH_TYPE
 #undef MAKE_DIAGNOSTIC_ENTRY
 
 ///////////////////////////////////////////////////////////////////////////////
 // Redirection generation
 ///////////////////////////////////////////////////////////////////////////////
 
 size_t NumRedirections() {
-  return ArrayLength(gSystemRedirections) + ArrayLength(gDiagnosticRedirections);
+  return ArrayLength(gSystemRedirections) +
+         ArrayLength(gDiagnosticRedirections);
 }
 
 static Redirection* gRedirections;
 
 Redirection& GetRedirection(size_t aCallId) {
   if (aCallId < ArrayLength(gSystemRedirections)) {
     return gRedirections[aCallId];
   }
@@ -2588,17 +2588,17 @@ static uint8_t* FunctionStartAddress(Red
   }
 
   return addr;
 }
 
 template <typename FnPtr>
 static uint8_t* ConvertMemberPtrToAddress(FnPtr aPtr) {
   // Dig around in clang's internal representation of member function pointers.
-  uint8_t** contents = (uint8_t**) &aPtr;
+  uint8_t** contents = (uint8_t**)&aPtr;
   return contents[0];
 }
 
 void EarlyInitializeRedirections() {
   size_t numSystemRedirections = ArrayLength(gSystemRedirections);
   gRedirections = new Redirection[numSystemRedirections];
   PodZero(gRedirections, numSystemRedirections);
 
@@ -2624,28 +2624,31 @@ void EarlyInitializeRedirections() {
           break;
         }
       }
     }
   }
 
   size_t diagnosticIndex = 0;
 
-#define LOAD_DIAGNOSTIC_ENTRY(aAddress, aPreamble) \
-  gDiagnosticRedirections[diagnosticIndex++].mBaseFunction = BitwiseCast<uint8_t*>(aAddress);
+#define LOAD_DIAGNOSTIC_ENTRY(aAddress, aPreamble)           \
+  gDiagnosticRedirections[diagnosticIndex++].mBaseFunction = \
+      BitwiseCast<uint8_t*>(aAddress);
   FOR_EACH_DIAGNOSTIC_REDIRECTION(LOAD_DIAGNOSTIC_ENTRY)
 #undef LOAD_DIAGNOSTIC_ENTRY
 
-#define LOAD_DIAGNOSTIC_ENTRY(aType, aAddress, aPreamble) \
-  gDiagnosticRedirections[diagnosticIndex++].mBaseFunction = ConvertMemberPtrToAddress<aType>(aAddress);
+#define LOAD_DIAGNOSTIC_ENTRY(aType, aAddress, aPreamble)    \
+  gDiagnosticRedirections[diagnosticIndex++].mBaseFunction = \
+      ConvertMemberPtrToAddress<aType>(aAddress);
   FOR_EACH_DIAGNOSTIC_MEMBER_PTR_WITH_TYPE_REDIRECTION(LOAD_DIAGNOSTIC_ENTRY)
 #undef LOAD_DIAGNOSTIC_ENTRY
 
-#define LOAD_DIAGNOSTIC_ENTRY(aAddress, aPreamble) \
-  gDiagnosticRedirections[diagnosticIndex++].mBaseFunction = ConvertMemberPtrToAddress(aAddress);
+#define LOAD_DIAGNOSTIC_ENTRY(aAddress, aPreamble)           \
+  gDiagnosticRedirections[diagnosticIndex++].mBaseFunction = \
+      ConvertMemberPtrToAddress(aAddress);
   FOR_EACH_DIAGNOSTIC_MEMBER_PTR_REDIRECTION(LOAD_DIAGNOSTIC_ENTRY)
 #undef LOAD_DIAGNOSTIC_ENTRY
 
   for (Redirection& redirection : gDiagnosticRedirections) {
     redirection.mOriginalFunction = redirection.mBaseFunction;
   }
 
   // Bind the gOriginal functions to their redirections' base addresses until we
--- a/widget/gtk/mozcontainer.cpp
+++ b/widget/gtk/mozcontainer.cpp
@@ -206,25 +206,25 @@ static void moz_container_unmap_wayland(
   g_clear_pointer(&container->surface, wl_surface_destroy);
   g_clear_pointer(&container->frame_callback_handler, wl_callback_destroy);
 
   container->surface_needs_clear = true;
   container->ready_to_draw = false;
 }
 
 static gint moz_container_get_scale(MozContainer *container) {
-    static auto sGdkWindowGetScaleFactorPtr = (gint(*)(GdkWindow *))dlsym(
-        RTLD_DEFAULT, "gdk_window_get_scale_factor");
+  static auto sGdkWindowGetScaleFactorPtr =
+      (gint(*)(GdkWindow *))dlsym(RTLD_DEFAULT, "gdk_window_get_scale_factor");
 
-    if (sGdkWindowGetScaleFactorPtr) {
-      GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(container));
-      return (*sGdkWindowGetScaleFactorPtr)(window);
-    }
+  if (sGdkWindowGetScaleFactorPtr) {
+    GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(container));
+    return (*sGdkWindowGetScaleFactorPtr)(window);
+  }
 
-    return 1;
+  return 1;
 }
 #endif
 
 void moz_container_map(GtkWidget *widget) {
   MozContainer *container;
   GList *tmp_list;
   GtkWidget *tmp_child;
 
@@ -347,18 +347,17 @@ void moz_container_size_allocate(GtkWidg
   // see gtk-clutter-embed.c for reference.
   if (container->subsurface) {
     gint x, y;
     gdk_window_get_position(gtk_widget_get_window(widget), &x, &y);
     wl_subsurface_set_position(container->subsurface, x, y);
   }
   if (container->eglwindow) {
     gint scale = moz_container_get_scale(container);
-    wl_egl_window_resize(container->eglwindow,
-                         allocation->width * scale,
+    wl_egl_window_resize(container->eglwindow, allocation->width * scale,
                          allocation->height * scale, 0, 0);
   }
 #endif
 }
 
 void moz_container_remove(GtkContainer *container, GtkWidget *child_widget) {
   MozContainerChild *child;
   MozContainer *moz_container;
@@ -501,19 +500,19 @@ struct wl_egl_window *moz_container_get_
   if (!container->eglwindow) {
     wl_surface *surface = moz_container_get_wl_surface(container);
     if (!surface) {
       return nullptr;
     }
 
     GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(container));
     gint scale = moz_container_get_scale(container);
-    container->eglwindow = wl_egl_window_create(
-        surface, gdk_window_get_width(window) * scale,
-                 gdk_window_get_height(window) * scale);
+    container->eglwindow =
+        wl_egl_window_create(surface, gdk_window_get_width(window) * scale,
+                             gdk_window_get_height(window) * scale);
   }
   return container->eglwindow;
 }
 
 gboolean moz_container_has_wl_egl_window(MozContainer *container) {
   return container->eglwindow ? true : false;
 }
 
--- a/xpcom/ds/PLDHashTable.h
+++ b/xpcom/ds/PLDHashTable.h
@@ -431,20 +431,17 @@ class PLDHashTable {
   ~PLDHashTable();
 
   // This should be used rarely.
   const PLDHashTableOps* Ops() const {
     return mozilla::recordreplay::UnwrapPLDHashTableCallbacks(mOps);
   }
 
   // Provide access to the raw ops to internal record/replay structures.
-  const PLDHashTableOps* RecordReplayWrappedOps() const
-  {
-    return mOps;
-  }
+  const PLDHashTableOps* RecordReplayWrappedOps() const { return mOps; }
 
   // Size in entries (gross, not net of free and removed sentinels) for table.
   // This can be zero if no elements have been added yet, in which case the
   // entry storage will not have yet been allocated.
   uint32_t Capacity() const {
     return mEntryStore.Get() ? CapacityFromHashShift() : 0;
   }