Backed out changeset 11d6688b953f (bug 1508472) for build bustages on a CLOSED TREE
authorAndreea Pavel <apavel@mozilla.com>
Tue, 27 Nov 2018 18:28:30 +0200
changeset 507538 f343188bdcf2a7566fc943bbae4a3ec5e7856c29
parent 507537 11d6688b953f800e234162bc8ed5842954de087f
child 507539 447f8ddd9bbd1c5b618025758019e01525e2cb45
push id1905
push userffxbld-merge
push dateMon, 21 Jan 2019 12:33:13 +0000
treeherdermozilla-release@c2fca1944d8c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1508472
milestone65.0a1
backs out11d6688b953f800e234162bc8ed5842954de087f
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 changeset 11d6688b953f (bug 1508472) for build bustages on a CLOSED TREE
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
--- 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
@@ -1,9 +1,9 @@
-/i* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "TextServicesDocument.h"
 
 #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
 #include "mozilla/EditorUtils.h"        // for AutoTransactionBatchExternal
@@ -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);