Backed out 2 changesets (bug 1508472) for causing build bustages on JobScheduler_posix.cpp. CLOSED TREE
authorCosmin Sabou <csabou@mozilla.com>
Wed, 28 Nov 2018 00:08:11 +0200
changeset 504817 193a2a5ad0e6148fa266929af17ff2d897af9f12
parent 504816 cd922858805d95123ce8cbab50a23cc365c7fe39
child 504818 54e6db47c59eecfccc644236eb86255d903fcb79
push id10290
push userffxbld-merge
push dateMon, 03 Dec 2018 16:23:23 +0000
treeherdermozilla-beta@700bed2445e6 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1508472
milestone65.0a1
backs outaf951294cf96812660b2ac9918eb6df32758d420
2320933cb7bc8255b7e484df1ef27718154362d5
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
Backed out 2 changesets (bug 1508472) for causing build bustages on JobScheduler_posix.cpp. CLOSED TREE Backed out changeset af951294cf96 (bug 1508472) Backed out changeset 2320933cb7bc (bug 1508472)
dom/html/nsIFormProcessor.h
dom/indexedDB/Key.cpp
dom/media/DOMMediaStream.h
dom/media/webaudio/blink/DynamicsCompressorKernel.cpp
dom/media/webaudio/blink/HRTFDatabase.h
dom/media/webaudio/blink/HRTFKernel.h
dom/media/webaudio/blink/IIRFilter.cpp
dom/plugins/base/npapi.h
dom/plugins/base/nsPluginLogging.h
dom/plugins/ipc/FunctionBroker.h
dom/plugins/test/testplugin/nptest.cpp
dom/presentation/PresentationSessionInfo.cpp
dom/promise/PromiseWorkerProxy.h
dom/security/nsCSPContext.cpp
dom/security/nsCSPParser.h
dom/security/nsMixedContentBlocker.cpp
dom/security/test/gtest/TestCSPParser.cpp
dom/serviceworkers/ServiceWorkerManager.cpp
dom/websocket/WebSocket.h
dom/xbl/nsXBLBinding.cpp
dom/xbl/nsXBLPrototypeBinding.cpp
dom/xbl/nsXBLService.cpp
dom/xslt/base/txList.h
dom/xslt/xpath/txBooleanResult.cpp
editor/libeditor/HTMLEditorDocumentCommands.cpp
editor/libeditor/HTMLTableEditor.cpp
editor/spellchecker/TextServicesDocument.cpp
extensions/cookie/nsPermissionManager.cpp
extensions/spellcheck/src/mozPersonalDictionary.cpp
gfx/2d/2D.h
gfx/2d/Blur.cpp
gfx/2d/DrawTargetSkia.cpp
gfx/2d/DrawTargetWrapAndRecord.h
gfx/2d/FilterProcessingSIMD-inl.h
gfx/2d/HelpersD2D.h
gfx/2d/JobScheduler_posix.cpp
gfx/2d/Logging.h
gfx/2d/Path.cpp
gfx/2d/Swizzle.cpp
gfx/2d/SwizzleNEON.cpp
gfx/gl/ForceDiscreteGPUHelperCGL.h
gfx/gl/GLContextProviderWGL.cpp
layout/base/nsBidi.h
layout/base/nsCSSFrameConstructor.cpp
layout/base/nsDocumentViewer.cpp
layout/base/nsIPresShell.h
layout/forms/nsComboboxControlFrame.cpp
layout/forms/nsComboboxControlFrame.h
layout/generic/nsBulletFrame.cpp
layout/generic/nsColumnSetFrame.cpp
layout/generic/nsFlexContainerFrame.cpp
layout/generic/nsFrame.cpp
layout/generic/nsFrameSelection.h
layout/generic/nsFrameSetFrame.cpp
layout/generic/nsIFrame.h
layout/generic/nsLineLayout.cpp
layout/mathml/nsIMathMLFrame.h
layout/mathml/nsMathMLContainerFrame.h
layout/mathml/nsMathMLmpaddedFrame.cpp
layout/mathml/nsMathMLmunderoverFrame.cpp
layout/style/StyleSheet.cpp
layout/style/nsCSSProps.h
layout/svg/SVGTextFrame.cpp
layout/tables/celldata.h
layout/tables/nsCellMap.h
layout/tables/nsTableFrame.cpp
layout/tables/nsTableRowFrame.h
layout/tables/nsTableRowGroupFrame.h
layout/xul/BoxObject.cpp
layout/xul/grid/nsGrid.cpp
layout/xul/nsScrollbarFrame.cpp
--- a/dom/html/nsIFormProcessor.h
+++ b/dom/html/nsIFormProcessor.h
@@ -47,22 +47,19 @@ public:
 
   /* ProcessValue is called for each name value pair that is
    * about to be submitted for both "get" and "post" form submissions.
    *
    * The formprocessor is registered as a service that gets called for
    * every form submission.
    *
    *   @param aElement element which the attribute/value pair is submitted for
-   *   @param aName    value of the form element name attribute about to be
-   *                   submitted
-   *   @param aValue   On entry it contains the value about to be submitted
-   *                   for aName.
-   *                   On exit it contains the value which will actually be
-   *                   submitted for aName.
+   *   @param aName    value of the form element name attribute about to be submitted
+   *   @param aValue   On entry it contains the value about to be submitted for aName.
+   *                   On exit it contains the value which will actually be submitted for aName.
    *
    */
   virtual nsresult ProcessValue(mozilla::dom::Element* aElement,
                                 const nsAString& aName,
                                 nsAString& aValue) = 0;
 
   /**
    * The same as above, but with the element unpacked so that this can be
@@ -73,20 +70,18 @@ public:
                                    const nsAString& aChallenge,
                                    const nsAString& aKeyParams,
                                    nsAString& newValue) = 0;
 
   /* Provide content for a form element. This method provides a mechanism to provide
    * content which comes from a source other than the document (i.e. a local database)
    *
    *   @param aFormType   Type of form to get content for.
-   *   @param aOptions    List of nsStrings which define the contents for the
-   *                      form element
-   *   @param aAttr       Attribute to be attached to the form element. It is
-   *                      used to identify
+   *   @param aOptions    List of nsStrings which define the contents for the form element
+   *   @param aAttr       Attribute to be attached to the form element. It is used to identify
    *                      the form element contains non-standard content.
    */
 
   virtual nsresult ProvideContent(const nsAString& aFormType,
                                   nsTArray<nsString>& aContent,
                                   nsAString& aAttribute) = 0;
 
 };
--- a/dom/indexedDB/Key.cpp
+++ b/dom/indexedDB/Key.cpp
@@ -48,18 +48,17 @@ namespace indexedDB {
  value < 0 ?
    (-to64bitInt(value)) :
    (to64bitInt(value) | 0x8000000000000000)
 
 
  When encoding strings, we use variable-size encoding per the following table
 
  Chars 0         - 7E           are encoded as 0xxxxxxx with 1 added
- Chars 7F        - (3FFF+7F)    are encoded as 10xxxxxx xxxxxxxx with 7F
-                                subtracted
+ Chars 7F        - (3FFF+7F)    are encoded as 10xxxxxx xxxxxxxx with 7F subtracted
  Chars (3FFF+80) - FFFF         are encoded as 11xxxxxx xxxxxxxx xx000000
 
  This ensures that the first byte is never encoded as 0, which means that the
  string terminator (per basic-stategy table) sorts before any character.
  The reason that (3FFF+80) - FFFF is encoded "shifted up" 6 bits is to maximize
  the chance that the last character is 0. See below for why.
 
  When encoding binaries, the algorithm is the same to how strings are encoded.
--- a/dom/media/DOMMediaStream.h
+++ b/dom/media/DOMMediaStream.h
@@ -147,27 +147,25 @@ class Pledge;
  *    var Z = B.getTracks()[0];
  *    A.addTrack(Z);
  *    A.removeTrack(X);
  *    B.removeTrack(Z);
  *    var A' = A.clone();
  *
  * DOMStream A
  *           Input        Owned          Playback
- *            t1 ---------> t1                      <- MediaStreamTrack X
- *                                                     (removed)
+ *            t1 ---------> t1                      <- MediaStreamTrack X (removed)
  *                                                     (pointing to t1 in A)
  *            t2 ---------> t2 ------------> t2     <- MediaStreamTrack Y
  *             \                                       (pointing to t2 in A)
  *              \                    ------> t3     <- MediaStreamTrack Z
  *               \                  /                  (pointing to t1 in B)
  * DOMStream B    \                /
  *           Input \      Owned   /      Playback
- *            t1 ---^-----> t1 ---                  <- MediaStreamTrack Z
- *                                                     (removed)
+ *            t1 ---^-----> t1 ---                  <- MediaStreamTrack Z (removed)
  *              \    \                                 (pointing to t1 in B)
  *               \    \
  * DOMStream A'   \    \
  *           Input \    \ Owned          Playback
  *                  \    -> t1 ------------> t1     <- MediaStreamTrack Y'
  *                   \                                 (pointing to t1 in A')
  *                    ----> t2 ------------> t2     <- MediaStreamTrack Z'
  *                                                     (pointing to t2 in A')
--- a/dom/media/webaudio/blink/DynamicsCompressorKernel.cpp
+++ b/dom/media/webaudio/blink/DynamicsCompressorKernel.cpp
@@ -271,18 +271,17 @@ void DynamicsCompressorKernel::process(f
     // y = a + b*x + c*x^2 + d*x^3 + e*x^4;
 
     float y1 = releaseFrames * releaseZone1;
     float y2 = releaseFrames * releaseZone2;
     float y3 = releaseFrames * releaseZone3;
     float y4 = releaseFrames * releaseZone4;
 
     // All of these coefficients were derived for 4th order polynomial curve fitting where the y values
-    // match the evenly spaced x values as follows:
-    //  (y1 : x == 0, y2 : x == 1, y3 : x == 2, y4 : x == 3)
+    // match the evenly spaced x values as follows: (y1 : x == 0, y2 : x == 1, y3 : x == 2, y4 : x == 3)
     float kA = 0.9999999999999998f*y1 + 1.8432219684323923e-16f*y2 - 1.9373394351676423e-16f*y3 + 8.824516011816245e-18f*y4;
     float kB = -1.5788320352845888f*y1 + 2.3305837032074286f*y2 - 0.9141194204840429f*y3 + 0.1623677525612032f*y4;
     float kC = 0.5334142869106424f*y1 - 1.272736789213631f*y2 + 0.9258856042207512f*y3 - 0.18656310191776226f*y4;
     float kD = 0.08783463138207234f*y1 - 0.1694162967925622f*y2 + 0.08588057951595272f*y3 - 0.00429891410546283f*y4;
     float kE = -0.042416883008123074f*y1 + 0.1115693827987602f*y2 - 0.09764676325265872f*y3 + 0.028494263462021576f*y4;
 
     // x ranges from 0 -> 3       0    1    2   3
     //                           -15  -10  -5   0db
--- a/dom/media/webaudio/blink/HRTFDatabase.h
+++ b/dom/media/webaudio/blink/HRTFDatabase.h
@@ -37,22 +37,20 @@
 namespace WebCore {
 
 class HRTFKernel;
 
 class HRTFDatabase {
 public:
     static nsReturnRef<HRTFDatabase> create(float sampleRate);
 
-    // clang-format off
     // getKernelsFromAzimuthElevation() returns a left and right ear kernel, and an interpolated left and right frame delay for the given azimuth and elevation.
     // azimuthBlend must be in the range 0 -> 1.
     // Valid values for azimuthIndex are 0 -> HRTFElevation::NumberOfTotalAzimuths - 1 (corresponding to angles of 0 -> 360).
     // Valid values for elevationAngle are MinElevation -> MaxElevation.
-    // clang-format on
     void getKernelsFromAzimuthElevation(double azimuthBlend, unsigned azimuthIndex, double elevationAngle, HRTFKernel* &kernelL, HRTFKernel* &kernelR, double& frameDelayL, double& frameDelayR);
 
     // Returns the number of different azimuth angles.
     static unsigned numberOfAzimuths() { return HRTFElevation::NumberOfTotalAzimuths; }
 
     float sampleRate() const { return m_sampleRate; }
 
     // Number of elevations loaded from resource.
--- a/dom/media/webaudio/blink/HRTFKernel.h
+++ b/dom/media/webaudio/blink/HRTFKernel.h
@@ -38,18 +38,17 @@
 namespace WebCore {
 
 using mozilla::FFTBlock;
 
 // HRTF stands for Head-Related Transfer Function.
 // HRTFKernel is a frequency-domain representation of an impulse-response used as part of the spatialized panning system.
 // For a given azimuth / elevation angle there will be one HRTFKernel for the left ear transfer function, and one for the right ear.
 // The leading delay (average group delay) for each impulse response is extracted:
-//      m_fftFrame is the frequency-domain representation of the impulse
-//                 response with the delay removed
+//      m_fftFrame is the frequency-domain representation of the impulse response with the delay removed
 //      m_frameDelay is the leading delay of the original impulse response.
 class HRTFKernel {
 public:
     // Note: this is destructive on the passed in |impulseResponse|.
     // The |length| of |impulseResponse| must be a power of two.
     // The size of the DFT will be |2 * length|.
     static nsReturnRef<HRTFKernel> create(float* impulseResponse, size_t length, float sampleRate);
 
--- a/dom/media/webaudio/blink/IIRFilter.cpp
+++ b/dom/media/webaudio/blink/IIRFilter.cpp
@@ -112,18 +112,17 @@ void IIRFilter::getFrequencyResponse(int
 {
     // Evaluate the z-transform of the filter at the given normalized frequencies from 0 to 1. (One
     // corresponds to the Nyquist frequency.)
     //
     // The z-tranform of the filter is
     //
     // H(z) = sum(b[k]*z^(-k), k, 0, M) / sum(a[k]*z^(-k), k, 0, N);
     //
-    // The desired frequency response is H(exp(j*omega)), where omega is in
-    // [0, 1).
+    // The desired frequency response is H(exp(j*omega)), where omega is in [0, 1).
     //
     // Let P(x) = sum(c[k]*x^k, k, 0, P) be a polynomial of order P.  Then each of the sums in H(z)
     // is equivalent to evaluating a polynomial at the point 1/z.
 
     for (int k = 0; k < nFrequencies; ++k) {
         // zRecip = 1/z = exp(-j*frequency)
         double omega = -M_PI * frequency[k];
         std::complex<double> zRecip = std::complex<double>(cos(omega), sin(omega));
--- a/dom/plugins/base/npapi.h
+++ b/dom/plugins/base/npapi.h
@@ -58,17 +58,16 @@
 /*----------------------------------------------------------------------*/
 /*                        Plugin Version Constants                      */
 /*----------------------------------------------------------------------*/
 
 #define NP_VERSION_MAJOR 0
 #define NP_VERSION_MINOR 29
 
 
-/* clang-format off */
 /* The OS/2 version of Netscape uses RC_DATA to define the
    mime types, file extensions, etc that are required.
    Use a vertical bar to separate types, end types with \0.
    FileVersion and ProductVersion are 32bit ints, all other
    entries are strings that MUST be terminated with a \0.
 
 AN EXAMPLE:
 
@@ -84,17 +83,16 @@ RCDATA NP_INFO_FileOpenName{ "MMOS2 vide
 RCDATA NP_INFO_FileVersion       { 1,0,0,1 }
 RCDATA NP_INFO_CompanyName       { "Netscape Communications\0" }
 RCDATA NP_INFO_FileDescription   { "NPAVI32 Extension DLL\0"
 RCDATA NP_INFO_InternalName      { "NPAVI32\0" )
 RCDATA NP_INFO_LegalCopyright    { "Copyright Netscape Communications \251 1996\0"
 RCDATA NP_INFO_OriginalFilename  { "NVAPI32.DLL" }
 RCDATA NP_INFO_ProductName       { "NPAVI32 Dynamic Link Library\0" }
 */
-/* clang-format on */
 /* RC_DATA types for version info - required */
 #define NP_INFO_ProductVersion      1
 #define NP_INFO_MIMEType            2
 #define NP_INFO_FileOpenName        3
 #define NP_INFO_FileExtents         4
 /* RC_DATA types for version info - used if found */
 #define NP_INFO_FileDescription     5
 #define NP_INFO_ProductName         6
--- a/dom/plugins/base/nsPluginLogging.h
+++ b/dom/plugins/base/nsPluginLogging.h
@@ -26,19 +26,18 @@
 #define PLUGIN_LOG_ALWAYS mozilla::LogLevel::Error
 #define PLUGIN_LOG_BASIC  mozilla::LogLevel::Info
 #define PLUGIN_LOG_NORMAL mozilla::LogLevel::Debug
 #define PLUGIN_LOG_NOISY  mozilla::LogLevel::Verbose
 
 // 2. You can combine logs and levels by separating them with a comma:
 //    My favorite Win32 Example: SET MOZ_LOG=Plugin:5,PluginNPP:5,PluginNPN:5
 
-// 3. Instead of output going to the console, you can log to a file.
-//    Additionally, set the MOZ_LOG_FILE environment variable to point to the
-//    full path of a file.
+// 3. Instead of output going to the console, you can log to a file. Additionally, set the
+//    MOZ_LOG_FILE environment variable to point to the full path of a file.
 //    My favorite Win32 Example: SET MOZ_LOG_FILE=c:\temp\pluginLog.txt
 
 // 4. For complete information see the Gecko Developer guide:
 // https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Gecko_Logging
 
 
 class nsPluginLogging
 {
--- a/dom/plugins/ipc/FunctionBroker.h
+++ b/dom/plugins/ipc/FunctionBroker.h
@@ -49,18 +49,17 @@
  * Step 1: Add a typedef or subclass of either FunctionHook (non-brokering) or
  * FunctionBroker (automatic brokering) to FunctionBroker.cpp, using a new
  * FunctionHookID (added to that enum).
  * For example:
  *   typedef FunctionBroker<ID_GetKeyState, decltype(GetKeyState)> GetKeyStateFB
  * Use a subclass instead of a typedef if you need to maintain data or state.
  *
  * Step 2: Add an instance of that object to the FunctionHookList in
- * AddFunctionHook(FunctionHookList&) or
- * AddBrokeredFunctionHook(FunctionHookList&).
+ * AddFunctionHook(FunctionHookList&) or AddBrokeredFunctionHook(FunctionHookList&).
  * This typically just means calling the constructor with the correct info.
  * At a minimum, this means supplying the names of the DLL and method to
  * broker, and a pointer to the original version of the method.
  * For example:
  *   aHooks[ID_GetKeyState] =
  *     new GetKeyStateFB("user32.dll", "GetKeyState", &GetKeyState);
  *
  * Step 3: If brokering, make sure the system can (un)marshal the parameters,
@@ -77,19 +76,17 @@
  *   parameters to client:
  *
  * If a system call changes a parameter call-by-reference style then the
  * parameter's value needs to be returned to the client.  The FunctionBroker
  * has "phase" (request/response) objects that it uses to determine which
  * parameters are sent/returned.  This example tells InternetWriteFileFB to
  * return its third parameter:
  *   template<> template<>
- *   struct InternetWriteFileFB::Response::Info::ShouldMarshal<3> {
- *     static const bool value = true;
- *   };
+ *   struct InternetWriteFileFB::Response::Info::ShouldMarshal<3> { static const bool value = true; };
  * By default, all parameters have ShouldMarshal set in the request phase
  * and only the return value (parameter -1) has it set in the response phase.
  *
  * * Marshalling special parameter/return types:
  *
  * The IPCTypeMap in FunctionBroker maps a parameter or return type
  * to a type that IpdlTuple knows how to marshal.  By default, the map is
  * the identity but some types need special handling.
@@ -111,26 +108,23 @@
  * there.  A wise approach is to map your complex parameters into a simpler
  * parameter list and delegate the Marshal/Unmarshal calls to them.  For
  * example, an API might take a void* and an int as a buffer and length.
  * Obviously a void* cannot generally be marshaled.  However,  we can delegate
  * this call to a parameter list that takes a string in place of the buffer and
  * length.  Something like:
  *
  * typedef RequestHandler<ID_HookedFunc,
- *                        int HOOK_CALL (nsDependentCSubstring)>
- *   HookedFuncDelegateReq;
+ *                        int HOOK_CALL (nsDependentCSubstring)> HookedFuncDelegateReq;
  *
  * template<>
- * void HookedFuncFB::Request::Marshal(IpdlTuple& aTuple, const void*& aBuf,
- *                                     const int& aBufLen)
+ * void HookedFuncFB::Request::Marshal(IpdlTuple& aTuple, const void*& aBuf, const int& aBufLen)
  * {
  *   MOZ_ASSERT(nWritten);
- *   HookedFuncDelegateReq::Marshal(aTuple,
- *                                  nsDependentCSubstring(aBuf, aBufLen));
+ *   HookedFuncDelegateReq::Marshal(aTuple, nsDependentCSubstring(aBuf, aBufLen));
  * }
  *
  * template<>
  * bool HookedFuncFB::Request::Unmarshal(ServerCallData& aScd, const IpdlTuple& aTuple,
  *                                       void*& aBuf, int& aBufLen)
  * {
  *   nsDependentCSubstring str;
  *   if (!HookedFuncDelegateReq::Unmarshal(aScd, aTuple, str)) {
--- a/dom/plugins/test/testplugin/nptest.cpp
+++ b/dom/plugins/test/testplugin/nptest.cpp
@@ -2451,18 +2451,17 @@ convertPointY(NPObject* npobj, const NPV
 
   DOUBLE_TO_NPVARIANT(resultY, *result);
   return true;
 }
 
 static bool
 streamTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
-  // .streamTest(url, doPost, postData, writeCallback, notifyCallback,
-  //             redirectCallback, allowRedirects, postFile = false)
+  // .streamTest(url, doPost, postData, writeCallback, notifyCallback, redirectCallback, allowRedirects, postFile = false)
   if (!(7 <= argCount && argCount <= 8))
     return false;
 
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
 
   if (!NPVARIANT_IS_STRING(args[0]))
     return false;
   NPString url = NPVARIANT_TO_STRING(args[0]);
--- a/dom/presentation/PresentationSessionInfo.cpp
+++ b/dom/presentation/PresentationSessionInfo.cpp
@@ -1139,18 +1139,17 @@ PresentationControllingInfo::NotifyData(
 }
 
 /**
  * Implementation of PresentationPresentingInfo
  *
  * During presentation session establishment, the receiver expects the following
  * after trying to launch the app by notifying "presentation-launch-receiver":
  * (The order between step 2 and 3 is not guaranteed.)
- * 1. |Observe| of |nsIObserver| is called with
- *    "presentation-receiver-launched".
+ * 1. |Observe| of |nsIObserver| is called with "presentation-receiver-launched".
  *    Then start listen to document |STATE_TRANSFERRING| event.
  * 2. |NotifyResponderReady| is called to indicate the receiver page is ready
  *    for presentation use.
  * 3. |OnOffer| of |nsIPresentationControlChannelListener| is called.
  * 4. Once both step 2 and 3 are done, establish the data transport channel and
  *    send the answer. (The control channel will be closed by the sender once it
  *    receives the answer.)
  * 5. |NotifyTransportReady| of |nsIPresentationSessionTransportCallback| is
--- a/dom/promise/PromiseWorkerProxy.h
+++ b/dom/promise/PromiseWorkerProxy.h
@@ -24,18 +24,17 @@ class WorkerPrivate;
 // A proxy to (eventually) mirror a resolved/rejected Promise's result from the
 // main thread to a Promise on the worker thread.
 //
 // How to use:
 //
 //   1. Create a Promise on the worker thread and return it to the content
 //      script:
 //
-//        RefPtr<Promise> promise =
-//          Promise::Create(workerPrivate->GlobalScope(), aRv);
+//        RefPtr<Promise> promise = Promise::Create(workerPrivate->GlobalScope(), aRv);
 //        if (aRv.Failed()) {
 //          return nullptr;
 //        }
 //
 //   2. Create a PromiseWorkerProxy wrapping the Promise. If this fails, the
 //      worker is shutting down and you should fail the original call. This is
 //      only likely to happen in (Gecko-specific) worker onclose handlers.
 //
@@ -75,18 +74,17 @@ class WorkerPrivate;
 //          // Worker has already shut down, can't access worker private.
 //          return;
 //        }
 //
 //   2. Dispatch a runnable to the worker. Use GetWorkerPrivate() to acquire the
 //      worker.
 //
 //        RefPtr<FinishTaskWorkerRunnable> runnable =
-//          new FinishTaskWorkerRunnable(proxy->GetWorkerPrivate(), proxy,
-//                                       result);
+//          new FinishTaskWorkerRunnable(proxy->GetWorkerPrivate(), proxy, result);
 //        if (!r->Dispatch()) {
 //          // Worker is alive but not Running any more, so the Promise can't
 //          // be resolved, give up. The proxy will get Release()d at some
 //          // point.
 //
 //          // Usually do nothing, but you may want to log the fact.
 //        }
 //
--- a/dom/security/nsCSPContext.cpp
+++ b/dom/security/nsCSPContext.cpp
@@ -544,22 +544,20 @@ nsCSPContext::GetAllowsInline(nsContentP
  * which is why we must check allows() again here.
  *
  * Note: This macro uses some parameters from its caller's context:
  * p, mPolicies, this, aSourceFile, aScriptSample, aLineNum, aColumnNum,
  * blockedContentSource
  *
  * @param violationType: the VIOLATION_TYPE_* constant (partial symbol)
  *                 such as INLINE_SCRIPT
- * @param contentPolicyType: a constant from nsIContentPolicy such as
- *                           TYPE_STYLESHEET
+ * @param contentPolicyType: a constant from nsIContentPolicy such as TYPE_STYLESHEET
  * @param nonceOrHash: for NONCE and HASH violations, it's the nonce or content
  *               string. For other violations, it is an empty string.
- * @param keyword: the keyword corresponding to violation (UNSAFE_INLINE for
- *                 most)
+ * @param keyword: the keyword corresponding to violation (UNSAFE_INLINE for most)
  * @param observerTopic: the observer topic string to send with the CSP
  *                 observer notifications.
  *
  * Please note that inline violations for scripts are reported within
  * GetAllowsInline() and do not call this macro, hence we can pass 'false'
  * as the argument _aParserCreated_ to allows().
  */
 #define CASE_CHECK_AND_REPORT(violationType, contentPolicyType, nonceOrHash,   \
--- a/dom/security/nsCSPParser.h
+++ b/dom/security/nsCSPParser.h
@@ -118,43 +118,40 @@ class nsCSPParser {
 /**
  * When parsing the policy, the parser internally uses the following helper
  * variables/members which are used/reset during parsing. The following
  * example explains how they are used.
  * The tokenizer separats all input into arrays of arrays of strings, which
  * are stored in mTokens, for example:
  *   mTokens = [ [ script-src, http://www.example.com, 'self' ], ... ]
  *
- * When parsing starts, mCurdir always holds the currently processed array of
- * strings.
+ * When parsing starts, mCurdir always holds the currently processed array of strings.
  * In our example:
  *   mCurDir = [ script-src, http://www.example.com, 'self' ]
  *
  * During parsing, we process/consume one string at a time of that array.
  * We set mCurToken to the string we are currently processing; in the first case
  * that would be:
  *   mCurToken = script-src
  * which allows to do simple string comparisons to see if mCurToken is a valid directive.
  *
- * Continuing parsing, the parser consumes the next string of that array,
- * resetting:
+ * Continuing parsing, the parser consumes the next string of that array, resetting:
  *   mCurToken = "http://www.example.com"
  *                ^                     ^
  *                mCurChar              mEndChar (points *after* the 'm')
  *   mCurValue = ""
  *
- * After calling advance() the first time, helpers would hold the following
- * values:
+ * After calling advance() the first time, helpers would hold the following values:
  *   mCurToken = "http://www.example.com"
  *                 ^                    ^
  *                 mCurChar             mEndChar (points *after* the 'm')
  *  mCurValue = "h"
  *
- * We continue parsing till all strings of one directive are consumed, then we
- * reset mCurDir to hold the next array of strings and start the process all over.
+ * We continue parsing till all strings of one directive are consumed, then we reset
+ * mCurDir to hold the next array of strings and start the process all over.
  */
 
     const char16_t*    mCurChar;
     const char16_t*    mEndChar;
     nsString           mCurValue;
     nsString           mCurToken;
     nsTArray<nsString> mCurDir;
 
--- a/dom/security/nsMixedContentBlocker.cpp
+++ b/dom/security/nsMixedContentBlocker.cpp
@@ -637,20 +637,19 @@ nsMixedContentBlocker::ShouldLoad(bool a
   // 2) if aRequestingContext yields a principal but no location, we check
   //    if its the system principal. If it is, allow the load.
   // 3) Special case handling for:
   //    a) speculative loads, where shouldLoad is called twice (bug 839235)
   //       and the first speculative load does not include a context.
   //       In this case we use aRequestingLocation to set requestingLocation.
   //    b) TYPE_CSP_REPORT which does not provide a context. In this case we
   //       use aRequestingLocation to set requestingLocation.
-  //    c) content scripts from addon code that do not provide
-  //       aRequestingContext or aRequestingLocation, but do provide
-  //       aRequestPrincipal. If aRequestPrincipal is an expanded principal,
-  //       we allow the load.
+  //    c) content scripts from addon code that do not provide aRequestingContext
+  //       or aRequestingLocation, but do provide aRequestPrincipal.
+  //       If aRequestPrincipal is an expanded principal, we allow the load.
   // 4) If we still end up not having a requestingLocation, we reject the load.
 
   nsCOMPtr<nsIPrincipal> principal;
   // 1a) Try to get the principal if aRequestingContext is a node.
   nsCOMPtr<nsINode> node = do_QueryInterface(aRequestingContext);
   if (node) {
     principal = node->NodePrincipal();
   }
--- a/dom/security/test/gtest/TestCSPParser.cpp
+++ b/dom/security/test/gtest/TestCSPParser.cpp
@@ -174,17 +174,16 @@ nsresult runTestSuite(const PolicyTest* 
 }
 
 // ============================= TestDirectives ========================
 
 TEST(CSPParser, Directives)
 {
   static const PolicyTest policies[] =
   {
-    // clang-format off
     { "connect-src xn--mnchen-3ya.de",
       "connect-src http://xn--mnchen-3ya.de"},
     { "default-src http://www.example.com",
       "default-src http://www.example.com" },
     { "script-src http://www.example.com",
       "script-src http://www.example.com" },
     { "object-src http://www.example.com",
       "object-src http://www.example.com" },
@@ -217,56 +216,52 @@ TEST(CSPParser, Directives)
     { "script-src 'nonce-foo' 'strict-dynamic' 'unsafe-inline' https:  ",
       "script-src 'nonce-foo' 'strict-dynamic' 'unsafe-inline' https:" },
     { "default-src 'sha256-siVR8' 'strict-dynamic' 'unsafe-inline' https:  ",
       "default-src 'sha256-siVR8' 'unsafe-inline' https:" },
     { "worker-src https://example.com",
       "worker-src https://example.com" },
     { "worker-src http://worker.com; frame-src http://frame.com; child-src http://child.com",
       "worker-src http://worker.com; frame-src http://frame.com; child-src http://child.com" },
-    // clang-format on
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
 // ============================= TestKeywords ========================
 
 TEST(CSPParser, Keywords)
 {
   static const PolicyTest policies[] =
   {
-    // clang-format off
     { "script-src 'self'",
       "script-src 'self'" },
     { "script-src 'unsafe-inline'",
       "script-src 'unsafe-inline'" },
     { "script-src 'unsafe-eval'",
       "script-src 'unsafe-eval'" },
     { "script-src 'unsafe-inline' 'unsafe-eval'",
       "script-src 'unsafe-inline' 'unsafe-eval'" },
     { "script-src 'none'",
       "script-src 'none'" },
     { "img-src 'none'; script-src 'unsafe-eval' 'unsafe-inline'; default-src 'self'",
       "img-src 'none'; script-src 'unsafe-eval' 'unsafe-inline'; default-src 'self'" },
-    // clang-format on
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
-// =================== TestIgnoreUpperLowerCasePolicies ==============
+// ============================= TestIgnoreUpperLowerCasePolicies ========================
 
 TEST(CSPParser, IgnoreUpperLowerCasePolicies)
 {
   static const PolicyTest policies[] =
   {
-    // clang-format off
     { "script-src 'SELF'",
       "script-src 'self'" },
     { "sCriPt-src 'Unsafe-Inline'",
       "script-src 'unsafe-inline'" },
     { "SCRIPT-src 'unsafe-eval'",
       "script-src 'unsafe-eval'" },
     { "default-SRC 'unsafe-inline' 'unsafe-eval'",
       "default-src 'unsafe-inline' 'unsafe-eval'" },
@@ -289,30 +284,28 @@ TEST(CSPParser, IgnoreUpperLowerCasePoli
     { "script-src 'SHA256-siVR8vAcqP06h2ppeNwqgjr0yZ6yned4X2VF84j4GmI='",
       "script-src 'sha256-siVR8vAcqP06h2ppeNwqgjr0yZ6yned4X2VF84j4GmI='" },
     { "upgrade-INSECURE-requests",
       "upgrade-insecure-requests" },
     { "sanDBox alloW-foRMs",
       "sandbox allow-forms"},
     { "require-SRI-for sCript stYle",
       "require-sri-for script style"},
-    // clang-format on
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
-// ========================= TestPaths ===============================
+// ============================= TestPaths ========================
 
 TEST(CSPParser, Paths)
 {
   static const PolicyTest policies[] =
   {
-    // clang-format off
     { "script-src http://www.example.com",
       "script-src http://www.example.com" },
     { "script-src http://www.example.com/",
       "script-src http://www.example.com/" },
     { "script-src http://www.example.com/path-1",
       "script-src http://www.example.com/path-1" },
     { "script-src http://www.example.com/path-1/",
       "script-src http://www.example.com/path-1/" },
@@ -389,30 +382,28 @@ TEST(CSPParser, Paths)
     { "connect-src http://www.example.com/foo%3bsessionid=12%2c34",
       "connect-src http://www.example.com/foo;sessionid=12,34" },
     { "connect-src http://test.com/pathIncludingAz19-._~!$&'()*+=:@",
       "connect-src http://test.com/pathIncludingAz19-._~!$&'()*+=:@" },
     { "script-src http://www.example.com:88/.js",
       "script-src http://www.example.com:88/.js" },
     { "script-src https://foo.com/_abc/abc_/_/_a_b_c_",
       "script-src https://foo.com/_abc/abc_/_/_a_b_c_" }
-    // clang-format on
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
-// ======================== TestSimplePolicies =======================
+// ============================= TestSimplePolicies ========================
 
 TEST(CSPParser, SimplePolicies)
 {
   static const PolicyTest policies[] =
   {
-    // clang-format off
     { "default-src *",
       "default-src *" },
     { "default-src https:",
       "default-src https:" },
     { "default-src https://*",
       "default-src https://*" },
     { "default-src *:*",
       "default-src http://*:*" },
@@ -467,30 +458,28 @@ TEST(CSPParser, SimplePolicies)
     { "script-src 1",
       "script-src http://1" },
     { "upgrade-insecure-requests",
       "upgrade-insecure-requests" },
     { "upgrade-insecure-requests https:",
       "upgrade-insecure-requests" },
     { "sandbox allow-scripts allow-forms  ",
       "sandbox allow-scripts allow-forms" },
-    // clang-format on
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
-// =================== TestPoliciesWithInvalidSrc ====================
+// ============================= TestPoliciesWithInvalidSrc ========================
 
 TEST(CSPParser, PoliciesWithInvalidSrc)
 {
   static const PolicyTest policies[] =
   {
-    // clang-format off
     { "script-src 'self'; SCRIPT-SRC http://www.example.com",
       "script-src 'self'" },
     { "script-src 'none' test.com; script-src example.com",
       "script-src http://test.com" },
     { "default-src **",
       "default-src 'none'" },
     { "default-src 'self",
       "default-src 'none'" },
@@ -563,55 +552,51 @@ TEST(CSPParser, PoliciesWithInvalidSrc)
     { "connect-src http://www.example.com/foo%zz;",
       "connect-src 'none'" },
     { "script-src https://foo.com/%$",
       "script-src 'none'" },
     { "require-SRI-for script elephants",
       "require-sri-for script"},
     { "sandbox    foo",
       "sandbox"},
-    // clang-format on
   };
 
   // amount of tests - 1, because the latest should be ignored.
   uint32_t policyCount = (sizeof(policies) / sizeof(PolicyTest)) -1;
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
-// ============================= TestBadPolicies =======================
+// ============================= TestBadPolicies ========================
 
 TEST(CSPParser, BadPolicies)
 {
   static const PolicyTest policies[] =
   {
-    // clang-format off
     { "script-sr 'self", "" },
     { "", "" },
     { "; ; ; ; ; ; ;", "" },
     { "defaut-src asdf", "" },
     { "default-src: aaa", "" },
     { "asdf http://test.com", ""},
     { "require-sri-for", ""},
     { "require-sri-for foo", ""},
     { "report-uri", ""},
     { "report-uri http://:foo", ""},
-    // clang-format on
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 0)));
 }
 
-// ======================= TestGoodGeneratedPolicies =================
+// ============================= TestGoodGeneratedPolicies ========================
 
 TEST(CSPParser, GoodGeneratedPolicies)
 {
   static const PolicyTest policies[] =
   {
-    // clang-format off
     { "default-src 'self'; img-src *",
       "default-src 'self'; img-src *" },
     { "report-uri /policy",
       "report-uri http://www.selfuri.com/policy"},
     { "img-src *",
       "img-src *" },
     { "media-src foo.bar",
       "media-src http://foo.bar" },
@@ -818,61 +803,57 @@ TEST(CSPParser, GoodGeneratedPolicies)
     { "frame-ancestors http://self:80",
       "frame-ancestors http://self:80" },
     { "frame-ancestors http://self.com/bar",
       "frame-ancestors http://self.com/bar" },
     { "default-src 'self'; frame-ancestors 'self'",
       "default-src 'self'; frame-ancestors 'self'" },
     { "frame-ancestors http://bar.com/foo.png",
       "frame-ancestors http://bar.com/foo.png" },
-    // clang-format on
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
-// ==================== TestBadGeneratedPolicies ====================
+// ============================= TestBadGeneratedPolicies ========================
 
 TEST(CSPParser, BadGeneratedPolicies)
 {
   static const PolicyTest policies[] =
   {
-    // clang-format off
     { "foo.*.bar", ""},
     { "foo!bar.com", ""},
     { "x.*.a.com", ""},
     { "a#2-c.com", ""},
     { "http://foo.com:bar.com:23", ""},
     { "f!oo.bar", ""},
     { "ht!ps://f-oo.bar", ""},
     { "https://f-oo.bar:3f", ""},
     { "**", ""},
     { "*a", ""},
     { "http://username:password@self.com/foo", ""},
     { "http://other:pass1@self.com/foo", ""},
     { "http://user1:pass1@self.com/foo", ""},
     { "http://username:password@self.com/bar", ""},
-    // clang-format on
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 0)));
 }
 
-// ============ TestGoodGeneratedPoliciesForPathHandling =============
+// ============ TestGoodGeneratedPoliciesForPathHandling ============
 
 TEST(CSPParser, GoodGeneratedPoliciesForPathHandling)
 {
   // Once bug 808292 (Implement path-level host-source matching to CSP)
   // lands we have to update the expected output to include the parsed path
 
   static const PolicyTest policies[] =
   {
-    // clang-format off
     { "img-src http://test1.example.com",
       "img-src http://test1.example.com" },
     { "img-src http://test1.example.com/",
       "img-src http://test1.example.com/" },
     { "img-src http://test1.example.com/path-1",
       "img-src http://test1.example.com/path-1" },
     { "img-src http://test1.example.com/path-1/",
       "img-src http://test1.example.com/path-1/" },
@@ -971,52 +952,49 @@ TEST(CSPParser, GoodGeneratedPoliciesFor
     { "img-src https://test1.example.com:80/abc/def//",
       "img-src https://test1.example.com:80/abc/def//" },
     { "img-src https://test1.example.com:80/abc/def/ghi//",
       "img-src https://test1.example.com:80/abc/def/ghi//" },
     { "img-src https://test1.example.com/abc////////////def/",
       "img-src https://test1.example.com/abc////////////def/" },
     { "img-src https://test1.example.com/abc////////////",
       "img-src https://test1.example.com/abc////////////" },
-    // clang-format on
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
-// ============== TestBadGeneratedPoliciesForPathHandling ============
+// ============ TestBadGeneratedPoliciesForPathHandling ============
 
 TEST(CSPParser, BadGeneratedPoliciesForPathHandling)
 {
   static const PolicyTest policies[] =
   {
-    // clang-format off
     { "img-src test1.example.com:88path-1/",
       "img-src 'none'" },
     { "img-src test1.example.com:80.js",
       "img-src 'none'" },
     { "img-src test1.example.com:*.js",
       "img-src 'none'" },
     { "img-src test1.example.com:*.",
       "img-src 'none'" },
     { "img-src http://test1.example.com//",
       "img-src 'none'" },
     { "img-src http://test1.example.com:80//",
       "img-src 'none'" },
     { "img-src http://test1.example.com:80abc",
       "img-src 'none'" },
-    // clang-format on
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
-// ======================== TestFuzzyPolicies ========================
+// ============================= TestFuzzyPolicies ========================
 
 // Use a policy, eliminate one character at a time,
 // and feed it as input to the parser.
 
 TEST(CSPParser, ShorteningPolicies)
 {
   char pol[] = "default-src http://www.sub1.sub2.example.com:88/path1/path2/ 'unsafe-inline' 'none'";
   uint32_t len = static_cast<uint32_t>(sizeof(pol));
@@ -1027,17 +1005,17 @@ TEST(CSPParser, ShorteningPolicies)
   while (--len) {
     memset(&testPol[0].policy, '\0', kMaxPolicyLength * sizeof(char));
     memcpy(&testPol[0].policy, &pol, len * sizeof(char));
     ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(testPol, 1,
                                           kFuzzyExpectedPolicyCount)));
   }
 }
 
-// ============================= TestFuzzyPolicies ===================
+// ============================= TestFuzzyPolicies ========================
 
 // We generate kFuzzyRuns inputs by (pseudo) randomly picking from the 128
 // ASCII characters; feed them to the parser and verfy that the parser
 // handles the input gracefully.
 //
 // Please note, that by using srand(0) we get deterministic results!
 
 #if RUN_OFFLINE_TESTS
@@ -1062,17 +1040,17 @@ TEST(CSPParser, FuzzyPolicies)
     }
     ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(testPol, 1,
                                           kFuzzyExpectedPolicyCount)));
   }
 }
 
 #endif
 
-// ======================= TestFuzzyPoliciesIncDir ===================
+// ============================= TestFuzzyPoliciesIncDir ========================
 
 // In a similar fashion as in TestFuzzyPolicies, we again (pseudo) randomly
 // generate input for the parser, but this time also include a valid directive
 // followed by the random input.
 
 #if RUN_OFFLINE_TESTS
 
 TEST(CSPParser, FuzzyPoliciesIncDir)
@@ -1102,17 +1080,17 @@ TEST(CSPParser, FuzzyPoliciesIncDir)
     }
     ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(testPol, 1,
                                           kFuzzyExpectedPolicyCount)));
   }
 }
 
 #endif
 
-// ====================== TestFuzzyPoliciesIncDirLimASCII ============
+// ============================= TestFuzzyPoliciesIncDirLimASCII ==============
 
 // Same as TestFuzzyPoliciesIncDir() but using limited ASCII,
 // which represents more likely input.
 
 #if RUN_OFFLINE_TESTS
 
 TEST(CSPParser, FuzzyPoliciesIncDirLimASCII)
 {
--- a/dom/serviceworkers/ServiceWorkerManager.cpp
+++ b/dom/serviceworkers/ServiceWorkerManager.cpp
@@ -2752,22 +2752,22 @@ ServiceWorkerManager::MaybeRemoveRegistr
   }
 }
 
 void
 ServiceWorkerManager::RemoveRegistration(ServiceWorkerRegistrationInfo* aRegistration)
 {
   // Note, we do not need to call mActor->SendUnregister() here.  There are a few
   // ways we can get here:
-  // 1) Through a normal unregister which calls SendUnregister() in the
-  //    unregister job Start() method.
+  // 1) Through a normal unregister which calls SendUnregister() in the unregister
+  //    job Start() method.
   // 2) Through origin storage being purged.  These result in ForceUnregister()
   //    starting unregister jobs which in turn call SendUnregister().
-  // 3) Through the failure to install a new service worker.  Since we don't
-  //    store the registration until install succeeds, we do not need to call
+  // 3) Through the failure to install a new service worker.  Since we don't store
+  //    the registration until install succeeds, we do not need to call
   //    SendUnregister here.
   // Assert these conditions by testing for pending uninstall (cases 1 and 2) or
   // null workers (case 3).
 #ifdef DEBUG
   RefPtr<ServiceWorkerInfo> newest = aRegistration->Newest();
   MOZ_ASSERT(aRegistration->IsPendingUninstall() || !newest);
 #endif
 
--- a/dom/websocket/WebSocket.h
+++ b/dom/websocket/WebSocket.h
@@ -123,18 +123,17 @@ public: // WebIDL interface:
   IMPL_EVENT_HANDLER(close)
 
   // webIDL: readonly attribute DOMString extensions;
   void GetExtensions(nsAString& aResult);
 
   // webIDL: readonly attribute DOMString protocol;
   void GetProtocol(nsAString& aResult);
 
-  // webIDL: void close(optional unsigned short code,
-  //                    optional DOMString reason):
+  // webIDL: void close(optional unsigned short code, optional DOMString reason):
   void Close(const Optional<uint16_t>& aCode,
              const Optional<nsAString>& aReason,
              ErrorResult& aRv);
 
   // webIDL: attribute Function? onmessage;
   IMPL_EVENT_HANDLER(message)
 
   // webIDL: attribute DOMString binaryType;
--- a/dom/xbl/nsXBLBinding.cpp
+++ b/dom/xbl/nsXBLBinding.cpp
@@ -92,17 +92,17 @@ static const JSClass gPrototypeJSClass =
     JSCLASS_HAS_PRIVATE |
     JSCLASS_PRIVATE_IS_NSISUPPORTS |
     JSCLASS_FOREGROUND_FINALIZE |
     // Our one reserved slot holds the relevant nsXBLPrototypeBinding
     JSCLASS_HAS_RESERVED_SLOTS(1),
     &gPrototypeJSClassOps
 };
 
-// Implementation //////////////////////////////////////////////////////////////
+// Implementation /////////////////////////////////////////////////////////////////
 
 // Constructors/Destructors
 nsXBLBinding::nsXBLBinding(nsXBLPrototypeBinding* aBinding)
   : mMarkedForDeath(false)
   , mUsingContentXBLScope(false)
   , mPrototypeBinding(aBinding)
   , mBoundElement(nullptr)
 {
@@ -803,17 +803,17 @@ nsXBLBinding::InheritsStyle() const
 
 
 const RawServoAuthorStyles*
 nsXBLBinding::GetServoStyles() const
 {
   return mPrototypeBinding->GetServoStyles();
 }
 
-// Internal helper methods /////////////////////////////////////////////////////
+// Internal helper methods ////////////////////////////////////////////////////////////////
 
 // Get or create a WeakMap object on a given XBL-hosting global.
 //
 // The scheme is as follows. XBL-hosting globals (either privileged content
 // Windows or XBL scopes) get two lazily-defined WeakMap properties. Each
 // WeakMap is keyed by the grand-proto - i.e. the original prototype of the
 // content before it was bound, and the prototype of the class object that we
 // splice in. The values in the WeakMap are simple dictionary-style objects,
--- a/dom/xbl/nsXBLPrototypeBinding.cpp
+++ b/dom/xbl/nsXBLPrototypeBinding.cpp
@@ -47,17 +47,17 @@
 
 #ifdef MOZ_XUL
 #include "nsXULElement.h"
 #endif
 
 using namespace mozilla;
 using namespace mozilla::dom;
 
-// Helper Classes ==============================================================
+// Helper Classes =====================================================================
 
 // nsXBLAttributeEntry and helpers.  This class is used to efficiently handle
 // attribute changes in anonymous content.
 
 class nsXBLAttributeEntry {
 public:
   nsXBLAttributeEntry(nsAtom* aSrcAtom, nsAtom* aDstAtom,
                       int32_t aDstNameSpace, Element* aElement)
@@ -100,17 +100,17 @@ nsXBLAttributeEntry::SizeOfIncludingThis
        entry; entry = entry->GetNext()) {
     n += aMallocSizeOf(entry);
   }
   return n;
 }
 
 // =============================================================================
 
-// Implementation //////////////////////////////////////////////////////////////
+// Implementation /////////////////////////////////////////////////////////////////
 
 // Constructors/Destructors
 nsXBLPrototypeBinding::nsXBLPrototypeBinding()
 : mImplementation(nullptr),
   mBaseBinding(nullptr),
   mInheritStyle(true),
   mCheckedBaseProto(false),
   mKeyHandlersRegistered(false),
@@ -451,17 +451,17 @@ nsXBLPrototypeBinding::GetBaseTag(int32_
 
 bool
 nsXBLPrototypeBinding::ImplementsInterface(REFNSIID aIID) const
 {
   // Check our IID table.
   return !!mInterfaceTable.GetWeak(aIID);
 }
 
-// Internal helpers ////////////////////////////////////////////////////////////
+// Internal helpers ///////////////////////////////////////////////////////////////////////
 
 Element*
 nsXBLPrototypeBinding::GetImmediateChild(nsAtom* aTag)
 {
   for (nsIContent* child = mBinding->GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     if (child->NodeInfo()->Equals(aTag, kNameSpaceID_XBL)) {
--- a/dom/xbl/nsXBLService.cpp
+++ b/dom/xbl/nsXBLService.cpp
@@ -341,17 +341,17 @@ nsXBLStreamListener::HandleEvent(Event* 
     }
   }
 
   target->RemoveEventListener(NS_LITERAL_STRING("load"), this, false);
 
   return rv;
 }
 
-// Implementation //////////////////////////////////////////////////////////////
+// Implementation /////////////////////////////////////////////////////////////////
 
 // Implement our nsISupports methods
 NS_IMPL_ISUPPORTS(nsXBLService, nsISupportsWeakReference)
 
 void
 nsXBLService::Init()
 {
   gInstance = new nsXBLService();
@@ -712,17 +712,17 @@ nsXBLService::DetachGlobalKeyHandler(Eve
   static_cast<nsXBLWindowKeyHandler*>(handler)->
     RemoveKeyboardEventListenersFrom(manager);
 
   contentNode->DeleteProperty(nsGkAtoms::listener);
 
   return NS_OK;
 }
 
-// Internal helper methods /////////////////////////////////////////////////////
+// Internal helper methods ////////////////////////////////////////////////////////////////
 
 nsresult
 nsXBLService::BindingReady(nsIContent* aBoundElement,
                            nsIURI* aURI,
                            bool* aIsReady)
 {
   // Don't do a security check here; we know this binding is set to go.
   return GetBinding(aBoundElement, aURI, true, nullptr, aIsReady, nullptr);
--- a/dom/xslt/base/txList.h
+++ b/dom/xslt/base/txList.h
@@ -130,18 +130,17 @@ public:
 
     /**
      * Removes the Object last returned by the next() or previous() methods;
      * @return the removed Object pointer
     **/
     void* remove();
 
     /**
-     * Resets the current location within the txList to the beginning of the
-     * txList
+     * Resets the current location within the txList to the beginning of the txList
     **/
     void reset();
 
     /**
      * Resets the current location within the txList to the end of the txList
     **/
     void resetToEnd();
 
--- a/dom/xslt/xpath/txBooleanResult.cpp
+++ b/dom/xslt/xpath/txBooleanResult.cpp
@@ -6,18 +6,17 @@
 /*
  * Boolean Expression result
 */
 
 #include "txExprResult.h"
 
 /**
  * Creates a new BooleanResult with the value of the given bool parameter
- * @param boolean the bool to use for initialization of this BooleanResult's
- * value
+ * @param boolean the bool to use for initialization of this BooleanResult's value
 **/
 BooleanResult::BooleanResult(bool boolean)
     : txAExprResult(nullptr)
 {
     this->value = boolean;
 } //-- BooleanResult
 
 /*
--- a/editor/libeditor/HTMLEditorDocumentCommands.cpp
+++ b/editor/libeditor/HTMLEditorDocumentCommands.cpp
@@ -562,30 +562,28 @@ SetDocumentStateCommand::GetCommandState
  *    for these or future observer commands.
  *    We check the input command param for different behavior
  *
  *  How to use:
  *  1. Get the nsICommandManager for the current editor
  *  2. Implement an nsIObserve object, e.g:
  *
  *    void Observe(
- *        in nsISupports aSubject, // The nsICommandManager calling this
- *                                 // Observer
+ *        in nsISupports aSubject, // The nsICommandManager calling this Observer
  *        in string      aTopic,   // command name, e.g.:"obs_documentCreated"
  *                                 //    or "obs_documentWillBeDestroyed"
           in wstring     aData );  // ignored (set to "command_status_changed")
  *
  *  3. Add the observer by:
  *       commandManager.addObserver(observeobject, obs_documentCreated);
  *  4. In the appropriate location in editorSession, editor, or commands code,
  *     trigger the notification of this observer by something like:
  *
  *  nsCOMPtr<nsICommandManager> commandManager = mDocShell->GetCommandManager();
- *  nsCOMPtr<nsPICommandUpdater> commandUpdater =
- *    do_QueryInterface(commandManager);
+ *  nsCOMPtr<nsPICommandUpdater> commandUpdater = do_QueryInterface(commandManager);
  *  NS_ENSURE_TRUE(commandUpdater, NS_ERROR_FAILURE);
  *    commandUpdater->CommandStatusChanged(obs_documentCreated);
  *
  *  5. Use GetCommandStateParams() to obtain state information
  *     e.g., any creation state codes when creating an editor are
  *     supplied for "obs_documentCreated" command in the
  *     "state_data" param's value
  *
--- a/editor/libeditor/HTMLTableEditor.cpp
+++ b/editor/libeditor/HTMLTableEditor.cpp
@@ -73,17 +73,17 @@ public:
   {
     if (mHTMLEditor) {
       mHTMLEditor->SetSelectionAfterTableEdit(mTable, mRow, mCol, mDirection,
                                               mSelected);
     }
   }
 
   // This is needed to abort the caret reset in the destructor
-  // when one method yields control to another
+  //  when one method yields control to another
   void CancelSetCaret()
   {
     mHTMLEditor = nullptr;
     mTable = nullptr;
   }
 };
 
 nsresult
@@ -1830,37 +1830,37 @@ HTMLEditor::SelectBlockOfCells(Element* 
 
   RefPtr<Element> endTable =
     GetElementOrParentByTagNameInternal(*nsGkAtoms::table, *aEndCell);
   if (NS_WARN_IF(!endTable)) {
     return NS_ERROR_FAILURE;
   }
 
   // We can only select a block if within the same table,
-  // so do nothing if not within one table
+  //  so do nothing if not within one table
   if (table != endTable) {
     return NS_OK;
   }
 
   ErrorResult error;
   CellIndexes startCellIndexes(*aStartCell, error);
   if (NS_WARN_IF(error.Failed())) {
     return error.StealNSResult();
   }
   CellIndexes endCellIndexes(*aEndCell, error);
   if (NS_WARN_IF(error.Failed())) {
     return error.StealNSResult();
   }
 
   // Suppress nsISelectionListener notification
-  // until all selection changes are finished
+  //  until all selection changes are finished
   SelectionBatcher selectionBatcher(SelectionRefPtr());
 
   // Examine all cell nodes in current selection and
-  // remove those outside the new block cell region
+  //  remove those outside the new block cell region
   int32_t minColumn =
     std::min(startCellIndexes.mColumn, endCellIndexes.mColumn);
   int32_t minRow =
     std::min(startCellIndexes.mRow, endCellIndexes.mRow);
   int32_t maxColumn =
     std::max(startCellIndexes.mColumn, endCellIndexes.mColumn);
   int32_t maxRow =
     std::max(startCellIndexes.mRow, endCellIndexes.mRow);
@@ -1953,17 +1953,17 @@ HTMLEditor::SelectAllTableCells()
 
   ErrorResult error;
   TableSize tableSize(*this, *table, error);
   if (NS_WARN_IF(error.Failed())) {
     return error.StealNSResult();
   }
 
   // Suppress nsISelectionListener notification
-  // until all selection changes are finished
+  //  until all selection changes are finished
   SelectionBatcher selectionBatcher(SelectionRefPtr());
 
   // It is now safe to clear the selection
   // BE SURE TO RESET IT BEFORE LEAVING!
   nsresult rv = ClearSelection();
 
   // Select all cells in the same column as current cell
   bool cellSelected = false;
@@ -2035,22 +2035,22 @@ HTMLEditor::SelectTableRow()
   }
 
   ErrorResult error;
   TableSize tableSize(*this, *table, error);
   if (NS_WARN_IF(error.Failed())) {
     return error.StealNSResult();
   }
 
-  // Note: At this point, we could get first and last cells in row,
-  // then call SelectBlockOfCells, but that would take just
-  // a little less code, so the following is more efficient
+  //Note: At this point, we could get first and last cells in row,
+  //  then call SelectBlockOfCells, but that would take just
+  //  a little less code, so the following is more efficient
 
   // Suppress nsISelectionListener notification
-  // until all selection changes are finished
+  //  until all selection changes are finished
   SelectionBatcher selectionBatcher(SelectionRefPtr());
 
   // It is now safe to clear the selection
   // BE SURE TO RESET IT BEFORE LEAVING!
   rv = ClearSelection();
 
   // Select all cells in the same row as current cell
   bool cellSelected = false;
@@ -2120,17 +2120,17 @@ HTMLEditor::SelectTableColumn()
 
   ErrorResult error;
   TableSize tableSize(*this, *table, error);
   if (NS_WARN_IF(error.Failed())) {
     return error.StealNSResult();
   }
 
   // Suppress nsISelectionListener notification
-  // until all selection changes are finished
+  //  until all selection changes are finished
   SelectionBatcher selectionBatcher(SelectionRefPtr());
 
   // It is now safe to clear the selection
   // BE SURE TO RESET IT BEFORE LEAVING!
   rv = ClearSelection();
 
   // Select all cells in the same column as current cell
   bool cellSelected = false;
@@ -2212,17 +2212,17 @@ HTMLEditor::SplitTableCell()
   //...so suppress Rules System selection munging
   AutoTransactionsConserveSelection dontChangeSelection(*this);
 
   RefPtr<Element> newCell;
   int32_t rowIndex = startRowIndex;
   int32_t rowSpanBelow, colSpanAfter;
 
   // Split up cell row-wise first into rowspan=1 above, and the rest below,
-  // whittling away at the cell below until no more extra span
+  //  whittling away at the cell below until no more extra span
   for (rowSpanBelow = actualRowSpan-1; rowSpanBelow >= 0; rowSpanBelow--) {
     // We really split row-wise only if we had rowspan > 1
     if (rowSpanBelow > 0) {
       rv = SplitCellIntoRows(table, rowIndex, startColIndex, 1, rowSpanBelow,
                              getter_AddRefs(newCell));
       NS_ENSURE_SUCCESS(rv, rv);
       CopyCellBackgroundColor(newCell, cell);
     }
@@ -2293,17 +2293,17 @@ HTMLEditor::SplitCellIntoColumns(Element
 
   // Reduce colspan of cell to split
   nsresult rv = SetColSpan(cellData.mElement, aColSpanLeft);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   // Insert new cell after using the remaining span
-  // and always get the new cell so we can copy the background color;
+  //  and always get the new cell so we can copy the background color;
   RefPtr<Element> newCellElement;
   rv = InsertCell(cellData.mElement,
                   cellData.mEffectiveRowSpan, aColSpanRight, true, false,
                   getter_AddRefs(newCellElement));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
   if (!newCellElement) {
@@ -2389,47 +2389,47 @@ HTMLEditor::SplitCellIntoRows(Element* a
       }
       // New cell isn't first in row,
       // so stop after we find the cell just before new cell's column
       if (cellDataAtInsertionPoint.NextColumnIndex() ==
             cellData.mFirst.mColumn) {
         break;
       }
       // If cell found is AFTER desired new cell colum,
-      // we have multiple cells with rowspan > 1 that
-      // prevented us from finding a cell to insert after...
+      //  we have multiple cells with rowspan > 1 that
+      //  prevented us from finding a cell to insert after...
       if (cellDataAtInsertionPoint.mFirst.mColumn > cellData.mFirst.mColumn) {
         // ... so instead insert before the cell we found
         insertAfter = false;
         break;
       }
       // FYI: Don't use std::move() here since
       //      cellDataAtInsertionPoint.NextColumnIndex() needs it.
       lastCellFound = cellDataAtInsertionPoint.mElement;
     }
     MOZ_ASSERT(colIndex < cellDataAtInsertionPoint.NextColumnIndex());
   }
 
   if (!cellElementAtInsertionPoint && lastCellFound) {
     // Edge case where we didn't find a cell to insert after
-    // or before because column(s) before desired column
-    // and all columns after it are spanned from above.
-    // We can insert after the last cell we found
+    //  or before because column(s) before desired column
+    //  and all columns after it are spanned from above.
+    //  We can insert after the last cell we found
     cellElementAtInsertionPoint = std::move(lastCellFound);
     insertAfter = true; // Should always be true, but let's be sure
   }
 
   // Reduce rowspan of cell to split
   nsresult rv = SetRowSpan(cellData.mElement, aRowSpanAbove);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   // Insert new cell after using the remaining span
-  // and always get the new cell so we can copy the background color;
+  //  and always get the new cell so we can copy the background color;
   RefPtr<Element> newCell;
   rv = InsertCell(cellElementAtInsertionPoint,
                   aRowSpanBelow, cellData.mEffectiveColSpan,
                   insertAfter, false, getter_AddRefs(newCell));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
   if (!newCell) {
@@ -2517,18 +2517,18 @@ HTMLEditor::JoinTableCells(bool aMergeNo
     return NS_OK;
   }
 
   AutoPlaceholderBatch treateAsOneTransaction(*this);
   //Don't let Rules System change the selection
   AutoTransactionsConserveSelection dontChangeSelection(*this);
 
   // Note: We dont' use AutoSelectionSetterAfterTableEdit here so the selection
-  // is retained after joining. This leaves the target cell selected
-  // as well as the "non-contiguous" cells, so user can see what happened.
+  //  is retained after joining. This leaves the target cell selected
+  //  as well as the "non-contiguous" cells, so user can see what happened.
 
   ErrorResult error;
   CellAndIndexes firstSelectedCell(*this, *SelectionRefPtr(), error);
   if (NS_WARN_IF(error.Failed())) {
     return error.StealNSResult();
   }
 
   bool joinSelectedCells = false;
@@ -2539,37 +2539,37 @@ HTMLEditor::JoinTableCells(bool aMergeNo
     }
 
     // If only one cell is selected, join with cell to the right
     joinSelectedCells = (secondCell != nullptr);
   }
 
   if (joinSelectedCells) {
     // We have selected cells: Join just contiguous cells
-    // and just merge contents if not contiguous
+    //  and just merge contents if not contiguous
     TableSize tableSize(*this, *table, error);
     if (NS_WARN_IF(error.Failed())) {
       return error.StealNSResult();
     }
 
     // Get spans for cell we will merge into
     int32_t firstRowSpan, firstColSpan;
     rv = GetCellSpansAt(table,
                         firstSelectedCell.mIndexes.mRow,
                         firstSelectedCell.mIndexes.mColumn,
                         firstRowSpan, firstColSpan);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     // This defines the last indexes along the "edges"
-    // of the contiguous block of cells, telling us
-    // that we can join adjacent cells to the block
+    //  of the contiguous block of cells, telling us
+    //  that we can join adjacent cells to the block
     // Start with same as the first values,
-    // then expand as we find adjacent selected cells
+    //  then expand as we find adjacent selected cells
     int32_t lastRowIndex = firstSelectedCell.mIndexes.mRow;
     int32_t lastColIndex = firstSelectedCell.mIndexes.mColumn;
 
     // First pass: Determine boundaries of contiguous rectangular block that
     // we will join into one cell, favoring adjacent cells in the same row.
     IgnoredErrorResult ignoredError;
     for (int32_t rowIndex = firstSelectedCell.mIndexes.mRow;
          rowIndex <= lastRowIndex;
@@ -2616,17 +2616,17 @@ HTMLEditor::JoinTableCells(bool aMergeNo
           // Save max selected column in this row, including extra colspan
           lastColInRow = cellData.LastColumnIndex();
           cellFoundInRow = true;
         } else if (cellFoundInRow) {
           // No cell or not selected, but at least one cell in row was found
           if (cellData.mCurrent.mRow > firstSelectedCell.mIndexes.mRow + 1 &&
               cellData.mCurrent.mColumn <= lastColIndex) {
             // Cell is in a column less than current right border in
-            // the third or higher selected row, so stop block at the previous row
+            //  the third or higher selected row, so stop block at the previous row
             lastRowIndex = std::max(0, cellData.mCurrent.mRow - 1);
             lastRowIsSet = true;
           }
           // We're done with this row
           break;
         }
         MOZ_ASSERT(colIndex < cellData.NextColumnIndex());
       } // End of column loop
@@ -2638,28 +2638,28 @@ HTMLEditor::JoinTableCells(bool aMergeNo
           lastColIndex = lastColInRow;
         }
 
         // If we didn't determine last row above...
         if (!lastRowIsSet) {
           if (colIndex < lastColIndex) {
             // (don't think we ever get here?)
             // Cell is in a column less than current right boundary,
-            // so stop block at the previous row
+            //  so stop block at the previous row
             lastRowIndex = std::max(0, rowIndex - 1);
           } else {
             // Go on to examine next row
             lastRowIndex = rowIndex + 1;
           }
         }
         // Use the minimum col we found so far for right boundary
         lastColIndex = std::min(lastColIndex, lastColInRow);
       } else {
         // No selected cells in this row -- stop at row above
-        // and leave last column at its previous value
+        //  and leave last column at its previous value
         lastRowIndex = std::max(0, rowIndex - 1);
       }
     }
 
     // The list of cells we will delete after joining
     nsTArray<RefPtr<Element>> deleteList;
 
     // 2nd pass: Do the joining and merging
@@ -2682,24 +2682,24 @@ HTMLEditor::JoinTableCells(bool aMergeNo
         if (cellData.mIsSelected &&
             cellData.mElement != firstSelectedCell.mElement) {
           if (cellData.mCurrent.mRow >= firstSelectedCell.mIndexes.mRow &&
               cellData.mCurrent.mRow <= lastRowIndex &&
               cellData.mCurrent.mColumn >= firstSelectedCell.mIndexes.mColumn &&
               cellData.mCurrent.mColumn <= lastColIndex) {
             // We are within the join region
             // Problem: It is very tricky to delete cells as we merge,
-            // since that will upset the cellmap
-            // Instead, build a list of cells to delete and do it later
+            //  since that will upset the cellmap
+            //  Instead, build a list of cells to delete and do it later
             NS_ASSERTION(!cellData.IsSpannedFromOtherRow(),
                          "JoinTableCells: StartRowIndex is in row above");
 
             if (cellData.mEffectiveColSpan > 1) {
-              // Check if cell "hangs" off the boundary because of colspan > 1
-              // Use split methods to chop off excess
+              //Check if cell "hangs" off the boundary because of colspan > 1
+              //  Use split methods to chop off excess
               int32_t extraColSpan =
                 cellData.mFirst.mColumn + cellData.mEffectiveColSpan -
                   (lastColIndex + 1);
               if ( extraColSpan > 0) {
                 rv = SplitCellIntoColumns(
                        table,
                        cellData.mFirst.mRow, cellData.mFirst.mColumn,
                        cellData.mEffectiveColSpan - extraColSpan,
@@ -2839,17 +2839,17 @@ HTMLEditor::JoinTableCells(bool aMergeNo
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
 
     if (effectiveRowSpan2 < leftCellData.mEffectiveRowSpan) {
       // Merged cell is "shorter"
       // (there are cells(s) below it that are row-spanned by target cell)
       // We could try splitting those cells, but that's REAL messy,
-      // so the safest thing to do is NOT really join the cells
+      //  so the safest thing to do is NOT really join the cells
       return NS_OK;
     }
 
     if (spanAboveMergedCell > 0) {
       // Cell we merged started in a row above the target cell
       // Reduce rowspan to give room where target cell will extend its colspan
       rv = SetRowSpan(rightCellData.mElement, spanAboveMergedCell);
       if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -2879,17 +2879,17 @@ HTMLEditor::MergeCells(RefPtr<Element> a
   AutoTopLevelEditSubActionNotifier maybeTopLevelEditSubAction(
                                       *this, EditSubAction::eDeleteNode,
                                       nsIEditor::eNext);
 
   // Don't need to merge if cell is empty
   if (!IsEmptyCell(aCellToMerge)) {
     // Get index of last child in target cell
     // If we fail or don't have children,
-    // we insert at index 0
+    //  we insert at index 0
     int32_t insertIndex = 0;
 
     // Start inserting just after last child
     uint32_t len = aTargetCell->GetChildCount();
     if (len == 1 && IsEmptyCell(aTargetCell)) {
       // Delete the empty node
       nsIContent* cellChild = aTargetCell->GetFirstChild();
       if (NS_WARN_IF(!cellChild)) {
@@ -3979,17 +3979,17 @@ HTMLEditor::SetSelectionAfterTableEdit(E
         NS_WARNING_ASSERTION(NS_SUCCEEDED(rv),
           "Failed to select the cell");
         return;
       }
 
       // Set the caret to deepest first child
       //   but don't go into nested tables
       // TODO: Should we really be placing the caret at the END
-      // of the cell content?
+      //  of the cell content?
       CollapseSelectionToDeepestNonTableFirstChild(cell);
       return;
     }
 
     // Setup index to find another cell in the
     //   direction requested, but move in other direction if already at
     //   beginning of row or column
     switch (aDirection) {
--- a/editor/spellchecker/TextServicesDocument.cpp
+++ b/editor/spellchecker/TextServicesDocument.cpp
@@ -840,18 +840,17 @@ nsresult
 TextServicesDocument::SetSelection(int32_t aOffset,
                                    int32_t aLength)
 {
   NS_ENSURE_TRUE(mSelCon && aOffset >= 0 && aLength >= 0, NS_ERROR_FAILURE);
 
   nsresult rv = SetSelectionInternal(aOffset, aLength, true);
 
   //**** KDEBUG ****
-  // printf("\n * Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex,
-  //        mSelStartOffset, mSelEndIndex, mSelEndOffset);
+  // printf("\n * Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
   //**** KDEBUG ****
 
   return rv;
 }
 
 nsresult
 TextServicesDocument::ScrollSelectionIntoView()
 {
@@ -1106,18 +1105,17 @@ TextServicesDocument::DeleteSelection()
   }
 
   // Now remove any invalid entries from the offset table.
 
   rv = RemoveInvalidOffsetEntries();
 
   //**** KDEBUG ****
   // printf("\n---- After Delete\n");
-  // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex,
-  //        mSelStartOffset, mSelEndIndex, mSelEndOffset);
+  // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
   // PrintOffsetTable();
   //**** KDEBUG ****
 
   return rv;
 }
 
 nsresult
 TextServicesDocument::InsertText(const nsString* aText)
@@ -1271,18 +1269,17 @@ TextServicesDocument::InsertText(const n
     }
     if (entry->mIsValid) {
       entry->mNodeOffset += strLength;
     }
   }
 
   //**** KDEBUG ****
   // printf("\n---- After Insert\n");
-  // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex,
-  //        mSelStartOffset, mSelEndIndex, mSelEndOffset);
+  // printf("Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
   // PrintOffsetTable();
   //**** KDEBUG ****
 
   if (!collapsedSelection) {
     rv = SetSelection(savedSelOffset, savedSelLength);
     if (NS_FAILED(rv)) {
       return rv;
     }
@@ -1688,17 +1685,16 @@ TextServicesDocument::IsBlockNode(nsICon
 {
   if (!aContent) {
     NS_ERROR("How did a null pointer get passed to IsBlockNode?");
     return false;
   }
 
   nsAtom *atom = aContent->NodeInfo()->NameAtom();
 
-  // clang-format off
   return (nsGkAtoms::a       != atom &&
           nsGkAtoms::address != atom &&
           nsGkAtoms::big     != atom &&
           nsGkAtoms::b       != atom &&
           nsGkAtoms::cite    != atom &&
           nsGkAtoms::code    != atom &&
           nsGkAtoms::dfn     != atom &&
           nsGkAtoms::em      != atom &&
@@ -1715,17 +1711,16 @@ TextServicesDocument::IsBlockNode(nsICon
           nsGkAtoms::strike  != atom &&
           nsGkAtoms::strong  != atom &&
           nsGkAtoms::sub     != atom &&
           nsGkAtoms::sup     != atom &&
           nsGkAtoms::tt      != atom &&
           nsGkAtoms::u       != atom &&
           nsGkAtoms::var     != atom &&
           nsGkAtoms::wbr     != atom);
-  // clang-format on
 }
 
 // static
 bool
 TextServicesDocument::HasSameBlockNodeParent(nsIContent* aContent1,
                                              nsIContent* aContent2)
 {
   nsIContent* p1 = aContent1->GetParent();
@@ -1836,18 +1831,17 @@ TextServicesDocument::SetSelectionIntern
 
   if (aLength <= 0) {
     // We have a collapsed selection. (Caret)
 
     mSelEndIndex  = mSelStartIndex;
     mSelEndOffset = mSelStartOffset;
 
    //**** KDEBUG ****
-   // printf("\n* Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex,
-   //        mSelStartOffset, mSelEndIndex, mSelEndOffset);
+   // printf("\n* Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
    //**** KDEBUG ****
 
     return NS_OK;
   }
 
   // Find the end of the selection in node offset terms:
   nsCOMPtr<nsINode> endNode;
   int32_t endNodeOffset = 0;
@@ -1879,18 +1873,17 @@ TextServicesDocument::SetSelectionIntern
 
   if (aDoUpdate && endNode) {
     nsresult rv = selection->Extend(endNode, endNodeOffset);
 
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   //**** KDEBUG ****
-  // printf("\n * Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex,
-  //        mSelStartOffset, mSelEndIndex, mSelEndOffset);
+  // printf("\n * Sel: (%2d, %4d) (%2d, %4d)\n", mSelStartIndex, mSelStartOffset, mSelEndIndex, mSelEndOffset);
   //**** KDEBUG ****
 
   return NS_OK;
 }
 
 nsresult
 TextServicesDocument::GetSelection(BlockSelectionStatus* aSelStatus,
                                    int32_t* aSelOffset,
--- a/extensions/cookie/nsPermissionManager.cpp
+++ b/extensions/cookie/nsPermissionManager.cpp
@@ -98,20 +98,20 @@ static int32_t sPreloadPermissionCount =
 // These permissions are special permissions which must be transmitted to the
 // content process before documents with their principals have loaded within
 // that process. This is because these permissions are used for content
 // blocking in nsContentBlocker.
 //
 // Permissions which are in this list are considered to have a "" permission
 // key, even if their principal would not normally have that key.
 static const char* kPreloadPermissions[] = {
-  // NOTE: These permissions are the different nsContentBlocker permissions
-  // for allowing or denying certain content types from being loaded. Every
-  // permission listed in the `kTypeString` array in nsContentBlocker.cpp
-  // should appear in this list.
+  // NOTE: These permissions are the different nsContentBlocker permissions for
+  // allowing or denying certain content types from being loaded. Every
+  // permission listed in the `kTypeString` array in nsContentBlocker.cpp should
+  // appear in this list.
   "other",
   "script",
   "image",
   "stylesheet",
   "object",
   "document",
   "subdocument",
   "refresh",
--- a/extensions/spellcheck/src/mozPersonalDictionary.cpp
+++ b/extensions/spellcheck/src/mozPersonalDictionary.cpp
@@ -27,17 +27,17 @@
 #include "prio.h"
 #include "mozilla/Move.h"
 
 #define MOZ_PERSONAL_DICT_NAME "persdict.dat"
 
 /**
  * This is the most braindead implementation of a personal dictionary possible.
  * There is not much complexity needed, though.  It could be made much faster,
- * and probably should, but I don't see much need for more in terms of interface.
+ *  and probably should, but I don't see much need for more in terms of interface.
  *
  * Allowing personal words to be associated with only certain dictionaries maybe.
  *
  * TODO:
  * Implement the suggestion record.
  */
 
 NS_IMPL_ADDREF(mozPersonalDictionary)
--- a/gfx/2d/2D.h
+++ b/gfx/2d/2D.h
@@ -344,18 +344,17 @@ public:
 
   RefPtr<SourceSurface> mSurface; //!< Surface to use for drawing
   ExtendMode mExtendMode;         /**< This determines how the image is extended
                                        outside the bounds of the image */
   SamplingFilter mSamplingFilter; //!< Resampling filter for resampling the image.
   Matrix mMatrix;                 //!< Transforms the pattern into user space
 
   IntRect mSamplingRect;          /**< Rect that must not be sampled outside of,
-                                       or an empty rect if none has been
-                                       specified. */
+                                       or an empty rect if none has been specified. */
 };
 
 class StoredPattern;
 class DrawTargetCaptureImpl;
 
 /**
  * This is the base class for source surfaces. These objects are surfaces
  * which may be used as a source in a SurfacePattern or a DrawSurface call.
@@ -952,18 +951,17 @@ class NativeFontResource : public extern
 {
 public:
   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(NativeFontResource)
 
   /**
    * Creates a UnscaledFont using the font corresponding to the index.
    *
    * @param aIndex index for the font within the resource.
-   * @param aInstanceData pointer to read-only buffer of any available instance
-   *                      data.
+   * @param aInstanceData pointer to read-only buffer of any available instance data.
    * @param aInstanceDataLength the size of the instance data.
    * @return an already_addrefed UnscaledFont, containing nullptr if failed.
    */
   virtual already_AddRefed<UnscaledFont>
     CreateUnscaledFont(uint32_t aIndex,
                        const uint8_t* aInstanceData,
                        uint32_t aInstanceDataLength) = 0;
 
@@ -1037,20 +1035,18 @@ public:
   virtual void DrawCapturedDT(DrawTargetCapture *aCaptureDT,
                               const Matrix& aTransform);
 
   /**
    * Draw a surface to the draw target. Possibly doing partial drawing or
    * applying scaling. No sampling happens outside the source.
    *
    * @param aSurface Source surface to draw
-   * @param aDest Destination rectangle that this drawing operation should draw
-   *              to
-   * @param aSource Source rectangle in aSurface coordinates, this area of
-   *                aSurface
+   * @param aDest Destination rectangle that this drawing operation should draw to
+   * @param aSource Source rectangle in aSurface coordinates, this area of aSurface
    *                will be stretched to the size of aDest.
    * @param aOptions General draw options that are applied to the operation
    * @param aSurfOptions DrawSurface options that are applied
    */
   virtual void DrawSurface(SourceSurface *aSurface,
                            const Rect &aDest,
                            const Rect &aSource,
                            const DrawSurfaceOptions &aSurfOptions = DrawSurfaceOptions(),
@@ -1465,18 +1461,17 @@ public:
   Matrix GetTransform() const { return mTransform; }
 
   /*
    * Get the metrics of a glyph, including any additional spacing that is taken
    * during rasterization to this backends (for example because of antialiasing
    * filters.
    *
    * aScaledFont The scaled font used when drawing.
-   * aGlyphIndices An array of indices for the glyphs whose the metrics are
-   *               wanted
+   * aGlyphIndices An array of indices for the glyphs whose the metrics are wanted
    * aNumGlyphs The amount of elements in aGlyphIndices
    * aGlyphMetrics The glyph metrics
    */
   virtual void GetGlyphRasterizationMetrics(ScaledFont *aScaledFont, const uint16_t* aGlyphIndices,
                                             uint32_t aNumGlyphs, GlyphMetrics* aGlyphMetrics)
   {
     aScaledFont->GetGlyphDesignMetrics(aGlyphIndices, aNumGlyphs, aGlyphMetrics);
   }
@@ -1724,21 +1719,19 @@ public:
                                bool aApplySyntheticBold = false);
 #endif
 
   /**
    * This creates a NativeFontResource from TrueType data.
    *
    * @param aData Pointer to the data
    * @param aSize Size of the TrueType data
-   * @param aBackendType Type of the reference DrawTarget the font should be
-   *                     created for.
+   * @param aBackendType Type of the reference DrawTarget the font should be created for.
    * @param aFontType Type of NativeFontResource that should be created.
-   * @param aFontContext Optional native font context to be used to create the
-   *                              NativeFontResource.
+   * @param aFontContext Optional native font context to be used to create the NativeFontResource.
    * @return a NativeFontResource of nullptr if failed.
    */
   static already_AddRefed<NativeFontResource>
     CreateNativeFontResource(uint8_t *aData, uint32_t aSize, BackendType aBackendType, FontType aFontType, void* aFontContext = nullptr);
 
   /**
    * This creates an unscaled font of the given type based on font descriptor
    * data retrieved from ScaledFont::GetFontDescriptor.
--- a/gfx/2d/Blur.cpp
+++ b/gfx/2d/Blur.cpp
@@ -209,21 +209,19 @@ BoxBlurRow(const uint8_t* aInput,
     RIGHT_ITER;
   }
 }
 
 /**
  * Box blur involves looking at one pixel, and setting its value to the average
  * of its neighbouring pixels. This is meant to provide a 3-pass approximation of a
  * Gaussian blur.
- * @param aTranspose Whether to transpose the buffer when reading and writing
- *                   to it.
+ * @param aTranspose Whether to transpose the buffer when reading and writing to it.
  * @param aData The buffer to be blurred.
- * @param aLobes The number of pixels to blend on the left and right for each of
- *               3 passes.
+ * @param aLobes The number of pixels to blend on the left and right for each of 3 passes.
  * @param aWidth The number of columns in the buffers.
  * @param aRows The number of rows in the buffers.
  * @param aStride The stride of the buffer.
  */
 template<bool aTranspose>
 static void
 BoxBlur(uint8_t* aData,
         const int32_t aLobes[3][2],
--- a/gfx/2d/DrawTargetSkia.cpp
+++ b/gfx/2d/DrawTargetSkia.cpp
@@ -1050,18 +1050,17 @@ GfxMatrixToCGAffineTransform(const Matri
  * 1) Translation of the context up
  * 2) Flipping the context around the Y axis
  * 3) Flipping the context around the Y axis
  * 4) Inverting the Y position of each glyph
  *
  * We cannot cancel out (2) and (3) as we have to apply the clips and transforms
  * of DrawTargetSkia between (2) and (3).
  *
- * Consider the example letter P, drawn at (0, 20) in CG coordinates in a
- * (100, 100) rect.
+ * Consider the example letter P, drawn at (0, 20) in CG coordinates in a (100, 100) rect.
  * Again, going right to left of the transforms. We'd get:
  *
  * 1) The letter P drawn at (0, -20) due to the inversion of the Y axis
  * 2) The letter P upside down (b) at (0, 20) due to the second flip
  * 3) The letter P right side up at (0, -20) due to the first flip
  * 4) The letter P right side up at (0, 80) due to the translation
  *
  * tl;dr - CGRects assume origin is bottom left, DrawTarget rects assume top left.
--- a/gfx/2d/DrawTargetWrapAndRecord.h
+++ b/gfx/2d/DrawTargetWrapAndRecord.h
@@ -315,18 +315,17 @@ public:
   }
 
 private:
   /**
    * Used for creating a DrawTargetWrapAndRecord for a CreateSimilarDrawTarget call.
    * We have to call CreateSimilarDrawTarget on mFinalDT up front and pass it in
    * as it can fail.
    *
-   * @param aDT DrawTargetWrapAndRecord on which CreateSimilarDrawTarget was
-   *            called
+   * @param aDT DrawTargetWrapAndRecord on which CreateSimilarDrawTarget was called
    * @param aSimilarDT Similar DrawTarget created from aDT.mFinalDT.
    */
   DrawTargetWrapAndRecord(const DrawTargetWrapAndRecord *aDT,
                       DrawTarget *aSimilarDT);
 
   Path *GetPathForPathRecording(const Path *aPath) const;
   already_AddRefed<PathRecording> EnsurePathStored(const Path *aPath);
   void EnsurePatternDependenciesStored(const Pattern &aPattern);
--- a/gfx/2d/FilterProcessingSIMD-inl.h
+++ b/gfx/2d/FilterProcessingSIMD-inl.h
@@ -242,24 +242,22 @@ BlendTwoComponentsOfFourPixels(i16x8_t s
 
 // The alpha channel is subject to a different calculation than the RGB
 // channels, and this calculation is the same for all blend modes:
 // resultAlpha * 255 = 255 * 255 - (255 - sourceAlpha) * (255 - destAlpha)
 template<typename i16x8_t, typename i32x4_t>
 inline i32x4_t
 BlendAlphaOfFourPixels(i16x8_t s_rrrraaaa1234, i16x8_t d_rrrraaaa1234)
 {
-  // clang-format off
   // We're using MulAdd16x8x2To32x4, so we need to interleave our factors
   // appropriately. The calculation is rewritten as follows:
   // resultAlpha[0] * 255 = 255 * 255 - (255 - sourceAlpha[0]) * (255 - destAlpha[0])
   //                      = 255 * 255 + (255 - sourceAlpha[0]) * (destAlpha[0] - 255)
   //                      = (255 - 0) * (510 - 255) + (255 - sourceAlpha[0]) * (destAlpha[0] - 255)
   //                      = MulAdd(255 - IntLv(0, sourceAlpha), IntLv(510, destAlpha) - 255)[0]
-  // clang-format on
   i16x8_t zeroInterleavedWithSourceAlpha = simd::InterleaveHi16(simd::FromI16<i16x8_t>(0), s_rrrraaaa1234);
   i16x8_t fiveTenInterleavedWithDestAlpha = simd::InterleaveHi16(simd::FromI16<i16x8_t>(510), d_rrrraaaa1234);
   i16x8_t f1 = simd::Sub16(simd::FromI16<i16x8_t>(255), zeroInterleavedWithSourceAlpha);
   i16x8_t f2 = simd::Sub16(fiveTenInterleavedWithDestAlpha, simd::FromI16<i16x8_t>(255));
   return simd::FastDivideBy255(simd::MulAdd16x8x2To32x4(f1, f2));
 }
 
 template<typename u8x16_t, typename i16x8_t>
@@ -514,25 +512,23 @@ ColorMatrixMultiply(i16x8_t p, i16x8_t r
   // int16_t rows_bg[8] == { bB, bG, bR, bA, gB, gG, gR, gA }.
   // int16_t rows_ra[8] == { rB, rG, rR, rA, aB, aG, aR, aA }.
   // int32_t bias[4] == { _B, _G, _R, _A }.
 
   i32x4_t sum = bias;
 
   // int16_t bg[8] = { b, g, b, g, b, g, b, g };
   i16x8_t bg = simd::ShuffleHi16<1,0,1,0>(simd::ShuffleLo16<1,0,1,0>(p));
-  // int32_t prodsum_bg[4] =
-  //   { b * bB + g * gB, b * bG + g * gG, b * bR + g * gR, b * bA + g * gA }
+  // int32_t prodsum_bg[4] = { b * bB + g * gB, b * bG + g * gG, b * bR + g * gR, b * bA + g * gA }
   i32x4_t prodsum_bg = simd::MulAdd16x8x2To32x4(bg, rows_bg);
   sum = simd::Add32(sum, prodsum_bg);
 
   // uint16_t ra[8] = { r, a, r, a, r, a, r, a };
   i16x8_t ra = simd::ShuffleHi16<3,2,3,2>(simd::ShuffleLo16<3,2,3,2>(p));
-  // int32_t prodsum_ra[4] =
-  //   { r * rB + a * aB, r * rG + a * aG, r * rR + a * aR, r * rA + a * aA }
+  // int32_t prodsum_ra[4] = { r * rB + a * aB, r * rG + a * aG, r * rR + a * aR, r * rA + a * aA }
   i32x4_t prodsum_ra = simd::MulAdd16x8x2To32x4(ra, rows_ra);
   sum = simd::Add32(sum, prodsum_ra);
 
   // int32_t sum[4] == { b * bB + g * gB + r * rB + a * aB + _B, ... }.
   return sum;
 }
 
 template<typename i32x4_t, typename i16x8_t, typename u8x16_t>
--- a/gfx/2d/HelpersD2D.h
+++ b/gfx/2d/HelpersD2D.h
@@ -578,26 +578,24 @@ CreatePartialBitmapForSurface(DataSource
 
   Rect uploadRect(0, 0, Float(size.width), Float(size.height));
   if (aSourceRect) {
     uploadRect = Rect(aSourceRect->X(), aSourceRect->Y(), aSourceRect->Width(), aSourceRect->Height());
   }
 
   // Limit the uploadRect as much as possible without supporting discontiguous uploads
   //
-  // clang-format off
   //                               region we will paint from
   //   uploadRect
   //   .---------------.              .---------------.         resulting uploadRect
   //   |               |rect          |               |
   //   |          .---------.         .----.     .----.          .---------------.
   //   |          |         |  ---->  |    |     |    |   ---->  |               |
   //   |          '---------'         '----'     '----'          '---------------'
   //   '---------------'              '---------------'
-  // clang-format on
   //
   //
 
   int Bpp = BytesPerPixel(aSurface->GetFormat());
 
   if (uploadRect.Contains(rect)) {
     // Extend mode is irrelevant, the displayed rect is completely contained
     // by the source bitmap.
--- a/gfx/2d/JobScheduler_posix.cpp
+++ b/gfx/2d/JobScheduler_posix.cpp
@@ -29,18 +29,17 @@ public:
 
   void SetName(const char*) override
   {
 // XXX - temporarily disabled, see bug 1209039
 //
 //    // Call this from the thread itself because of Mac.
 //#ifdef XP_MACOSX
 //    pthread_setname_np(aName);
-//#elif defined(__DragonFly__) || defined(__FreeBSD__) || \
-//      defined(__OpenBSD__)
+//#elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
 //    pthread_set_name_np(mThread, aName);
 //#elif defined(__NetBSD__)
 //    pthread_setname_np(mThread, "%s", (void*)aName);
 //#else
 //    pthread_setname_np(mThread, aName);
 //#endif
   }
 
--- a/gfx/2d/Logging.h
+++ b/gfx/2d/Logging.h
@@ -753,18 +753,17 @@ typedef Log<LOG_CRITICAL, CriticalLogger
 #define GFX_LOGGING_GLUE(x, y)   GFX_LOGGING_GLUE1(x, y)
 
 // This log goes into crash reports, use with care.
 #define gfxCriticalError mozilla::gfx::CriticalLog
 #define gfxCriticalErrorOnce static gfxCriticalError GFX_LOGGING_GLUE(sOnceAtLine,__LINE__) = gfxCriticalError
 
 // This is a shortcut for errors we want logged in crash reports/about support
 // but we do not want asserting.  These are available in all builds, so it is
-// not worth trying to do magic to avoid matching the syntax of
-// gfxCriticalError.
+// not worth trying to do magic to avoid matching the syntax of gfxCriticalError.
 // So, this one is used as
 // gfxCriticalNote << "Something to report and not assert";
 // while the critical error is
 // gfxCriticalError() << "Something to report and assert";
 #define gfxCriticalNote gfxCriticalError(gfxCriticalError::DefaultOptions(false))
 #define gfxCriticalNoteOnce static gfxCriticalError GFX_LOGGING_GLUE(sOnceAtLine,__LINE__) = gfxCriticalNote
 
 // The "once" versions will only trigger the first time through. You can do this:
--- a/gfx/2d/Path.cpp
+++ b/gfx/2d/Path.cpp
@@ -335,44 +335,39 @@ FindInflectionApproximationRange(BezierC
     *aMin = aT - tf * (1 - aT);
     *aMax = aT + tf * (1 - aT);
 }
 
 /* Find the inflection points of a bezier curve. Will return false if the
  * curve is degenerate in such a way that it is best approximated by a straight
  * line.
  *
- * The below algorithm was written by Jeff Muizelaar <jmuizelaar@mozilla.com>,
- * explanation follows:
+ * The below algorithm was written by Jeff Muizelaar <jmuizelaar@mozilla.com>, explanation follows:
  *
  * The lower inflection point is returned in aT1, the higher one in aT2. In the
  * case of a single inflection point this will be in aT1.
  *
- * The method is inspired by the algorithm in "analysis of in?ection points for
- * planar cubic bezier curve"
+ * The method is inspired by the algorithm in "analysis of in?ection points for planar cubic bezier curve"
  *
- * Here are some differences between this algorithm and versions discussed
- * elsewhere in the literature:
+ * Here are some differences between this algorithm and versions discussed elsewhere in the literature:
  *
  * zhang et. al compute a0, d0 and e0 incrementally using the follow formula:
  *
  * Point a0 = CP2 - CP1
  * Point a1 = CP3 - CP2
  * Point a2 = CP4 - CP1
  *
  * Point d0 = a1 - a0
  * Point d1 = a2 - a1
  
  * Point e0 = d1 - d0
  *
- * this avoids any multiplications and may or may not be faster than the
- * approach take below.
+ * this avoids any multiplications and may or may not be faster than the approach take below.
  *
- * "fast, precise flattening of cubic bezier path and ofset curves" by hain et.
- * al
+ * "fast, precise flattening of cubic bezier path and ofset curves" by hain et. al
  * Point a = CP1 + 3 * CP2 - 3 * CP3 + CP4
  * Point b = 3 * CP1 - 6 * CP2 + 3 * CP3
  * Point c = -3 * CP1 + 3 * CP2
  * Point d = CP1
  * the a, b, c, d can be expressed in terms of a0, d0 and e0 defined above as:
  * c = 3 * a0
  * b = 3 * d0
  * a = e0
--- a/gfx/2d/Swizzle.cpp
+++ b/gfx/2d/Swizzle.cpp
@@ -204,21 +204,20 @@ PremultiplyFallback(const uint8_t* aSrc,
       uint32_t a = aSrcAShift ? color >> aSrcAShift : color & 0xFF;
 
       // Isolate the R and B components.
       uint32_t rb = (color >> aSrcRGBShift) & 0x00FF00FF;
       // Swap the order of R and B if necessary.
       if (aSwapRB) {
         rb = (rb >> 16) | (rb << 16);
       }
-      // Approximate the multiply by alpha and divide by 255 which is
-      // essentially:
+      // Approximate the multiply by alpha and divide by 255 which is essentially:
       // c = c*a + 255; c = (c + (c >> 8)) >> 8;
-      // However, we omit the final >> 8 to fold it with the final shift into
-      // place depending on desired output format.
+      // However, we omit the final >> 8 to fold it with the final shift into place
+      // depending on desired output format.
       rb = rb*a + 0x00FF00FF;
       rb = (rb + ((rb >> 8) & 0x00FF00FF)) & 0xFF00FF00;
 
       // Use same approximation as above, but G is shifted 8 bits left.
       // Alpha is left out and handled separately.
       uint32_t g = color & (0xFF00 << aSrcRGBShift);
       g = g*a + (0xFF00 << aSrcRGBShift);
       g = (g + (g >> 8)) & (0xFF0000 << aSrcRGBShift);
--- a/gfx/2d/SwizzleNEON.cpp
+++ b/gfx/2d/SwizzleNEON.cpp
@@ -179,25 +179,24 @@ UnpremultiplyVector_NEON(const uint16x8_
           vld1q_lane_u32(&sUnpremultiplyTable_NEON[a2],
             vld1q_lane_u32(&sUnpremultiplyTable_NEON[a1],
                            vdupq_n_u32(0), 0), 1), 2), 3));
   // Transpose the interleaved low/high portions so that we produce
   // two separate duplicated vectors for the low and high portions respectively:
   // lo1 lo1 lo2 lo2 lo3 lo3 lo4 lo4 and hi1 hi1 hi2 hi2 hi3 hi3 hi4 hi4
   uint16x8x2_t q1234lohi = vtrnq_u16(q1234, q1234);
 
-  // VQDMULH is a signed multiply that doubles (*2) the result, then takes the
-  // high word.  To work around the signedness and the doubling, the low
-  // portion of the reciprocal only stores the lower 15 bits, which fits in a
-  // signed 16 bit integer. The high 9 bit portion is effectively also doubled
-  // by 2 as a side-effect of being shifted for storage. Thus the output scale
-  // of doing a normal multiply by the high portion and the VQDMULH by the low
-  // portion are both doubled and can be safely added together. The resulting
-  // sum just needs to be halved (via VHADD) to thus cancel out the doubling.
-  // All this combines to produce a reciprocal multiply of the form:
+  // VQDMULH is a signed multiply that doubles (*2) the result, then takes the high word.
+  // To work around the signedness and the doubling, the low portion of the reciprocal only
+  // stores the lower 15 bits, which fits in a signed 16 bit integer. The high 9 bit portion
+  // is effectively also doubled by 2 as a side-effect of being shifted for storage. Thus the
+  // output scale of doing a normal multiply by the high portion and the VQDMULH by the low
+  // portion are both doubled and can be safely added together. The resulting sum just needs
+  // to be halved (via VHADD) to thus cancel out the doubling. All this combines to produce
+  // a reciprocal multiply of the form:
   // rb = ((rb * hi) + ((rb * lo * 2) >> 16)) / 2
   rb =
     vhaddq_u16(
       vmulq_u16(rb, q1234lohi.val[1]),
       vreinterpretq_u16_s16(
         vqdmulhq_s16(vreinterpretq_s16_u16(rb),
                      vreinterpretq_s16_u16(q1234lohi.val[0]))));
 
--- a/gfx/gl/ForceDiscreteGPUHelperCGL.h
+++ b/gfx/gl/ForceDiscreteGPUHelperCGL.h
@@ -15,18 +15,17 @@
 class ForceDiscreteGPUHelperCGL
 {
     CGLPixelFormatObj mPixelFormatObj;
 
 public:
     ForceDiscreteGPUHelperCGL()
         : mPixelFormatObj(nullptr)
     {
-        // the code in this function is taken from Chromium,
-        // src/ui/gfx/gl/gl_context_cgl.cc, r122013
+        // the code in this function is taken from Chromium, src/ui/gfx/gl/gl_context_cgl.cc, r122013
         // BSD-style license, (c) The Chromium Authors
         CGLPixelFormatAttribute attribs[1];
         attribs[0] = static_cast<CGLPixelFormatAttribute>(0);
         GLint num_pixel_formats = 0;
         CGLChoosePixelFormat(attribs, &mPixelFormatObj, &num_pixel_formats);
     }
 
     ~ForceDiscreteGPUHelperCGL()
--- a/gfx/gl/GLContextProviderWGL.cpp
+++ b/gfx/gl/GLContextProviderWGL.cpp
@@ -171,30 +171,28 @@ WGLLibrary::EnsureInitialized()
     const auto resetContext = MakeScopeExit([&]() {
         mSymbols.fMakeCurrent(curDC, curCtx);
     });
 
     const auto lookupFunc = (GLLibraryLoader::PlatformLookupFunction)mSymbols.fGetProcAddress;
 
     // Now we can grab all the other symbols that we couldn't without having
     // a context current.
-    // clang-format off
     const GLLibraryLoader::SymLoadStruct reqExtSymbols[] = {
         { (PRFuncPtr*)&mSymbols.fCreatePbuffer, { "wglCreatePbufferARB", "wglCreatePbufferEXT", nullptr } },
         { (PRFuncPtr*)&mSymbols.fDestroyPbuffer, { "wglDestroyPbufferARB", "wglDestroyPbufferEXT", nullptr } },
         { (PRFuncPtr*)&mSymbols.fGetPbufferDC, { "wglGetPbufferDCARB", "wglGetPbufferDCEXT", nullptr } },
         { (PRFuncPtr*)&mSymbols.fReleasePbufferDC, { "wglReleasePbufferDCARB", "wglReleasePbufferDCEXT", nullptr } },
     //    { (PRFuncPtr*)&mSymbols.fBindTexImage, { "wglBindTexImageARB", "wglBindTexImageEXT", nullptr } },
     //    { (PRFuncPtr*)&mSymbols.fReleaseTexImage, { "wglReleaseTexImageARB", "wglReleaseTexImageEXT", nullptr } },
         { (PRFuncPtr*)&mSymbols.fChoosePixelFormat, { "wglChoosePixelFormatARB", "wglChoosePixelFormatEXT", nullptr } },
     //    { (PRFuncPtr*)&mSymbols.fGetPixelFormatAttribiv, { "wglGetPixelFormatAttribivARB", "wglGetPixelFormatAttribivEXT", nullptr } },
         SYMBOL(GetExtensionsStringARB),
         END_OF_SYMBOLS
     };
-    // clang-format on
     if (!GLLibraryLoader::LoadSymbols(mOGLLibrary, reqExtSymbols, lookupFunc)) {
         NS_WARNING("reqExtSymbols missing");
         return false;
     }
 
     // --
 
     const auto extString = mSymbols.fGetExtensionsStringARB(mRootDc);
--- a/layout/base/nsBidi.h
+++ b/layout/base/nsBidi.h
@@ -36,18 +36,17 @@ public:
   }
 
   /**
    * Perform the Unicode Bidi algorithm.
    *
    * @param aText is a pointer to the single-paragraph text that the
    *      Bidi algorithm will be performed on
    *      (step (P1) of the algorithm is performed externally).
-   *      <strong>The text must be (at least) <code>aLength</code> long.
-   *      </strong>
+   *      <strong>The text must be (at least) <code>aLength</code> long.</strong>
    *
    * @param aLength is the length of the text; if <code>aLength==-1</code> then
    *      the text must be zero-terminated.
    *
    * @param aParaLevel specifies the default level for the paragraph;
    *      it is typically 0 (LTR) or 1 (RTL).
    *      If the function shall determine the paragraph level from the text,
    *      then <code>aParaLevel</code> can be set to
--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -2767,30 +2767,29 @@ nsCSSFrameConstructor::SetUpDocElementCo
   [abs-cb]: the default containing block for abs-pos content
 
   Meaning of nsCSSFrameConstructor fields:
     mRootElementFrame is "root element frame".  This is the primary frame for
       the root element.
     mDocElementContainingBlock is the parent of mRootElementFrame
       (i.e. nsCanvasFrame or nsRootBoxFrame)
 
-    mPageSequenceFrame is the nsSimplePageSequenceFrame,
-    or null if there isn't one
+    mPageSequenceFrame is the nsSimplePageSequenceFrame, or null if there isn't one
   */
 
   // --------- CREATE ROOT FRAME -------
 
 
   // Create the root frame. The document element's frame is a child of the
   // root frame.
   //
   // The root frame serves two purposes:
   // - reserves space for any margins needed for the document element's frame
-  // - renders the document element's background. This ensures the background
-  //   covers the entire canvas as specified by the CSS2 spec
+  // - renders the document element's background. This ensures the background covers
+  //   the entire canvas as specified by the CSS2 spec
 
   nsPresContext* presContext = mPresShell->GetPresContext();
   bool isPaginated = presContext->IsRootPaginatedDocument();
   nsContainerFrame* viewportFrame = static_cast<nsContainerFrame*>(GetRootFrame());
   ComputedStyle* viewportPseudoStyle = viewportFrame->Style();
 
   nsContainerFrame* rootFrame = nullptr;
   nsAtom* rootPseudo;
@@ -4441,51 +4440,46 @@ void
 nsCSSFrameConstructor::FinishBuildingScrollFrame(nsContainerFrame* aScrollFrame,
                                                  nsIFrame* aScrolledFrame)
 {
   nsFrameList scrolled(aScrolledFrame, aScrolledFrame);
   aScrollFrame->AppendFrames(kPrincipalList, scrolled);
 }
 
 /**
- * Called to wrap a gfx scrollframe around a frame. The hierarchy will look like
- * this
+ * Called to wrap a gfx scrollframe around a frame. The hierarchy will look like this
+ *
  * ------- for gfx scrollbars ------
  *
  *
  *            ScrollFrame
  *                 ^
  *                 |
  *               Frame (scrolled frame you passed in)
  *
  *
  *-----------------------------------
  * LEGEND:
  *
- * ScrollFrame: This is a frame that manages gfx cross platform frame based
- * scrollbars.
+ * ScrollFrame: This is a frame that manages gfx cross platform frame based scrollbars.
  *
  * @param aContent the content node of the child to wrap.
- *
  * @param aScrolledFrame The frame of the content to wrap. This should not be
- *                       Initialized. This method will initialize it with a
- *                       scrolled pseudo and no nsIContent. The content will be
- *                       attached to the scrollframe returned.
- *
- * @param aContentStyle  the style that has already been resolved for the content
- *                       being passed in.
+ *                    Initialized. This method will initialize it with a scrolled pseudo
+ *                    and no nsIContent. The content will be attached to the scrollframe
+ *                    returned.
+ * @param aContentStyle the style that has already been resolved for the content
+ *                      being passed in.
  *
- * @param aParentFrame   The parent to attach the scroll frame to
+ * @param aParentFrame The parent to attach the scroll frame to
  *
- * @param aNewFrame The new scrollframe or gfx scrollframe that we create. It
- *                  will contain the scrolled frame you passed in. (returned)
+ * @param aNewFrame The new scrollframe or gfx scrollframe that we create. It will contain the
+ *                  scrolled frame you passed in. (returned)
  *                  If this is not null, we'll just use it
- *
- * @param aScrolledContentStyle the style that was resolved for the scrolled
-                                frame. (returned)
+ * @param aScrolledContentStyle the style that was resolved for the scrolled frame. (returned)
  */
 void
 nsCSSFrameConstructor::BuildScrollFrame(nsFrameConstructorState& aState,
                                         nsIContent*              aContent,
                                         ComputedStyle*           aContentStyle,
                                         nsIFrame*                aScrolledFrame,
                                         nsContainerFrame*        aParentFrame,
                                         nsContainerFrame*&       aNewFrame)
--- a/layout/base/nsDocumentViewer.cpp
+++ b/layout/base/nsDocumentViewer.cpp
@@ -3380,19 +3380,18 @@ NS_IMETHODIMP nsDocumentViewer::GetHintC
 
 /* [noscript,notxpcom] Encoding getHintCharset (); */
 NS_IMETHODIMP_(const Encoding *)
 nsDocumentViewer::GetHintCharset()
 {
   if(kCharsetUninitialized == mHintCharsetSource) {
     return nullptr;
   }
-  // this can't possibly be right.  we can't set a value just because somebody
-  // got a related value!
-  // mHintCharsetSource = kCharsetUninitialized;
+  // this can't possibly be right.  we can't set a value just because somebody got a related value!
+  //mHintCharsetSource = kCharsetUninitialized;
   return mHintCharset;
 }
 
 NS_IMETHODIMP nsDocumentViewer::GetHintCharacterSetSource(int32_t *aHintCharacterSetSource)
 {
   NS_ENSURE_ARG_POINTER(aHintCharacterSetSource);
 
   *aHintCharacterSetSource = mHintCharsetSource;
--- a/layout/base/nsIPresShell.h
+++ b/layout/base/nsIPresShell.h
@@ -715,19 +715,18 @@ public:
   };
   typedef struct ScrollAxis {
     int16_t mWhereToScroll;
     WhenToScroll mWhenToScroll : 8;
     bool mOnlyIfPerceivedScrollableDirection : 1;
   /**
    * @param aWhere: Either a percentage or a special value.
    *                nsIPresShell defines:
-   *                * (Default) SCROLL_MINIMUM = -1: The visible area is
-   *                scrolled the minimum amount to show as much as possible
-   *                of the frame.
+   *                * (Default) SCROLL_MINIMUM = -1: The visible area is scrolled
+   *                the minimum amount to show as much as possible of the frame.
    *                This won't hide any initially visible part of the frame.
    *                * SCROLL_TOP = 0: The frame's upper edge is aligned with the
    *                top edge of the visible area.
    *                * SCROLL_BOTTOM = 100: The frame's bottom edge is aligned
    *                with the bottom edge of the visible area.
    *                * SCROLL_LEFT = 0: The frame's left edge is aligned with the
    *                left edge of the visible area.
    *                * SCROLL_RIGHT = 100: The frame's right edge is aligned with
@@ -744,19 +743,19 @@ public:
    *                at all). Note that in this case if the frame is too large to
    *                fit in view, it will only be scrolled if more of it can fit
    *                than is already in view.
    *                * SCROLL_IF_NOT_VISIBLE: Move the frame only if none of it
    *                is visible.
    *                * SCROLL_ALWAYS: Move the frame regardless of its current
    *                visibility.
    * @param aOnlyIfPerceivedScrollableDirection:
-   *                If the direction is not a perceived scrollable direction
-   *                (i.e. no scrollbar showing and less than one device pixel
-   *                of scrollable distance), don't scroll. Defaults to false.
+   *                If the direction is not a perceived scrollable direction (i.e.
+   *                no scrollbar showing and less than one device pixel of
+   *                scrollable distance), don't scroll. Defaults to false.
    */
     explicit ScrollAxis(int16_t aWhere = SCROLL_MINIMUM,
                         WhenToScroll aWhen = SCROLL_IF_NOT_FULLY_VISIBLE,
                         bool aOnlyIfPerceivedScrollableDirection = false) :
       mWhereToScroll(aWhere), mWhenToScroll(aWhen),
       mOnlyIfPerceivedScrollableDirection(aOnlyIfPerceivedScrollableDirection)
     {}
   } ScrollAxis;
--- a/layout/forms/nsComboboxControlFrame.cpp
+++ b/layout/forms/nsComboboxControlFrame.cpp
@@ -854,18 +854,17 @@ nsComboboxControlFrame::Reflow(nsPresCon
   // 5) Block Size of display area is GetBSizeOfARow() on the
   //    mListControlFrame.
 
   if (!mDisplayFrame || !mButtonFrame || !mDropdownFrame) {
     NS_ERROR("Why did the frame constructor allow this to happen?  Fix it!!");
     return;
   }
 
-  // Make sure the displayed text is the same as the selected option,
-  // bug 297389.
+  // Make sure the displayed text is the same as the selected option, bug 297389.
   if (!mDroppedDown) {
     mDisplayedIndex = mListControlFrame->GetSelectedIndex();
   }
   // In dropped down mode the "selected index" is the hovered menu item,
   // we want the last selected item which is |mDisplayedIndex| in this case.
   RedisplayText();
 
   // First reflow our dropdown so that we know how tall we should be.
--- a/layout/forms/nsComboboxControlFrame.h
+++ b/layout/forms/nsComboboxControlFrame.h
@@ -120,18 +120,17 @@ public:
 
   // nsIFormControlFrame
   virtual nsresult SetFormProperty(nsAtom* aName, const nsAString& aValue) override;
   /**
    * Inform the control that it got (or lost) focus.
    * If it lost focus, the dropdown menu will be rolled up if needed,
    * and FireOnChange() will be called.
    * @param aOn true if got focus, false if lost focus.
-   * @param aRepaint if true then force repaint (NOTE: we always force repaint
-   *        currently)
+   * @param aRepaint if true then force repaint (NOTE: we always force repaint currently)
    * @note This method might destroy |this|.
    */
   MOZ_CAN_RUN_SCRIPT_BOUNDARY
   virtual void SetFocus(bool aOn, bool aRepaint) override;
 
   bool IsDroppedDown() { return mDroppedDown; }
   /**
    * @note This method might destroy |this|.
--- a/layout/generic/nsBulletFrame.cpp
+++ b/layout/generic/nsBulletFrame.cpp
@@ -325,17 +325,17 @@ private:
   // generating proper WebRender commands. When webrender is disabled the Path is lazily created
   // for these items before painting.
   // TODO: The size of this structure doesn't seem to be an issue since it has so many fields
   // that are specific to a bullet style or another, but if it becomes one we can easily
   // store mDest and mPathRect into the same memory location since they are never used by
   // the same bullet types.
   LayoutDeviceRect mPathRect;
 
-  // mColor indicate the color of list-style. Both text and path type would use this member.
+  // mColor indicate the color of list-style. Both text and path type would use this memeber.
   nscolor mColor;
 
   // mPath record the path of the list-style for later drawing.
   // Included following types: square, circle, disc, disclosure open and disclosure closed.
   RefPtr<Path> mPath;
 
   // mText, mFontMertrics, mPoint, mFont and mGlyphs are for other
   // list-style-type which can be drawed by text.
--- a/layout/generic/nsColumnSetFrame.cpp
+++ b/layout/generic/nsColumnSetFrame.cpp
@@ -619,19 +619,18 @@ nsColumnSetFrame::ReflowChildren(ReflowO
 
   if (colBSizeChanged) {
     mLastBalanceBSize = aConfig.mColMaxBSize;
     // XXX Seems like this could fire if incremental reflow pushed the column set
     // down so we reflow incrementally with a different available height.
     // We need a way to do an incremental reflow and be sure availableHeight
     // changes are taken account of! Right now I think block frames with absolute
     // children might exit early.
-    // NS_ASSERTION(aKidReason != eReflowReason_Incremental,
-    //             "incremental reflow should not have changed the
-    //             balance height");
+    //NS_ASSERTION(aKidReason != eReflowReason_Incremental,
+    //             "incremental reflow should not have changed the balance height");
   }
 
   // get our border and padding
   LogicalMargin borderPadding = aReflowInput.ComputedLogicalBorderPadding();
   borderPadding.ApplySkipSides(GetLogicalSkipSides(&aReflowInput));
 
   nsRect contentRect(0, 0, 0, 0);
   nsOverflowAreas overflowRects;
--- a/layout/generic/nsFlexContainerFrame.cpp
+++ b/layout/generic/nsFlexContainerFrame.cpp
@@ -1635,18 +1635,17 @@ static bool
 ResolveAutoFlexBasisFromRatio(FlexItem& aFlexItem,
                               const ReflowInput& aItemReflowInput,
                               const FlexboxAxisTracker& aAxisTracker)
 {
   MOZ_ASSERT(NS_AUTOHEIGHT == aFlexItem.GetFlexBaseSize(),
              "Should only be called to resolve an 'auto' flex-basis");
   // If the flex item has ...
   //  - an intrinsic aspect ratio,
-  //  - a [used] flex-basis of 'main-size' [auto?]
-  //    [We have this, if we're here.]
+  //  - a [used] flex-basis of 'main-size' [auto?] [We have this, if we're here.]
   //  - a definite cross size
   // then the flex base size is calculated from its inner cross size and the
   // flex item’s intrinsic aspect ratio.
   if (aAxisTracker.GetCrossComponent(aFlexItem.IntrinsicRatio()) != 0) {
     // We have a usable aspect ratio. (not going to divide by 0)
     const bool useMinSizeIfCrossSizeIsIndefinite = false;
     nscoord crossSizeToUseWithRatio =
       CrossSizeToUseWithRatio(aFlexItem, aItemReflowInput,
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -8608,22 +8608,22 @@ nsIFrame::PeekOffset(nsPeekOffsetStruct*
         // This pref only affects whether moving forward by word should go to the end of this word or start of the next word.
         // When going backwards, the start of the word is always used, on every operating system.
         wordSelectEatSpace = aPos->mDirection == eDirNext &&
           Preferences::GetBool("layout.word_select.eat_space_to_next_word");
       }
 
       // mSawBeforeType means "we already saw characters of the type
       // before the boundary we're looking for". Examples:
-      // 1. If we're moving forward, looking for a word beginning (i.e. a
-      //    boundary between whitespace and non-whitespace), then
-      //    eatingWS==true means "we already saw some whitespace".
-      // 2. If we're moving backward, looking for a word beginning (i.e. a
-      //    boundary between non-whitespace and whitespace), then
-      //     eatingWS==true means "we already saw some non-whitespace".
+      // 1. If we're moving forward, looking for a word beginning (i.e. a boundary
+      //    between whitespace and non-whitespace), then eatingWS==true means
+      //    "we already saw some whitespace".
+      // 2. If we're moving backward, looking for a word beginning (i.e. a boundary
+      //    between non-whitespace and whitespace), then eatingWS==true means
+      //    "we already saw some non-whitespace".
       PeekWordState state;
       int32_t offsetAdjustment = 0;
       bool done = false;
       while (!done) {
         bool movingInFrameDirection =
           IsMovingInFrameDirection(current, aPos->mDirection, aPos->mVisual);
 
         done = current->PeekOffsetWord(movingInFrameDirection, wordSelectEatSpace,
--- a/layout/generic/nsFrameSelection.h
+++ b/layout/generic/nsFrameSelection.h
@@ -225,79 +225,63 @@ public:
 
   /*interfaces for addref and release and queryinterface*/
 
   NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(nsFrameSelection)
   NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(nsFrameSelection)
 
   /** Init will initialize the frame selector with the necessary pres shell to
    *  be used by most of the methods
-   *  @param aShell is the parameter to be used for most of the other calls for
-   *         callbacks etc
+   *  @param aShell is the parameter to be used for most of the other calls for callbacks etc
    *  @param aLimiter limits the selection to nodes with aLimiter parents
-   *  @param aAccessibleCaretEnabled true if we should enable the accessible
-   *         caret.
+   *  @param aAccessibleCaretEnabled true if we should enable the accessible caret.
    */
   void Init(nsIPresShell *aShell, nsIContent *aLimiter,
             bool aAccessibleCaretEnabled);
 
   /** HandleClick will take the focus to the new frame at the new offset and
-   *  will either extend the selection from the old anchor, or replace the old
-   *  anchor.
+   *  will either extend the selection from the old anchor, or replace the old anchor.
    *  the old anchor and focus position may also be used to deselect things
    *  @param aNewfocus is the content that wants the focus
    *  @param aContentOffset is the content offset of the parent aNewFocus
-   *  @param aContentOffsetEnd is the content offset of the parent aNewFocus
-   *                           and is specified different when you need to
-   *                           select to and include both start and end points
-   *  @param aContinueSelection is the flag that tells the selection to keep
-   *                            the old anchor point or not.
-   *  @param aMultipleSelection will tell the frame selector to replace /or not
-   *                            the old selection.
-   *                            cannot coexist with aContinueSelection
-   *  @param aHint will tell the selection which direction geometrically to
-   *               actually show the caret on.
+   *  @param aContentOffsetEnd is the content offset of the parent aNewFocus and is specified different
+   *                           when you need to select to and include both start and end points
+   *  @param aContinueSelection is the flag that tells the selection to keep the old anchor point or not.
+   *  @param aMultipleSelection will tell the frame selector to replace /or not the old selection.
+   *         cannot coexist with aContinueSelection
+   *  @param aHint will tell the selection which direction geometrically to actually show the caret on.
    *         1 = end of this line 0 = beginning of this line
    */
   MOZ_CAN_RUN_SCRIPT_BOUNDARY
   nsresult HandleClick(nsIContent *aNewFocus,
                        uint32_t aContentOffset,
                        uint32_t aContentEndOffset,
                        bool aContinueSelection,
                        bool aMultipleSelection,
                        CaretAssociateHint aHint);
 
   /** HandleDrag extends the selection to contain the frame closest to aPoint.
-   *  @param aPresContext is the context to use when figuring out what frame
-   *                      contains the point.
-   *  @param aFrame is the parent of all frames to use when searching for the
-   *                closest frame to the point.
+   *  @param aPresContext is the context to use when figuring out what frame contains the point.
+   *  @param aFrame is the parent of all frames to use when searching for the closest frame to the point.
    *  @param aPoint is relative to aFrame
    */
   /*unsafe*/
   void HandleDrag(nsIFrame* aFrame, const nsPoint& aPoint);
 
   /** HandleTableSelection will set selection to a table, cell, etc
    *   depending on information contained in aFlags
-   *  @param aParentContent is the parent of either a table or cell that
-   *                        user clicked or dragged the mouse in
+   *  @param aParentContent is the paretent of either a table or cell that user clicked or dragged the mouse in
    *  @param aContentOffset is the offset of the table or cell
    *  @param aTarget indicates what to select
-   *    TableSelection::Cell     We should select a cell
-   *                             (content points to the cell)
-   *    TableSelection::Row      We should select a row
-   *                             (content points to any cell in row)
-   *    TableSelection::Column   We should select a row
-   *                             (content points to any cell in column)
-   *    TableSelection::Table    We should select a table
-   *                             (content points to the table)
-   *    TableSelection::AllCells We should select all cells
-   *                             (content points to any cell in table)
-   *  @param aMouseEvent         passed in so we can get where event occurred
-   *                             and what keys are pressed
+   *    TableSelection::Cell     We should select a cell (content points to the cell)
+   *    TableSelection::Row      We should select a row (content points to any cell in row)
+   *    TableSelection::Column   We should select a row (content points to any cell in column)
+   *    TableSelection::Table    We should select a table (content points to the table)
+   *    TableSelection::AllCells We should select all cells (content points to any cell in table)
+   *  @param aMouseEvent         passed in so we can get where event occurred and what keys are pressed
    */
   /*unsafe*/
   nsresult HandleTableSelection(nsINode* aParentContent,
                                 int32_t aContentOffset,
                                 mozilla::TableSelection aTarget,
                                 mozilla::WidgetMouseEvent* aMouseEvent);
 
   /**
@@ -367,18 +351,17 @@ public:
                                 const nsPoint& aPoint,
                                 uint32_t aDelay);
 
   /** StopAutoScrollTimer stops any active auto scroll timer.
    */
   void StopAutoScrollTimer();
 
   /** Lookup Selection
-   *  returns in frame coordinates the selection beginning and ending with the
-   *  type of selection given
+   *  returns in frame coordinates the selection beginning and ending with the type of selection given
    * @param aContent is the content asking
    * @param aContentOffset is the starting content boundary
    * @param aContentLength is the length of the content piece asking
    * @param aSlowCheck will check using slow method with no shortcuts
    */
   mozilla::UniquePtr<SelectionDetails> LookUpSelection(nsIContent *aContent,
                                                        int32_t aContentOffset,
                                                        int32_t aContentLength,
@@ -531,35 +514,32 @@ public:
   /** WordMove will generally be called from the nsiselectioncontroller implementations.
    *  the effect being the selection will move one word left or right.
    * @param aForward move forward in document.
    * @param aExtend continue selection
    */
   /*unsafe*/
   nsresult WordMove(bool aForward, bool aExtend);
 
-  /** WordExtendForDelete extends the selection backward or forward
-   *  (logically) to the next word boundary, so that the selected word
-   *  can be deleted.
+  /** WordExtendForDelete extends the selection backward or forward (logically) to the
+   *  next word boundary, so that the selected word can be deleted.
    * @param aForward select forward in document.
    */
   /*unsafe*/
   nsresult WordExtendForDelete(bool aForward);
 
-  /** LineMove will generally be called from the nsiselectioncontroller
-   *  implementations.
+  /** LineMove will generally be called from the nsiselectioncontroller implementations.
    *  the effect being the selection will move one line up or down.
    * @param aForward move forward in document.
    * @param aExtend continue selection
    */
   /*unsafe*/
   nsresult LineMove(bool aForward, bool aExtend);
 
-  /** IntraLineMove will generally be called from the nsiselectioncontroller
-   *  implementations.
+  /** IntraLineMove will generally be called from the nsiselectioncontroller implementations.
    *  the effect being the selection will move to beginning or end of line
    * @param aForward move forward in document.
    * @param aExtend continue selection
    */
   /*unsafe*/
   nsresult IntraLineMove(bool aForward, bool aExtend);
 
   /** Select All will generally be called from the nsiselectioncontroller implementations.
--- a/layout/generic/nsFrameSetFrame.cpp
+++ b/layout/generic/nsFrameSetFrame.cpp
@@ -800,18 +800,17 @@ nsHTMLFramesetFrame::Reflow(nsPresContex
   DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
   MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
 
   nsIPresShell *shell = aPresContext->PresShell();
   ServoStyleSet* styleSet = shell->StyleSet();
 
   GetParent()->AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
 
-  // printf("FramesetFrame2::Reflow %X (%d,%d) \n", this,
-  // aReflowInput.AvailableWidth(), aReflowInput.AvailableHeight());
+  //printf("FramesetFrame2::Reflow %X (%d,%d) \n", this, aReflowInput.AvailableWidth(), aReflowInput.AvailableHeight());
   // Always get the size so that the caller knows how big we are
   GetDesiredSize(aPresContext, aReflowInput, aDesiredSize);
 
   nscoord width  = (aDesiredSize.Width() <= aReflowInput.AvailableWidth())
     ? aDesiredSize.Width() : aReflowInput.AvailableWidth();
   nscoord height = (aDesiredSize.Height() <= aReflowInput.AvailableHeight())
     ? aDesiredSize.Height() : aReflowInput.AvailableHeight();
 
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -48,29 +48,28 @@
 #include "nsDisplayItemTypes.h"
 
 #ifdef ACCESSIBILITY
 #include "mozilla/a11y/AccTypes.h"
 #endif
 
 /**
  * New rules of reflow:
- * 1. you get a WillReflow() followed by a Reflow() followed by a DidReflow() in
- *    order (no separate pass over the tree)
- * 2. it's the parent frame's responsibility to size/position the child's view
- *    (not the child frame's responsibility as it is today) during reflow (and
- *    before sending the DidReflow() notification)
- * 3. positioning of child frames (and their views) is done on the way down the
- *    tree, and sizing of child frames (and their views) on the way back up
- * 4. if you move a frame (outside of the reflow process, or after reflowing
- *    it), then you must make sure that its view (or its child frame's views)
- *    are re-positioned as well. It's reasonable to not position the view until
- *    after all reflowing the entire line, for example, but the frame should
- *    still be positioned and sized (and the view sized) during the reflow
- *    (i.e., before sending the DidReflow() notification)
+ * 1. you get a WillReflow() followed by a Reflow() followed by a DidReflow() in order
+ *    (no separate pass over the tree)
+ * 2. it's the parent frame's responsibility to size/position the child's view (not
+ *    the child frame's responsibility as it is today) during reflow (and before
+ *    sending the DidReflow() notification)
+ * 3. positioning of child frames (and their views) is done on the way down the tree,
+ *    and sizing of child frames (and their views) on the way back up
+ * 4. if you move a frame (outside of the reflow process, or after reflowing it),
+ *    then you must make sure that its view (or its child frame's views) are re-positioned
+ *    as well. It's reasonable to not position the view until after all reflowing the
+ *    entire line, for example, but the frame should still be positioned and sized (and
+ *    the view sized) during the reflow (i.e., before sending the DidReflow() notification)
  * 5. the view system handles moving of widgets, i.e., it's not our problem
  */
 
 class nsAtom;
 class nsPresContext;
 class nsIPresShell;
 class nsView;
 class nsIWidget;
@@ -3272,48 +3271,40 @@ public:
    *  return NS_ERROR_FAILURE
    *  @param aPOS is defined in nsFrameSelection
    */
   virtual nsresult PeekOffset(nsPeekOffsetStruct *aPos);
 
   /**
    *  called to find the previous/next non-anonymous selectable leaf frame.
    *  @param aDirection [in] the direction to move in (eDirPrevious or eDirNext)
-   *  @param aVisual [in] whether bidi caret behavior is visual (true) or
-   *                      logical (false)
+   *  @param aVisual [in] whether bidi caret behavior is visual (true) or logical (false)
    *  @param aJumpLines [in] whether to allow jumping across line boundaries
-   *  @param aScrollViewStop [in] whether to stop when reaching a scroll frame
-                                  boundary
+   *  @param aScrollViewStop [in] whether to stop when reaching a scroll frame boundary
    *  @param aOutFrame [out] the previous/next selectable leaf frame
-   *  @param aOutOffset [out] 0 indicates that we arrived at the beginning of
-                              the output frame;
+   *  @param aOutOffset [out] 0 indicates that we arrived at the beginning of the output frame;
    *                          -1 indicates that we arrived at its end.
-   *  @param aOutJumpedLine [out] whether this frame and the returned frame
-                                  are on different lines
-   *  @param aOutMovedOverNonSelectableText [out] whether we jumped over a
-                                                  non-selectable
+   *  @param aOutJumpedLine [out] whether this frame and the returned frame are on different lines
+   *  @param aOutMovedOverNonSelectableText [out] whether we jumped over a non-selectable
    *                                              frame during the search
    */
   nsresult GetFrameFromDirection(nsDirection aDirection, bool aVisual,
                                  bool aJumpLines, bool aScrollViewStop,
                                  bool aForceEditableRegion,
                                  nsIFrame** aOutFrame, int32_t* aOutOffset,
                                  bool* aOutJumpedLine, bool* aOutMovedOverNonSelectableText);
 
   /**
-   *  called to see if the children of the frame are visible from indexstart
-   *  to index end.
-   *  this does not change any state. returns true only if the indexes are
-   *  valid and any of the children are visible.  for textframes this index is
-   *  the character index.
+   *  called to see if the children of the frame are visible from indexstart to index end.
+   *  this does not change any state. returns true only if the indexes are valid and any of
+   *  the children are visible.  for textframes this index is the character index.
    *  if aStart = aEnd result will be false
    *  @param aStart start index of first child from 0-N (number of children)
    *  @param aEnd   end index of last child from 0-N
-   *  @param aRecurse should this frame talk to siblings to get to the contents
-   *                  other children?
+   *  @param aRecurse should this frame talk to siblings to get to the contents other children?
    *  @param aFinished did this frame have the aEndIndex? or is there more work to do
    *  @param _retval  return value true or false. false = range is not rendered.
    */
   virtual nsresult CheckVisibility(nsPresContext* aContext, int32_t aStartIndex, int32_t aEndIndex, bool aRecurse, bool *aFinished, bool *_retval)=0;
 
   /**
    * Called to tell a frame that one of its child frames is dirty (i.e.,
    * has the NS_FRAME_IS_DIRTY *or* NS_FRAME_HAS_DIRTY_CHILDREN bit
@@ -4352,18 +4343,17 @@ protected:
 
   // There is a 1-bit gap left here.
 
   // Helpers
   /**
    * Can we stop inside this frame when we're skipping non-rendered whitespace?
    * @param  aForward [in] Are we moving forward (or backward) in content order.
    * @param  aOffset [in/out] At what offset into the frame to start looking.
-   *         on output - what offset was reached (whether or not we found a place to
-   *         stop).
+   *         on output - what offset was reached (whether or not we found a place to stop).
    * @return STOP: An appropriate offset was found within this frame,
    *         and is given by aOffset.
    *         CONTINUE: Not found within this frame, need to try the next frame.
    *         see enum FrameSearchResult for more details.
    */
   virtual FrameSearchResult PeekOffsetNoAmount(bool aForward, int32_t* aOffset) = 0;
 
   /**
@@ -4436,18 +4426,18 @@ protected:
       mAtStart = false;
     }
   };
   virtual FrameSearchResult PeekOffsetWord(bool aForward, bool aWordSelectEatSpace, bool aIsKeyboardSelect,
                                 int32_t* aOffset, PeekWordState* aState) = 0;
 
   /**
    * Search for the first paragraph boundary before or after the given position
-   * @param  aPos See description in nsFrameSelection.h. The following fields
-   *              are used by this method:
+   * @param  aPos See description in nsFrameSelection.h. The following fields are
+   *              used by this method:
    *              Input: mDirection
    *              Output: mResultContent, mContentOffset
    */
   nsresult PeekOffsetParagraph(nsPeekOffsetStruct *aPos);
 
 private:
   // Get a pointer to the overflow areas property attached to the frame.
   nsOverflowAreas* GetOverflowAreasProperty() const {
--- a/layout/generic/nsLineLayout.cpp
+++ b/layout/generic/nsLineLayout.cpp
@@ -2288,19 +2288,19 @@ nsLineLayout::VerticalAlignFrames(PerSpa
     // Update minBCoord/maxBCoord for frames that we just placed. Do not factor
     // text into the equation.
     if (pfd->mBlockDirAlign == VALIGN_OTHER) {
       // Text frames do not contribute to the min/max Y values for the
       // line (instead their parent frame's font-size contributes).
       // XXXrbs -- relax this restriction because it causes text frames
       //           to jam together when 'font-size-adjust' is enabled
       //           and layout is using dynamic font heights (bug 20394)
-      //        -- Note #1: With this code enabled and with the fact that we are
-      //           not using Em[Ascent|Descent] as nsDimensions for text
-      //           metrics in GFX mean that the discussion in bug 13072 cannot hold.
+      //        -- Note #1: With this code enabled and with the fact that we are not
+      //           using Em[Ascent|Descent] as nsDimensions for text metrics in
+      //           GFX mean that the discussion in bug 13072 cannot hold.
       //        -- Note #2: We still don't want empty-text frames to interfere.
       //           For example in quirks mode, avoiding empty text frames prevents
       //           "tall" lines around elements like <hr> since the rules of <hr>
       //           in quirks.css have pseudo text contents with LF in them.
       bool canUpdate;
       if (pfd->mIsTextFrame) {
         // Only consider text frames if they're not empty and
         // line-height=normal.
--- a/layout/mathml/nsIMathMLFrame.h
+++ b/layout/mathml/nsIMathMLFrame.h
@@ -122,30 +122,27 @@ public:
    *
    * As a rule of thumb:
    *
    * 1. Use InheritAutomaticData() to set properties related to your ancestors:
    *    - set properties that are intrinsic to yourself
    *    - set properties that depend on the state that you expect your ancestors
    *      to have already reached in their own InheritAutomaticData().
    *    - set properties that your descendants assume that you would have set in
-   *      your InheritAutomaticData() -- this way, they can safely query them
-   *      and the process will feed upon itself.
+   *      your InheritAutomaticData() -- this way, they can safely query them and
+   *      the process will feed upon itself.
    *
-   * 2. Use TransmitAutomaticData() to set properties related to your
-   *    descendants:
-   *    - set properties that depend on the state that you expect your
-   *      descendants to have reached upon processing their own
-   *      TransmitAutomaticData().
-   *    - transmit properties that your descendants expect that you will
-   *      transmit to them in your TransmitAutomaticData() -- this way, they
-   *      remain up-to-date.
+   * 2. Use TransmitAutomaticData() to set properties related to your descendants:
+   *    - set properties that depend on the state that you expect your descendants
+   *      to have reached upon processing their own TransmitAutomaticData().
+   *    - transmit properties that your descendants expect that you will transmit to
+   *      them in your TransmitAutomaticData() -- this way, they remain up-to-date.
    *    - set properties that your ancestors expect that you would set in your
-   *      TransmitAutomaticData() -- this way, they can safely query them and
-   *      the process will feed upon itself.
+   *      TransmitAutomaticData() -- this way, they can safely query them and the
+   *      process will feed upon itself.
    */
 
   NS_IMETHOD
   InheritAutomaticData(nsIFrame* aParent) = 0;
 
   NS_IMETHOD
   TransmitAutomaticData() = 0;
 
--- a/layout/mathml/nsMathMLContainerFrame.h
+++ b/layout/mathml/nsMathMLContainerFrame.h
@@ -394,20 +394,18 @@ private:
 
 
 // --------------------------------------------------------------------------
 // Currently, to benefit from line-breaking inside the <math> element, <math> is
 // simply mapping to nsBlockFrame or nsInlineFrame.
 // A separate implemention needs to provide:
 // 1) line-breaking
 // 2) proper inter-frame spacing
-// 3) firing of Stretch() (in which case FinalizeReflow() would have to be
-//    cleaned)
-// Issues: If/when mathml becomes a pluggable component, the separation will be
-// needed.
+// 3) firing of Stretch() (in which case FinalizeReflow() would have to be cleaned)
+// Issues: If/when mathml becomes a pluggable component, the separation will be needed.
 class nsMathMLmathBlockFrame final : public nsBlockFrame
 {
 public:
   NS_DECL_QUERYFRAME
   NS_DECL_FRAMEARENA_HELPERS(nsMathMLmathBlockFrame)
 
   friend nsContainerFrame* NS_NewMathMLmathBlockFrame(nsIPresShell* aPresShell,
           ComputedStyle* aStyle);
--- a/layout/mathml/nsMathMLmpaddedFrame.cpp
+++ b/layout/mathml/nsMathMLmpaddedFrame.cpp
@@ -50,27 +50,25 @@ nsMathMLmpaddedFrame::InheritAutomaticDa
   mPresentationData.flags |= NS_MATHML_STRETCH_ALL_CHILDREN_VERTICALLY;
 
   return NS_OK;
 }
 
 void
 nsMathMLmpaddedFrame::ProcessAttributes()
 {
-  // clang-format off
   /*
   parse the attributes
 
   width  = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | h-unit | namedspace)
   height = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
   depth  = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
   lspace = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | h-unit | namedspace)
   voffset= [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
   */
-  // clang-format on
 
   nsAutoString value;
 
   // width
   mWidthSign = NS_MATHML_SIGN_INVALID;
   mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::width, value);
   if (!value.IsEmpty()) {
     if (!ParseAttribute(value, mWidthSign, mWidth, mWidthPseudoUnit)) {
--- a/layout/mathml/nsMathMLmunderoverFrame.cpp
+++ b/layout/mathml/nsMathMLmunderoverFrame.cpp
@@ -10,18 +10,17 @@
 #include "nsMathMLElement.h"
 #include <algorithm>
 #include "gfxContext.h"
 #include "gfxMathTable.h"
 
 using namespace mozilla;
 
 //
-// <munderover> -- attach an underscript-overscript pair to a base
-//                 implementation
+// <munderover> -- attach an underscript-overscript pair to a base - implementation
 // <mover> -- attach an overscript to a base - implementation
 // <munder> -- attach an underscript to a base - implementation
 //
 
 nsIFrame*
 NS_NewMathMLmunderoverFrame(nsIPresShell* aPresShell, ComputedStyle* aStyle)
 {
   return new (aPresShell) nsMathMLmunderoverFrame(aStyle);
--- a/layout/style/StyleSheet.cpp
+++ b/layout/style/StyleSheet.cpp
@@ -981,21 +981,19 @@ StyleSheet::CreateEmptyChildSheet(
   child->mMedia = aMediaList;
   return child.forget();
 }
 
 // We disable parallel stylesheet parsing if any of the following three
 // conditions hold:
 //
 // (1) The pref is off.
-// (2) The browser is recording CSS errors (which parallel parsing can't
-//     handle).
-// (3) The stylesheet is a chrome stylesheet, since those can use
-//     -moz-bool-pref, which needs to access the pref service, which is
-//     not threadsafe.
+// (2) The browser is recording CSS errors (which parallel parsing can't handle).
+// (3) The stylesheet is a chrome stylesheet, since those can use -moz-bool-pref,
+//     which needs to access the pref service, which is not threadsafe.
 static bool
 AllowParallelParse(css::Loader* aLoader, nsIURI* aSheetURI)
 {
   // Check the pref.
   if (!StaticPrefs::layout_css_parsing_parallel()) {
     return false;
   }
 
--- a/layout/style/nsCSSProps.h
+++ b/layout/style/nsCSSProps.h
@@ -312,29 +312,28 @@ public:
   static const KTableEntry kBorderStyleKTable[];
   static const KTableEntry kShapeRadiusKTable[];
   static const KTableEntry kFilterFunctionKTable[];
   static const KTableEntry kBoxShadowTypeKTable[];
   static const KTableEntry kCursorKTable[];
   // Not const because we modify its entries when various
   // "layout.css.*.enabled" prefs changes:
   static KTableEntry kDisplayKTable[];
-  // -- tables for parsing the {align,justify}-{content,items,self} properties
+  // -- tables for parsing the {align,justify}-{content,items,self} properties --
   static const KTableEntry kAlignAllKeywords[];
   static const KTableEntry kAlignOverflowPosition[]; // <overflow-position>
   static const KTableEntry kAlignSelfPosition[];     // <self-position>
   static const KTableEntry kAlignLegacy[];           // 'legacy'
   static const KTableEntry kAlignLegacyPosition[];   // 'left/right/center'
   static const KTableEntry kAlignAutoNormalStretchBaseline[]; // 'auto/normal/stretch/baseline'
   static const KTableEntry kAlignNormalStretchBaseline[]; // 'normal/stretch/baseline'
   static const KTableEntry kAlignNormalBaseline[]; // 'normal/baseline'
   static const KTableEntry kAlignContentDistribution[]; // <content-distribution>
   static const KTableEntry kAlignContentPosition[]; // <content-position>
-  // -- tables for auto-completion of the {align,justify}-{content,items,self}
-  // properties
+  // -- tables for auto-completion of the {align,justify}-{content,items,self} properties --
   static const KTableEntry kAutoCompletionAlignJustifySelf[];
   static const KTableEntry kAutoCompletionAlignItems[];
   static const KTableEntry kAutoCompletionAlignJustifyContent[];
   // ------------------------------------------------------------------
   static const KTableEntry kFontSmoothingKTable[];
   static const KTableEntry kGridAutoFlowKTable[];
   static const KTableEntry kGridTrackBreadthKTable[];
   static const KTableEntry kLineHeightKTable[];
--- a/layout/svg/SVGTextFrame.cpp
+++ b/layout/svg/SVGTextFrame.cpp
@@ -529,18 +529,17 @@ struct TextRenderedRun
    * The difference between this method and GetTransformFromRunUserSpaceToUserSpace
    * is that when calling in to nsTextFrame::PaintText, it will already take
    * into account any left clip edge (that is, it doesn't just apply a visual
    * clip to the rendered text, it shifts the glyphs over so that they are
    * painted with their left edge at the x coordinate passed in to it).
    * Thus we need to account for this in our transform.
    *
    *
-   * Assume that we have
-   * <text x="100" y="100" rotate="0 0 1 0 0 1">abcdef</text>.
+   * Assume that we have <text x="100" y="100" rotate="0 0 1 0 0 1">abcdef</text>.
    * This would result in four text rendered runs:
    *
    *   - one for "ab"
    *   - one for "c"
    *   - one for "de"
    *   - one for "f"
    *
    * Assume now that we are painting the third TextRenderedRun.  It will have
--- a/layout/tables/celldata.h
+++ b/layout/tables/celldata.h
@@ -57,52 +57,48 @@ public:
     */
   bool IsZeroRowSpan() const;
 
   /** mark the current entry as spanned by a zero rowspan
     * @param aIsZero    if true mark the entry as covered by a zero rowspan
     */
   void SetZeroRowSpan(bool aIsZero);
 
-  /** get the distance from the current entry to the corresponding origin of the
-   * rowspan
-   * @return    containing the distance in the column to the originating cell
-   */
+  /** get the distance from the current entry to the corresponding origin of the rowspan
+    * @return    containing the distance in the column to the originating cell
+    */
   uint32_t GetRowSpanOffset() const;
 
-  /** set the distance from the current entry to the corresponding origin of
-   * the rowspan
-   * @param    the distance in the column to the originating cell
-   */
+  /** set the distance from the current entry to the corresponding origin of the rowspan
+    * @param    the distance in the column to the originating cell
+    */
   void SetRowSpanOffset(uint32_t aSpan);
 
   /** is the entry spanned by colspan
     * @return    is true if the entry is spanned by a colspan
     */
   bool IsColSpan() const;
 
-  /** get the distance from the current entry to the corresponding origin of
-   *  the colspan
-   * @return    containing the distance in the row to the originating cell
-   */
+  /** get the distance from the current entry to the corresponding origin of the colspan
+    * @return    containing the distance in the row to the originating cell
+    */
   uint32_t GetColSpanOffset() const;
 
   /** set the distance from the current entry to the corresponding origin of the colspan
     * @param    the distance in the column to the originating cell
     */
   void SetColSpanOffset(uint32_t aSpan);
 
   /** is the entry spanned by a row- and a colspan
     * @return    is true if the entry is spanned by a row- and a colspan
     */
   bool IsOverlap() const;
 
   /** mark the current entry as spanned by a row- and a colspan
-    * @param aOverlap    if true mark the entry as covered by a row- and
-    *                    a colspan
+    * @param aOverlap    if true mark the entry as covered by a row- and a colspan
     */
   void SetOverlap(bool aOverlap);
 
   /** get the table cell frame for this entry
     * @return    a pointer to the cellframe, this will be nullptr when the entry
     *            is only a spanned entry
     */
   nsTableCellFrame* GetCellFrame() const;
--- a/layout/tables/nsCellMap.h
+++ b/layout/tables/nsCellMap.h
@@ -318,24 +318,23 @@ public:
   void GetRowAndColumnByIndex(int32_t aColCount, int32_t aIndex,
                               int32_t *aRow, int32_t *aColumn) const;
 
   /** append the cellFrame at an empty or dead cell or finally at the end of
     * the row at aRowIndex and return a pointer to the celldata entry in the
     * cellmap
     *
     * @param aMap               - reference to the table cell map
-    * @param aCellFrame         - a pointer to the cellframe which will be
-    *                             appended to the row
+    * @param aCellFrame         - a pointer to the cellframe which will be appended
+    *                             to the row
     * @param aRowIndex          - to this row the celldata entry will be added
     * @param aRebuildIfNecessay - if a cell spans into a row below it might be
-    *                             necesserary to rebuild the cellmap as this
-    *                             rowspan might overlap another cell.
-    * @param aDamageArea        - area in cellmap coordinates which have been
-    *                             updated.
+    *                             necesserary to rebuild the cellmap as this rowspan
+    *                             might overlap another cell.
+    * @param aDamageArea        - area in cellmap coordinates which have been updated.
     * @param aColToBeginSearch  - if not null contains the column number where
     *                             the search for a empty or dead cell in the
     *                             row should start
     * @return                   - a pointer to the celldata entry inserted into
     *                             the cellmap
     */
   CellData* AppendCell(nsTableCellMap&   aMap,
                        nsTableCellFrame* aCellFrame,
--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -4332,18 +4332,18 @@ nsTableFrame::ColumnHasCellSpacingBefore
 /********************************************************************************
  * Collapsing Borders
  *
  *  The CSS spec says to resolve border conflicts in this order:
  *  1) any border with the style HIDDEN wins
  *  2) the widest border with a style that is not NONE wins
  *  3) the border styles are ranked in this order, highest to lowest precedence:
  *     double, solid, dashed, dotted, ridge, outset, groove, inset
- *  4) borders that are of equal width and style (differ only in color) have
- *     this precedence: cell, row, rowgroup, col, colgroup, table
+ *  4) borders that are of equal width and style (differ only in color) have this precedence:
+ *     cell, row, rowgroup, col, colgroup, table
  *  5) if all border styles are NONE, then that's the computed border style.
  *******************************************************************************/
 
 #ifdef DEBUG
 #define VerifyNonNegativeDamageRect(r)                                  \
   NS_ASSERTION((r).StartCol() >= 0, "negative col index");              \
   NS_ASSERTION((r).StartRow() >= 0, "negative row index");              \
   NS_ASSERTION((r).ColCount() >= 0, "negative cols damage");            \
--- a/layout/tables/nsTableRowFrame.h
+++ b/layout/tables/nsTableRowFrame.h
@@ -80,24 +80,23 @@ public:
   virtual void BuildDisplayList(nsDisplayListBuilder*   aBuilder,
                                 const nsDisplayListSet& aLists) override;
 
   // Implemented in nsTableCellFrame.h, because it needs to know about the
   // nsTableCellFrame class, but we can't include nsTableCellFrame.h here.
   inline nsTableCellFrame* GetFirstCell() const;
 
   /** calls Reflow for all of its child cells.
-    * Cells with rowspan=1 are all set to the same height and stacked
-    * horizontally.
+    * Cells with rowspan=1 are all set to the same height and stacked horizontally.
     * <P> Cells are not split unless absolutely necessary.
     * <P> Cells are resized in nsTableFrame::BalanceColumnWidths
     * and nsTableFrame::ShrinkWrapChildren
     *
-    * @param aDesiredSize width set to width of the sum of the cells,
-    *                     height set to height of cells with rowspan=1.
+    * @param aDesiredSize width set to width of the sum of the cells, height set to
+    *                     height of cells with rowspan=1.
     *
     * @see nsIFrame::Reflow
     * @see nsTableFrame::BalanceColumnWidths
     * @see nsTableFrame::ShrinkWrapChildren
     */
   virtual void Reflow(nsPresContext*           aPresContext,
                       ReflowOutput&     aDesiredSize,
                       const ReflowInput& aReflowInput,
@@ -296,18 +295,17 @@ private:
   nscoord mContentBSize;
   // the bsize based on a style percentage bsize on either the row or any cell
   // if mHasPctBSize is set
   nscoord mStylePctBSize;
   // the bsize based on a style pixel bsize on the row or any
   // cell if mHasFixedBSize is set
   nscoord mStyleFixedBSize;
 
-  // max-ascent and max-descent amongst all cells that have
-  // 'vertical-align: baseline'
+  // max-ascent and max-descent amongst all cells that have 'vertical-align: baseline'
   nscoord mMaxCellAscent;  // does include cells with rowspan > 1
   nscoord mMaxCellDescent; // does *not* include cells with rowspan > 1
 
   // border widths in pixels in the collapsing border model of the *inner*
   // half of the border only
   BCPixelSize mBStartBorderWidth;
   BCPixelSize mBEndBorderWidth;
   BCPixelSize mIEndContBorderWidth;
--- a/layout/tables/nsTableRowGroupFrame.h
+++ b/layout/tables/nsTableRowGroupFrame.h
@@ -229,18 +229,17 @@ public:
     * @return               row index relative to the row group if this a row
     *                       frame and the index is at least aStartLine.
     *                       -1 if the frame cannot be found.
     */
   virtual int32_t FindLineContaining(nsIFrame* aFrame, int32_t aStartLine = 0) override;
 
   /** Find the orginating cell frame on a row that is the nearest to the
     * inline-dir coordinate of aPos.
-    * @param aLineNumber          - the index of the row relative to the row
-    *                               group
+    * @param aLineNumber          - the index of the row relative to the row group
     * @param aPos                 - coordinate in twips relative to the
     *                               origin of the row group
     * @param aFrameFound          - pointer to the cellframe
     * @param aPosIsBeforeFirstFrame - the point is before the first originating
     *                               cellframe
     * @param aPosIsAfterLastFrame   - the point is after the last originating
     *                               cellframe
     */
@@ -296,20 +295,20 @@ public:
       mFrames.Compact();
     }
   };
 
   // Clear out row cursor because we're disturbing the rows (e.g., Reflow)
   void ClearRowCursor();
 
   /**
-   * Get the first row that might contain y-coord 'aY', or nullptr if you must
-   * search all rows.
-   * The actual row returned might not contain 'aY', but if not, it is
-   * guaranteed to be before any row which does contain 'aY'.
+   * Get the first row that might contain y-coord 'aY', or nullptr if you must search
+   * all rows.
+   * The actual row returned might not contain 'aY', but if not, it is guaranteed
+   * to be before any row which does contain 'aY'.
    * aOverflowAbove is the maximum over all rows of -row.GetOverflowRect().y.
    * To find all rows that intersect the vertical interval aY/aYMost, call
    * GetFirstRowContaining(aY, &overflowAbove), and then iterate through all
    * rows until reaching a row where row->GetRect().y - overflowAbove >= aYMost.
    * That row and all subsequent rows cannot intersect the interval.
    */
   nsIFrame* GetFirstRowContaining(nscoord aY, nscoord* aOverflowAbove);
 
--- a/layout/xul/BoxObject.cpp
+++ b/layout/xul/BoxObject.cpp
@@ -16,17 +16,17 @@
 #include "nsView.h"
 #include "nsLayoutUtils.h"
 #include "nsISupportsPrimitives.h"
 #include "nsSupportsPrimitives.h"
 #include "mozilla/dom/Element.h"
 #include "nsComponentManagerUtils.h"
 #include "mozilla/dom/BoxObjectBinding.h"
 
-// Implementation /////////////////////////////////////////////////////////////
+// Implementation /////////////////////////////////////////////////////////////////
 
 namespace mozilla {
 namespace dom {
 
 // Static member variable initialization
 
 // Implement our nsISupports methods
 NS_IMPL_CYCLE_COLLECTION_CLASS(BoxObject)
@@ -69,17 +69,17 @@ BoxObject::~BoxObject()
 NS_IMETHODIMP
 BoxObject::GetElement(Element** aResult)
 {
   RefPtr<Element> element = mContent;
   element.forget(aResult);
   return NS_OK;
 }
 
-// nsPIBoxObject //////////////////////////////////////////////////////////////
+// nsPIBoxObject //////////////////////////////////////////////////////////////////////////
 
 nsresult
 BoxObject::Init(Element* aElement)
 {
   mContent = aElement;
   return NS_OK;
 }
 
--- a/layout/xul/grid/nsGrid.cpp
+++ b/layout/xul/grid/nsGrid.cpp
@@ -1048,18 +1048,17 @@ nsGrid::GetRowFlex(int32_t aIndex, bool 
 
   if (box) {
 
     // We need our flex but a inflexible row could be around us. If so
     // neither are we. However if its the row tag just inside the grid it won't
     // affect us. We need to do this for this case:
     // <grid>
     //   <rows>
-    //     <rows> // this is not flexible.
-    //            // So our children should not be flexible
+    //     <rows> // this is not flexible. So our children should not be flexible
     //        <row flex="1"/>
     //        <row flex="1"/>
     //     </rows>
     //        <row/>
     //   </rows>
     // </grid>
     //
     // or..
--- a/layout/xul/nsScrollbarFrame.cpp
+++ b/layout/xul/nsScrollbarFrame.cpp
@@ -305,26 +305,25 @@ nsScrollbarFrame::MoveToNewPosition()
   }
   content->UnsetAttr(kNameSpaceID_None, nsGkAtoms::smooth, false);
   return curpos;
 }
 
 nsresult
 nsScrollbarFrame::CreateAnonymousContent(nsTArray<ContentInfo>& aElements)
 {
-  // clang-format off
   // <xul:scrollbarbutton sbattr="scrollbar-up-top" type="decrement" xbl:inherits="curpos,maxpos,disabled"/>
   // <xul:scrollbarbutton sbattr="scrollbar-down-top" type="increment" xbl:inherits="curpos,maxpos,disabled"/>
   // <xul:slider flex="1" xbl:inherits="disabled,curpos,maxpos,pageincrement,increment,orient">
   //   <xul:thumb sbattr="scrollbar-thumb" xbl:inherits="orient,collapsed=disabled"
   //              align="center" pack="center"/>
   // </xul:slider>
   // <xul:scrollbarbutton sbattr="scrollbar-up-bottom" type="decrement" xbl:inherits="curpos,maxpos,disabled"/>
   // <xul:scrollbarbutton sbattr="scrollbar-down-bottom" type="increment" xbl:inherits="curpos,maxpos,disabled"/>
-  // clang-format on
+
   nsNodeInfoManager* nodeInfoManager = mContent->NodeInfo()->NodeInfoManager();
 
   Element* el(GetContent()->AsElement());
 
   // If there are children already in the node, don't create any anonymous content
   // (this only apply to crashtests/369038-1.xhtml)
   if (el->HasChildren()) {
     return NS_OK;