Bug 1542146 - Apply the change with the option StatementMacros from clang-format-8 r=andi
authorSylvestre Ledru <sledru@mozilla.com>
Fri, 05 Apr 2019 21:42:17 +0000
changeset 468250 6f723cac81ddf18954af5c5b3d430864e849930b
parent 468249 55ed5f885d52c347f6ef98bb86d2eb71f2a729c3
child 468251 39c1b02a33f5392adcb11238fa821da84574d057
push id35824
push userapavel@mozilla.com
push dateSat, 06 Apr 2019 10:57:50 +0000
treeherdermozilla-central@a765634b9ec2 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersandi
bugs1542146
milestone68.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1542146 - Apply the change with the option StatementMacros from clang-format-8 r=andi # ignore-this-changeset Differential Revision: https://phabricator.services.mozilla.com/D26280
caps/tests/gtest/TestOriginAttributes.cpp
dom/base/test/gtest/TestContentUtils.cpp
dom/base/test/gtest/TestMimeType.cpp
dom/base/test/gtest/TestPlainTextSerializer.cpp
dom/base/test/gtest/TestXPathGenerator.cpp
dom/canvas/gtest/TestImageBitmapColorUtils.cpp
dom/localstorage/test/gtest/TestLocalStorage.cpp
dom/media/doctor/gtest/TestMultiWriterQueue.cpp
dom/media/doctor/gtest/TestRollingNumber.cpp
dom/media/gtest/TestAudioBuffers.cpp
dom/media/gtest/TestAudioCompactor.cpp
dom/media/gtest/TestAudioDeviceEnumerator.cpp
dom/media/gtest/TestAudioMixer.cpp
dom/media/gtest/TestAudioPacketizer.cpp
dom/media/gtest/TestAudioSegment.cpp
dom/media/gtest/TestAudioTrackEncoder.cpp
dom/media/gtest/TestBitWriter.cpp
dom/media/gtest/TestBlankVideoDataCreator.cpp
dom/media/gtest/TestBufferReader.cpp
dom/media/gtest/TestCDMStorage.cpp
dom/media/gtest/TestDataMutex.cpp
dom/media/gtest/TestGMPCrossOrigin.cpp
dom/media/gtest/TestGMPRemoveAndDelete.cpp
dom/media/gtest/TestGMPUtils.cpp
dom/media/gtest/TestGroupId.cpp
dom/media/gtest/TestIntervalSet.cpp
dom/media/gtest/TestMP4Demuxer.cpp
dom/media/gtest/TestMediaDataDecoder.cpp
dom/media/gtest/TestMediaEventSource.cpp
dom/media/gtest/TestMediaMIMETypes.cpp
dom/media/gtest/TestOpusParser.cpp
dom/media/gtest/TestRust.cpp
dom/media/gtest/TestTimeUnit.cpp
dom/media/gtest/TestVPXDecoding.cpp
dom/media/gtest/TestVideoSegment.cpp
dom/media/gtest/TestVideoTrackEncoder.cpp
dom/media/gtest/TestVideoUtils.cpp
dom/media/gtest/TestWebMBuffered.cpp
dom/media/gtest/TestWebMWriter.cpp
dom/media/gtest/mp4_demuxer/TestInterval.cpp
dom/media/gtest/mp4_demuxer/TestMP4.cpp
dom/media/gtest/mp4_demuxer/TestParser.cpp
dom/media/mediasource/gtest/TestContainerParser.cpp
dom/media/mediasource/gtest/TestExtractVPXCodecDetails.cpp
dom/prio/test/gtest/TestPrioEncoder.cpp
dom/quota/test/gtest/TestQuotaManager.cpp
dom/reporting/tests/gtest/TestReportToParser.cpp
dom/security/featurepolicy/test/gtest/TestFeaturePolicyParser.cpp
dom/security/test/gtest/TestCSPParser.cpp
dom/security/test/gtest/TestSecureContext.cpp
dom/serviceworkers/test/gtest/TestReadWrite.cpp
editor/txmgr/tests/TestTXMgr.cpp
gfx/2d/unittest/TestCairo.cpp
gfx/tests/gtest/PolygonTestUtils.cpp
gfx/tests/gtest/TestArena.cpp
gfx/tests/gtest/TestArrayView.cpp
gfx/tests/gtest/TestBSPTree.cpp
gfx/tests/gtest/TestBufferRotation.cpp
gfx/tests/gtest/TestColorNames.cpp
gfx/tests/gtest/TestCompositor.cpp
gfx/tests/gtest/TestGfxPrefs.cpp
gfx/tests/gtest/TestGfxWidgets.cpp
gfx/tests/gtest/TestJobScheduler.cpp
gfx/tests/gtest/TestLayers.cpp
gfx/tests/gtest/TestMoz2D.cpp
gfx/tests/gtest/TestPolygon.cpp
gfx/tests/gtest/TestQcms.cpp
gfx/tests/gtest/TestRect.cpp
gfx/tests/gtest/TestRegion.cpp
gfx/tests/gtest/TestSkipChars.cpp
gfx/tests/gtest/TestSwizzle.cpp
gfx/tests/gtest/TestTextureCompatibility.cpp
gfx/tests/gtest/TestTextures.cpp
gfx/tests/gtest/TestTreeTraversal.cpp
gfx/tests/gtest/gfxSurfaceRefCountTest.cpp
image/test/gtest/TestADAM7InterpolatingFilter.cpp
image/test/gtest/TestBlendAnimationFilter.cpp
image/test/gtest/TestCopyOnWrite.cpp
image/test/gtest/TestDownscalingFilter.cpp
image/test/gtest/TestDownscalingFilterNoSkia.cpp
image/test/gtest/TestRemoveFrameRectFilter.cpp
image/test/gtest/TestSurfaceSink.cpp
intl/locale/tests/gtest/TestCollation.cpp
intl/locale/tests/gtest/TestDateTimeFormat.cpp
intl/locale/tests/gtest/TestLocaleService.cpp
intl/locale/tests/gtest/TestLocaleServiceNegotiate.cpp
intl/locale/tests/gtest/TestMozLocale.cpp
intl/locale/tests/gtest/TestOSPreferences.cpp
intl/lwbrk/gtest/TestLineBreak.cpp
ipc/chromium/src/base/thread_local_win.cc
ipc/chromium/src/base/waitable_event_win.cc
ipc/chromium/src/chrome/common/ipc_channel_posix.cc
media/gmp-clearkey/0.1/gtest/TestClearKeyUtils.cpp
media/mtransport/test/ice_unittest.cpp
media/mtransport/test/simpletokenbucket_unittest.cpp
media/mtransport/test/test_nr_socket_unittest.cpp
media/psshparser/gtest/TestPsshParser.cpp
media/webrtc/signaling/gtest/jsep_session_unittest.cpp
media/webrtc/signaling/gtest/sdp_unittests.cpp
memory/gtest/TestJemalloc.cpp
memory/volatile/tests/TestVolatileBuffer.cpp
mfbt/tests/gtest/TestBuffer.cpp
mfbt/tests/gtest/TestLinkedList.cpp
mfbt/tests/gtest/TestMozDbg.cpp
modules/libpref/test/gtest/Basics.cpp
modules/libpref/test/gtest/CallbackAndVarCacheOrder.cpp
modules/libpref/test/gtest/Parser.cpp
mozglue/tests/gtest/TestDLLBlocklist.cpp
mozglue/tests/gtest/TestDLLEject.cpp
netwerk/test/TestBind.cpp
netwerk/test/TestCookie.cpp
netwerk/test/TestNamedPipeService.cpp
netwerk/test/TestUDPSocket.cpp
netwerk/test/gtest/TestBufferedInputStream.cpp
netwerk/test/gtest/TestHeaders.cpp
netwerk/test/gtest/TestHttpAuthUtils.cpp
netwerk/test/gtest/TestIsValidIp.cpp
netwerk/test/gtest/TestMIMEInputStream.cpp
netwerk/test/gtest/TestMozURL.cpp
netwerk/test/gtest/TestPartiallySeekableInputStream.cpp
netwerk/test/gtest/TestProtocolProxyService.cpp
netwerk/test/gtest/TestReadStreamToString.cpp
netwerk/test/gtest/TestServerTimingHeader.cpp
netwerk/test/gtest/TestStandardURL.cpp
netwerk/test/gtest/TestURIMutator.cpp
netwerk/test/gtest/parse-ftp/TestParseFTPList.cpp
security/certverifier/tests/gtest/TrustOverrideTest.cpp
security/manager/ssl/tests/gtest/CertDBTest.cpp
security/manager/ssl/tests/gtest/CertListTest.cpp
security/manager/ssl/tests/gtest/DeserializeCertTest.cpp
security/sandbox/linux/gtest/TestBroker.cpp
security/sandbox/linux/gtest/TestBrokerPolicy.cpp
storage/test/gtest/test_AsXXX_helpers.cpp
storage/test/gtest/test_asyncStatementExecution_transaction.cpp
storage/test/gtest/test_async_callbacks_with_spun_event_loops.cpp
storage/test/gtest/test_binding_params.cpp
storage/test/gtest/test_file_perms.cpp
storage/test/gtest/test_mutex.cpp
storage/test/gtest/test_service_init_background_thread.cpp
storage/test/gtest/test_spinningSynchronousClose.cpp
storage/test/gtest/test_statement_scoper.cpp
storage/test/gtest/test_transaction_helper.cpp
storage/test/gtest/test_true_async.cpp
storage/test/gtest/test_unlock_notify.cpp
testing/gtest/mozilla/MozGTestBench.h
testing/gtest/mozilla/SanityTest.cpp
toolkit/components/places/tests/gtest/places_test_harness_tail.h
toolkit/components/places/tests/gtest/test_casing.cpp
toolkit/components/reputationservice/test/gtest/TestExecutableLists.cpp
toolkit/components/resistfingerprinting/tests/test_reduceprecision.cpp
toolkit/components/telemetry/geckoview/gtest/TestGeckoView.cpp
toolkit/components/telemetry/tests/gtest/TelemetryTestHelpers.cpp
toolkit/components/telemetry/tests/gtest/TestCombinedStacks.cpp
toolkit/components/telemetry/tests/gtest/TestEvents.cpp
toolkit/components/telemetry/tests/gtest/TestHistograms.cpp
toolkit/components/telemetry/tests/gtest/TestOrigins.cpp
toolkit/components/telemetry/tests/gtest/TestScalars.cpp
toolkit/components/url-classifier/tests/gtest/TestCaching.cpp
toolkit/components/url-classifier/tests/gtest/TestChunkSet.cpp
toolkit/components/url-classifier/tests/gtest/TestClassifier.cpp
toolkit/components/url-classifier/tests/gtest/TestFailUpdate.cpp
toolkit/components/url-classifier/tests/gtest/TestFindFullHash.cpp
toolkit/components/url-classifier/tests/gtest/TestLookupCacheV4.cpp
toolkit/components/url-classifier/tests/gtest/TestPerProviderDirectory.cpp
toolkit/components/url-classifier/tests/gtest/TestProtocolParser.cpp
toolkit/components/url-classifier/tests/gtest/TestRiceDeltaDecoder.cpp
toolkit/components/url-classifier/tests/gtest/TestSafeBrowsingProtobuf.cpp
toolkit/components/url-classifier/tests/gtest/TestSafebrowsingHash.cpp
toolkit/components/url-classifier/tests/gtest/TestTable.cpp
toolkit/components/url-classifier/tests/gtest/TestUrlClassifierTableUpdateV4.cpp
toolkit/components/url-classifier/tests/gtest/TestUrlClassifierUtils.cpp
toolkit/components/url-classifier/tests/gtest/TestVariableLengthPrefixSet.cpp
toolkit/crashreporter/test/gtest/TestCrashThreadAnnotation.cpp
toolkit/profile/gtest/TestProfileLock.cpp
toolkit/profile/gtest/TestProfileLockRetry.cpp
toolkit/system/osxproxy/tests/gtest/TestProxyBypassRules.cpp
toolkit/system/windowsproxy/tests/gtest/TestProxyBypassRules.cpp
tools/fuzzing/interface/FuzzingInterfaceStream.h
tools/profiler/tests/gtest/GeckoProfiler.cpp
tools/profiler/tests/gtest/LulTest.cpp
tools/profiler/tests/gtest/ThreadProfileTest.cpp
xpcom/rust/gtest/nsstring/Test.cpp
xpcom/rust/gtest/xpcom/Test.cpp
xpcom/tests/gtest/TestAllocReplacement.cpp
xpcom/tests/gtest/TestArenaAllocator.cpp
xpcom/tests/gtest/TestAtoms.cpp
xpcom/tests/gtest/TestAutoPtr.cpp
xpcom/tests/gtest/TestAutoRef.cpp
xpcom/tests/gtest/TestAutoRefCnt.cpp
xpcom/tests/gtest/TestBase64.cpp
xpcom/tests/gtest/TestCOMArray.cpp
xpcom/tests/gtest/TestCOMPtr.cpp
xpcom/tests/gtest/TestCOMPtrEq.cpp
xpcom/tests/gtest/TestCRT.cpp
xpcom/tests/gtest/TestCloneInputStream.cpp
xpcom/tests/gtest/TestDafsa.cpp
xpcom/tests/gtest/TestDeadlockDetectorScalability.cpp
xpcom/tests/gtest/TestEncoding.cpp
xpcom/tests/gtest/TestEscape.cpp
xpcom/tests/gtest/TestEventPriorities.cpp
xpcom/tests/gtest/TestEventTargetQI.cpp
xpcom/tests/gtest/TestExpirationTracker.cpp
xpcom/tests/gtest/TestFile.cpp
xpcom/tests/gtest/TestFilePreferencesUnix.cpp
xpcom/tests/gtest/TestFilePreferencesWin.cpp
xpcom/tests/gtest/TestGCPostBarriers.cpp
xpcom/tests/gtest/TestHashtables.cpp
xpcom/tests/gtest/TestID.cpp
xpcom/tests/gtest/TestInputStreamLengthHelper.cpp
xpcom/tests/gtest/TestLogCommandLineHandler.cpp
xpcom/tests/gtest/TestMoveString.cpp
xpcom/tests/gtest/TestMozPromise.cpp
xpcom/tests/gtest/TestMruCache.cpp
xpcom/tests/gtest/TestMultiplexInputStream.cpp
xpcom/tests/gtest/TestNSPRLogModulesParser.cpp
xpcom/tests/gtest/TestNonBlockingAsyncInputStream.cpp
xpcom/tests/gtest/TestNsDeque.cpp
xpcom/tests/gtest/TestNsRefPtr.cpp
xpcom/tests/gtest/TestObserverArray.cpp
xpcom/tests/gtest/TestObserverService.cpp
xpcom/tests/gtest/TestPLDHash.cpp
xpcom/tests/gtest/TestPipes.cpp
xpcom/tests/gtest/TestPriorityQueue.cpp
xpcom/tests/gtest/TestRWLock.cpp
xpcom/tests/gtest/TestRacingServiceManager.cpp
xpcom/tests/gtest/TestRecursiveMutex.cpp
xpcom/tests/gtest/TestSlicedInputStream.cpp
xpcom/tests/gtest/TestSnappyStreams.cpp
xpcom/tests/gtest/TestStateWatching.cpp
xpcom/tests/gtest/TestStorageStream.cpp
xpcom/tests/gtest/TestStringStream.cpp
xpcom/tests/gtest/TestStrings.cpp
xpcom/tests/gtest/TestSynchronization.cpp
xpcom/tests/gtest/TestTArray.cpp
xpcom/tests/gtest/TestTArray2.cpp
xpcom/tests/gtest/TestTaskQueue.cpp
xpcom/tests/gtest/TestTextFormatter.cpp
xpcom/tests/gtest/TestThreadManager.cpp
xpcom/tests/gtest/TestThreadPool.cpp
xpcom/tests/gtest/TestThreadPoolListener.cpp
xpcom/tests/gtest/TestThreadUtils.cpp
xpcom/tests/gtest/TestThreads.cpp
xpcom/tests/gtest/TestThrottledEventQueue.cpp
xpcom/tests/gtest/TestTimeStamp.cpp
xpcom/tests/gtest/TestTimers.cpp
xpcom/tests/gtest/TestTokenizer.cpp
xpcom/tests/gtest/TestUTF.cpp
xpcom/tests/windows/TestCOM.cpp
xpcom/tests/windows/TestNtPathToDosPath.cpp
--- a/caps/tests/gtest/TestOriginAttributes.cpp
+++ b/caps/tests/gtest/TestOriginAttributes.cpp
@@ -12,22 +12,25 @@ static void TestSuffix(const OriginAttri
 
   OriginAttributes attrsFromSuffix;
   bool success = attrsFromSuffix.PopulateFromSuffix(suffix);
   EXPECT_TRUE(success);
 
   EXPECT_EQ(attrs, attrsFromSuffix);
 }
 
-TEST(OriginAttributes, Suffix_default) {
+TEST(OriginAttributes, Suffix_default)
+{
   OriginAttributes attrs;
   TestSuffix(attrs);
 }
 
-TEST(OriginAttributes, Suffix_appId_inIsolatedMozBrowser) {
+TEST(OriginAttributes, Suffix_appId_inIsolatedMozBrowser)
+{
   OriginAttributes attrs(1, true);
   TestSuffix(attrs);
 }
 
-TEST(OriginAttributes, Suffix_maxAppId_inIsolatedMozBrowser) {
+TEST(OriginAttributes, Suffix_maxAppId_inIsolatedMozBrowser)
+{
   OriginAttributes attrs(4294967295, true);
   TestSuffix(attrs);
 }
--- a/dom/base/test/gtest/TestContentUtils.cpp
+++ b/dom/base/test/gtest/TestContentUtils.cpp
@@ -6,31 +6,33 @@
 
 #include "gtest/gtest.h"
 
 #include "jsapi.h"
 #include "nsContentUtils.h"
 #include "mozilla/CycleCollectedJSContext.h"
 #include "mozilla/dom/SimpleGlobalObject.h"
 
-TEST(DOM_Base_ContentUtils, StringifyJSON_EmptyValue) {
+TEST(DOM_Base_ContentUtils, StringifyJSON_EmptyValue)
+{
   JSObject* globalObject = mozilla::dom::SimpleGlobalObject::Create(
       mozilla::dom::SimpleGlobalObject::GlobalType::BindingDetail);
   mozilla::dom::AutoJSAPI jsAPI;
   ASSERT_TRUE(jsAPI.Init(globalObject));
   JSContext* cx = jsAPI.cx();
   nsAutoString serializedValue;
 
   JS::RootedValue jsValue(cx);
   ASSERT_TRUE(nsContentUtils::StringifyJSON(cx, &jsValue, serializedValue));
 
   ASSERT_TRUE(serializedValue.EqualsLiteral("null"));
 }
 
-TEST(DOM_Base_ContentUtils, StringifyJSON_Object) {
+TEST(DOM_Base_ContentUtils, StringifyJSON_Object)
+{
   JSObject* globalObject = mozilla::dom::SimpleGlobalObject::Create(
       mozilla::dom::SimpleGlobalObject::GlobalType::BindingDetail);
   mozilla::dom::AutoJSAPI jsAPI;
   ASSERT_TRUE(jsAPI.Init(globalObject));
   JSContext* cx = jsAPI.cx();
   nsAutoString serializedValue;
 
   JS::RootedObject jsObj(cx, JS_NewPlainObject(cx));
--- a/dom/base/test/gtest/TestMimeType.cpp
+++ b/dom/base/test/gtest/TestMimeType.cpp
@@ -6,600 +6,736 @@
 
 #include "gtest/gtest.h"
 
 #include "MimeType.h"
 #include "nsString.h"
 
 using mozilla::UniquePtr;
 
-TEST(MimeType, EmptyString) {
+TEST(MimeType, EmptyString)
+{
   const auto in = NS_LITERAL_STRING("");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Empty string";
+  ASSERT_FALSE(parsed)
+  << "Empty string";
 }
 
-TEST(MimeType, JustWhitespace) {
+TEST(MimeType, JustWhitespace)
+{
   const auto in = NS_LITERAL_STRING(" \t\r\n ");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Just whitespace";
+  ASSERT_FALSE(parsed)
+  << "Just whitespace";
 }
 
-TEST(MimeType, JustBackslash) {
+TEST(MimeType, JustBackslash)
+{
   const auto in = NS_LITERAL_STRING("\\");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Just backslash";
+  ASSERT_FALSE(parsed)
+  << "Just backslash";
 }
 
-TEST(MimeType, JustForwardslash) {
+TEST(MimeType, JustForwardslash)
+{
   const auto in = NS_LITERAL_STRING("/");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Just forward slash";
+  ASSERT_FALSE(parsed)
+  << "Just forward slash";
 }
 
-TEST(MimeType, MissingType1) {
+TEST(MimeType, MissingType1)
+{
   const auto in = NS_LITERAL_STRING("/bogus");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Missing type #1";
+  ASSERT_FALSE(parsed)
+  << "Missing type #1";
 }
 
-TEST(MimeType, MissingType2) {
+TEST(MimeType, MissingType2)
+{
   const auto in = NS_LITERAL_STRING(" \r\n\t/bogus");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Missing type #2";
+  ASSERT_FALSE(parsed)
+  << "Missing type #2";
 }
 
-TEST(MimeType, MissingSubtype1) {
+TEST(MimeType, MissingSubtype1)
+{
   const auto in = NS_LITERAL_STRING("bogus");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Missing subtype #1";
+  ASSERT_FALSE(parsed)
+  << "Missing subtype #1";
 }
 
-TEST(MimeType, MissingSubType2) {
+TEST(MimeType, MissingSubType2)
+{
   const auto in = NS_LITERAL_STRING("bogus/");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Missing subtype #2";
+  ASSERT_FALSE(parsed)
+  << "Missing subtype #2";
 }
 
-TEST(MimeType, MissingSubType3) {
+TEST(MimeType, MissingSubType3)
+{
   const auto in = NS_LITERAL_STRING("bogus;");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Missing subtype #3";
+  ASSERT_FALSE(parsed)
+  << "Missing subtype #3";
 }
 
-TEST(MimeType, MissingSubType4) {
+TEST(MimeType, MissingSubType4)
+{
   const auto in = NS_LITERAL_STRING("bogus; \r\n\t");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Missing subtype #3";
+  ASSERT_FALSE(parsed)
+  << "Missing subtype #3";
 }
 
-TEST(MimeType, ExtraForwardSlash) {
+TEST(MimeType, ExtraForwardSlash)
+{
   const auto in = NS_LITERAL_STRING("bogus/bogus/;");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Extra forward slash";
+  ASSERT_FALSE(parsed)
+  << "Extra forward slash";
 }
 
-TEST(MimeType, WhitespaceInType) {
+TEST(MimeType, WhitespaceInType)
+{
   const auto in = NS_LITERAL_STRING("t\re\nx\tt /html");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Type with whitespace";
+  ASSERT_FALSE(parsed)
+  << "Type with whitespace";
 }
 
-TEST(MimeType, WhitespaceInSubtype) {
+TEST(MimeType, WhitespaceInSubtype)
+{
   const auto in = NS_LITERAL_STRING("text/ h\rt\nm\tl");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Subtype with whitespace";
+  ASSERT_FALSE(parsed)
+  << "Subtype with whitespace";
 }
 
-TEST(MimeType, NonAlphanumericMediaType1) {
+TEST(MimeType, NonAlphanumericMediaType1)
+{
   const auto in = NS_LITERAL_STRING("</>");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Non-alphanumeric media type #1";
+  ASSERT_FALSE(parsed)
+  << "Non-alphanumeric media type #1";
 }
 
-TEST(MimeType, NonAlphanumericMediaType2) {
+TEST(MimeType, NonAlphanumericMediaType2)
+{
   const auto in = NS_LITERAL_STRING("(/)");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Non-alphanumeric media type #2";
+  ASSERT_FALSE(parsed)
+  << "Non-alphanumeric media type #2";
 }
 
-TEST(MimeType, NonAlphanumericMediaType3) {
+TEST(MimeType, NonAlphanumericMediaType3)
+{
   const auto in = NS_LITERAL_STRING("{/}");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Non-alphanumeric media type #3";
+  ASSERT_FALSE(parsed)
+  << "Non-alphanumeric media type #3";
 }
 
-TEST(MimeType, NonAlphanumericMediaType4) {
+TEST(MimeType, NonAlphanumericMediaType4)
+{
   const auto in = NS_LITERAL_STRING("\"/\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Non-alphanumeric media type #4";
+  ASSERT_FALSE(parsed)
+  << "Non-alphanumeric media type #4";
 }
 
-TEST(MimeType, NonAlphanumericMediaType5) {
+TEST(MimeType, NonAlphanumericMediaType5)
+{
   const auto in = NS_LITERAL_STRING("\0/\0");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Non-alphanumeric media type #5";
+  ASSERT_FALSE(parsed)
+  << "Non-alphanumeric media type #5";
 }
 
-TEST(MimeType, NonAlphanumericMediaType6) {
+TEST(MimeType, NonAlphanumericMediaType6)
+{
   const auto in = NS_LITERAL_STRING("text/html(;doesnot=matter");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Non-alphanumeric media type #6";
+  ASSERT_FALSE(parsed)
+  << "Non-alphanumeric media type #6";
 }
 
-TEST(MimeType, NonLatin1MediaType1) {
+TEST(MimeType, NonLatin1MediaType1)
+{
   const auto in = NS_LITERAL_STRING("ÿ/ÿ");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Non-latin1 media type #1";
+  ASSERT_FALSE(parsed)
+  << "Non-latin1 media type #1";
 }
 
-TEST(MimeType, NonLatin1MediaType2) {
+TEST(MimeType, NonLatin1MediaType2)
+{
   const auto in = NS_LITERAL_STRING(u"\x0100/\x0100");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_FALSE(parsed) << "Non-latin1 media type #2";
+  ASSERT_FALSE(parsed)
+  << "Non-latin1 media type #2";
 }
 
-TEST(MimeType, MultipleParameters) {
+TEST(MimeType, MultipleParameters)
+{
   const auto in =
       NS_LITERAL_STRING("text/html;charset=gbk;no=1;charset_=gbk_;yes=2");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.Equals(
       NS_LITERAL_STRING("text/html;charset=gbk;no=1;charset_=gbk_;yes=2")))
-      << "Multiple parameters";
+  << "Multiple parameters";
 }
 
-TEST(MimeType, DuplicateParameter1) {
+TEST(MimeType, DuplicateParameter1)
+{
   const auto in =
       NS_LITERAL_STRING("text/html;charset=gbk;charset=windows-1255");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.Equals(NS_LITERAL_STRING("text/html;charset=gbk")))
-      << "Duplicate parameter #1";
+  << "Duplicate parameter #1";
 }
 
-TEST(MimeType, DuplicateParameter2) {
+TEST(MimeType, DuplicateParameter2)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=();charset=GBK");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.Equals(NS_LITERAL_STRING("text/html;charset=\"()\"")))
-      << "Duplicate parameter #2";
+  << "Duplicate parameter #2";
 }
 
-TEST(MimeType, CString) {
+TEST(MimeType, CString)
+{
   const auto in = NS_LITERAL_CSTRING("text/html;charset=();charset=GBK");
   UniquePtr<CMimeType> parsed = CMimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsCString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.Equals(NS_LITERAL_CSTRING("text/html;charset=\"()\"")))
-      << "Duplicate parameter #2";
+  << "Duplicate parameter #2";
 }
 
 #ifdef _MSC_VER
 #  pragma warning(push)
 #  pragma warning(disable : 4819)
 #endif
-TEST(MimeType, NonAlphanumericParametersAreQuoted) {
+TEST(MimeType, NonAlphanumericParametersAreQuoted)
+{
   const auto in = NS_LITERAL_STRING("text/html;test=\x00FF\\;charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.Equals(
       NS_LITERAL_STRING("text/html;test=\"\x00FF\\\\\";charset=gbk")))
-      << "Non-alphanumeric parameters are quoted";
+  << "Non-alphanumeric parameters are quoted";
 }
 #ifdef _MSC_VER
 #  pragma warning(pop)
 #endif
 
-TEST(MimeType, ParameterQuotedIfHasLeadingWhitespace1) {
+TEST(MimeType, ParameterQuotedIfHasLeadingWhitespace1)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset= g\\\"bk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" g\\\\\\\"bk\""))
-      << "Parameter is quoted if has leading whitespace #1";
+  << "Parameter is quoted if has leading whitespace #1";
 }
 
-TEST(MimeType, ParameterQuotedIfHasLeadingWhitespace2) {
+TEST(MimeType, ParameterQuotedIfHasLeadingWhitespace2)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset= \"g\\bk\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" \\\"g\\\\bk\\\"\""))
-      << "Parameter is quoted if has leading whitespace #2";
+  << "Parameter is quoted if has leading whitespace #2";
 }
 
-TEST(MimeType, ParameterQuotedIfHasInternalWhitespace) {
+TEST(MimeType, ParameterQuotedIfHasInternalWhitespace)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=g \\b\"k");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"g \\\\b\\\"k\""))
-      << "Parameter is quoted if has internal whitespace";
+  << "Parameter is quoted if has internal whitespace";
 }
 
-TEST(MimeType, ImproperlyQuotedParameter1) {
+TEST(MimeType, ImproperlyQuotedParameter1)
+{
   const auto in = NS_LITERAL_STRING("x/x;test=\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("x/x;test=\"\""))
-      << "Improperly-quoted parameter is handled properly #1";
+  << "Improperly-quoted parameter is handled properly #1";
 }
 
-TEST(MimeType, ImproperlyQuotedParameter2) {
+TEST(MimeType, ImproperlyQuotedParameter2)
+{
   const auto in = NS_LITERAL_STRING("x/x;test=\"\\");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("x/x;test=\"\\\\\""))
-      << "Improperly-quoted parameter is handled properly #2";
+  << "Improperly-quoted parameter is handled properly #2";
 }
 
-TEST(MimeType, NonLatin1ParameterIgnored) {
+TEST(MimeType, NonLatin1ParameterIgnored)
+{
   const auto in = NS_LITERAL_STRING(u"x/x;test=\xFFFD;x=x");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("x/x;x=x"))
-      << "Non latin-1 parameters are ignored";
+  << "Non latin-1 parameters are ignored";
 }
 
-TEST(MimeType, ParameterIgnoredIfWhitespaceInName1) {
+TEST(MimeType, ParameterIgnoredIfWhitespaceInName1)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset =gbk;charset=123");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=123"))
-      << "Parameter ignored if whitespace in name #1";
+  << "Parameter ignored if whitespace in name #1";
 }
 
-TEST(MimeType, ParameterIgnoredIfWhitespaceInName2) {
+TEST(MimeType, ParameterIgnoredIfWhitespaceInName2)
+{
   const auto in = NS_LITERAL_STRING("text/html;cha rset =gbk;charset=123");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=123"))
-      << "Parameter ignored if whitespace in name #2";
+  << "Parameter ignored if whitespace in name #2";
 }
 
-TEST(MimeType, WhitespaceTrimmed) {
+TEST(MimeType, WhitespaceTrimmed)
+{
   const auto in = NS_LITERAL_STRING(
       "\n\r\t  text/plain\n\r\t  ;\n\r\t  charset=123\n\r\t ");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/plain;charset=123"))
-      << "Whitespace appropriately ignored";
+  << "Whitespace appropriately ignored";
 }
 
-TEST(MimeType, WhitespaceOnlyParameterIgnored) {
+TEST(MimeType, WhitespaceOnlyParameterIgnored)
+{
   const auto in = NS_LITERAL_STRING("x/x;x= \r\n\t");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
+  nsAutoString out;
+  parsed->Serialize(out);
+  ASSERT_TRUE(out.EqualsLiteral("x/x"))
+  << "Whitespace-only parameter is ignored";
+}
+
+TEST(MimeType, IncompleteParameterIgnored1)
+{
+  const auto in = NS_LITERAL_STRING("x/x;test");
+  UniquePtr<MimeType> parsed = MimeType::Parse(in);
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("x/x"))
-      << "Whitespace-only parameter is ignored";
+  << "Incomplete parameter is ignored #1";
 }
 
-TEST(MimeType, IncompleteParameterIgnored1) {
-  const auto in = NS_LITERAL_STRING("x/x;test");
-  UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
-  nsAutoString out;
-  parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("x/x")) << "Incomplete parameter is ignored #1";
-}
-
-TEST(MimeType, IncompleteParameterIgnored2) {
+TEST(MimeType, IncompleteParameterIgnored2)
+{
   const auto in = NS_LITERAL_STRING("x/x;test=");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("x/x")) << "Incomplete parameter is ignored #2";
+  ASSERT_TRUE(out.EqualsLiteral("x/x"))
+  << "Incomplete parameter is ignored #2";
 }
 
-TEST(MimeType, IncompleteParameterIgnored3) {
+TEST(MimeType, IncompleteParameterIgnored3)
+{
   const auto in = NS_LITERAL_STRING("x/x;test= \r\n\t");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("x/x")) << "Incomplete parameter is ignored #3";
+  ASSERT_TRUE(out.EqualsLiteral("x/x"))
+  << "Incomplete parameter is ignored #3";
 }
 
-TEST(MimeType, IncompleteParameterIgnored4) {
+TEST(MimeType, IncompleteParameterIgnored4)
+{
   const auto in = NS_LITERAL_STRING("text/html;test;charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Incomplete parameter is ignored #4";
+  << "Incomplete parameter is ignored #4";
 }
 
-TEST(MimeType, IncompleteParameterIgnored5) {
+TEST(MimeType, IncompleteParameterIgnored5)
+{
   const auto in = NS_LITERAL_STRING("text/html;test=;charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
-  nsAutoString out;
-  parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Incomplete parameter is ignored #5";
-}
-
-TEST(MimeType, EmptyParameterIgnored1) {
-  const auto in = NS_LITERAL_STRING("text/html ; ; charset=gbk");
-  UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Empty parameter ignored #1";
+  << "Incomplete parameter is ignored #5";
 }
 
-TEST(MimeType, EmptyParameterIgnored2) {
-  const auto in = NS_LITERAL_STRING("text/html;;;;charset=gbk");
+TEST(MimeType, EmptyParameterIgnored1)
+{
+  const auto in = NS_LITERAL_STRING("text/html ; ; charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Empty parameter ignored #2";
+  << "Empty parameter ignored #1";
 }
 
-TEST(MimeType, InvalidParameterIgnored1) {
-  const auto in = NS_LITERAL_STRING("text/html;';charset=gbk");
+TEST(MimeType, EmptyParameterIgnored2)
+{
+  const auto in = NS_LITERAL_STRING("text/html;;;;charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Invalid parameter ignored #1";
+  << "Empty parameter ignored #2";
 }
 
-TEST(MimeType, InvalidParameterIgnored2) {
-  const auto in = NS_LITERAL_STRING("text/html;\";charset=gbk;=123; =321");
+TEST(MimeType, InvalidParameterIgnored1)
+{
+  const auto in = NS_LITERAL_STRING("text/html;';charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Invalid parameter ignored #2";
+  << "Invalid parameter ignored #1";
 }
 
-TEST(MimeType, InvalidParameterIgnored3) {
+TEST(MimeType, InvalidParameterIgnored2)
+{
+  const auto in = NS_LITERAL_STRING("text/html;\";charset=gbk;=123; =321");
+  UniquePtr<MimeType> parsed = MimeType::Parse(in);
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
+  nsAutoString out;
+  parsed->Serialize(out);
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
+  << "Invalid parameter ignored #2";
+}
+
+TEST(MimeType, InvalidParameterIgnored3)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset= \"\u007F;charset=GBK");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=GBK"))
-      << "Invalid parameter ignored #3";
+  << "Invalid parameter ignored #3";
 }
 
-TEST(MimeType, InvalidParameterIgnored4) {
+TEST(MimeType, InvalidParameterIgnored4)
+{
   const auto in = NS_LITERAL_STRING(
       "text/html;charset=\"\u007F;charset=foo\";charset=GBK;charset=");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=GBK"))
-      << "Invalid parameter ignored #4";
+  << "Invalid parameter ignored #4";
 }
 
-TEST(MimeType, SingleQuotes1) {
+TEST(MimeType, SingleQuotes1)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset='gbk'");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset='gbk'"))
-      << "Single quotes handled properly #1";
+  << "Single quotes handled properly #1";
 }
 
-TEST(MimeType, SingleQuotes2) {
+TEST(MimeType, SingleQuotes2)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset='gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset='gbk"))
-      << "Single quotes handled properly #2";
+  << "Single quotes handled properly #2";
 }
 
-TEST(MimeType, SingleQuotes3) {
+TEST(MimeType, SingleQuotes3)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=gbk'");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk'"))
-      << "Single quotes handled properly #3";
+  << "Single quotes handled properly #3";
 }
 
-TEST(MimeType, SingleQuotes4) {
+TEST(MimeType, SingleQuotes4)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=';charset=GBK");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset='"))
-      << "Single quotes handled properly #4";
+  << "Single quotes handled properly #4";
 }
 
-TEST(MimeType, SingleQuotes5) {
+TEST(MimeType, SingleQuotes5)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=''';charset=GBK");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset='''"))
-      << "Single quotes handled properly #5";
+  << "Single quotes handled properly #5";
 }
 
-TEST(MimeType, DoubleQuotes1) {
+TEST(MimeType, DoubleQuotes1)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=\"gbk\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
-  nsAutoString out;
-  parsed->Serialize(out);
-  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Double quotes handled properly #1";
-}
-
-TEST(MimeType, DoubleQuotes2) {
-  const auto in = NS_LITERAL_STRING("text/html;charset=\"gbk");
-  UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Double quotes handled properly #2";
+  << "Double quotes handled properly #1";
 }
 
-TEST(MimeType, DoubleQuotes3) {
+TEST(MimeType, DoubleQuotes2)
+{
+  const auto in = NS_LITERAL_STRING("text/html;charset=\"gbk");
+  UniquePtr<MimeType> parsed = MimeType::Parse(in);
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
+  nsAutoString out;
+  parsed->Serialize(out);
+  ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
+  << "Double quotes handled properly #2";
+}
+
+TEST(MimeType, DoubleQuotes3)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=gbk\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"gbk\\\"\""))
-      << "Double quotes handled properly #3";
+  << "Double quotes handled properly #3";
 }
 
-TEST(MimeType, DoubleQuotes4) {
+TEST(MimeType, DoubleQuotes4)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=\" gbk\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" gbk\""))
-      << "Double quotes handled properly #4";
+  << "Double quotes handled properly #4";
 }
 
-TEST(MimeType, DoubleQuotes5) {
+TEST(MimeType, DoubleQuotes5)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=\"gbk \"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"gbk \""))
-      << "Double quotes handled properly #5";
+  << "Double quotes handled properly #5";
 }
 
-TEST(MimeType, DoubleQuotes6) {
+TEST(MimeType, DoubleQuotes6)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=\"\\ gbk\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\" gbk\""))
-      << "Double quotes handled properly #6";
+  << "Double quotes handled properly #6";
 }
 
-TEST(MimeType, DoubleQuotes7) {
+TEST(MimeType, DoubleQuotes7)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=\"\\g\\b\\k\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Double quotes handled properly #7";
+  << "Double quotes handled properly #7";
 }
 
-TEST(MimeType, DoubleQuotes8) {
+TEST(MimeType, DoubleQuotes8)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=\"gbk\"x");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=gbk"))
-      << "Double quotes handled properly #8";
+  << "Double quotes handled properly #8";
 }
 
-TEST(MimeType, DoubleQuotes9) {
+TEST(MimeType, DoubleQuotes9)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=\"\";charset=GBK");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"\""))
-      << "Double quotes handled properly #9";
+  << "Double quotes handled properly #9";
 }
 
-TEST(MimeType, DoubleQuotes10) {
+TEST(MimeType, DoubleQuotes10)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=\";charset=GBK");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\";charset=GBK\""))
-      << "Double quotes handled properly #10";
+  << "Double quotes handled properly #10";
 }
 
-TEST(MimeType, UnexpectedCodePoints) {
+TEST(MimeType, UnexpectedCodePoints)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset={gbk}");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"{gbk}\""))
-      << "Unexpected code points handled properly";
+  << "Unexpected code points handled properly";
 }
 
-TEST(MimeType, LongTypesSubtypesAccepted) {
+TEST(MimeType, LongTypesSubtypesAccepted)
+{
   const auto in = NS_LITERAL_STRING(
       "012345678901234567890123456789012345678901234567890123456789012345678901"
       "2345678901234567890123456789012345678901234567890123456789/"
       "012345678901234567890123456789012345678901234567890123456789012345678901"
       "2345678901234567890123456789012345678901234567890123456789");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(in)) << "Long type/subtype accepted";
+  ASSERT_TRUE(out.Equals(in))
+  << "Long type/subtype accepted";
 }
 
-TEST(MimeType, LongParametersAccepted) {
+TEST(MimeType, LongParametersAccepted)
+{
   const auto in = NS_LITERAL_STRING(
       "text/"
       "html;"
       "012345678901234567890123456789012345678901234567890123456789012345678901"
       "2345678901234567890123456789012345678901234567890123456789=x;charset="
       "gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(in)) << "Long parameters accepted";
+  ASSERT_TRUE(out.Equals(in))
+  << "Long parameters accepted";
 }
 
-TEST(MimeType, AllValidCharactersAccepted1) {
+TEST(MimeType, AllValidCharactersAccepted1)
+{
   const auto in = NS_LITERAL_STRING(
       u"x/x;x=\"\t "
       u"!\\\"#$%&'()*+,-./"
       u"0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`"
       u"abcdefghijklmnopqrstuvwxyz{|}~"
       u"\u0080\u0081\u0082\u0083\u0084\u0085\u0086\u0087\u0088\u0089\u008A"
       u"\u008B\u008C\u008D\u008E\u008F\u0090\u0091\u0092\u0093\u0094\u0095"
       u"\u0096\u0097\u0098\u0099\u009A\u009B\u009C\u009D\u009E\u009F\u00A0"
@@ -608,67 +744,77 @@ TEST(MimeType, AllValidCharactersAccepte
       u"\u00B7\u00B8\u00B9\u00BA\u00BB\u00BC\u00BD\u00BE\u00BF\u00C0\u00C1"
       u"\u00C2\u00C3\u00C4\u00C5\u00C6\u00C7\u00C8\u00C9\u00CA\u00CB\u00CC"
       u"\u00CD\u00CE\u00CF\u00D0\u00D1\u00D2\u00D3\u00D4\u00D5\u00D6\u00D7"
       u"\u00D8\u00D9\u00DA\u00DB\u00DC\u00DD\u00DE\u00DF\u00E0\u00E1\u00E2"
       u"\u00E3\u00E4\u00E5\u00E6\u00E7\u00E8\u00E9\u00EA\u00EB\u00EC\u00ED"
       u"\u00EE\u00EF\u00F0\u00F1\u00F2\u00F3\u00F4\u00F5\u00F6\u00F7\u00F8"
       u"\u00F9\u00FA\u00FB\u00FC\u00FD\u00FE\u00FF\"");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
-  ASSERT_TRUE(out.Equals(in)) << "All valid characters accepted #1";
+  ASSERT_TRUE(out.Equals(in))
+  << "All valid characters accepted #1";
 }
 
-TEST(MimeType, CaseNormalization1) {
+TEST(MimeType, CaseNormalization1)
+{
   const auto in = NS_LITERAL_STRING("TEXT/PLAIN;CHARSET=TEST");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/plain;charset=TEST"))
-      << "Case normalized properly #1";
+  << "Case normalized properly #1";
 }
 
-TEST(MimeType, CaseNormalization2) {
+TEST(MimeType, CaseNormalization2)
+{
   const auto in = NS_LITERAL_STRING(
       "!#$%&'*+-.^_`|~"
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz/"
       "!#$%&'*+-.^_`|~"
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz;!#$%&'*+-"
       ".^_`|~0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz=!#$"
       "%&'*+-.^_`|~"
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral(
       "!#$%&'*+-.^_`|~"
       "0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz/"
       "!#$%&'*+-.^_`|~"
       "0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz;!#$%&'*+-"
       ".^_`|~0123456789abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz=!#$"
       "%&'*+-.^_`|~"
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"))
-      << "Case normalized properly #2";
+  << "Case normalized properly #2";
 }
 
-TEST(MimeType, LegacyCommentSyntax1) {
+TEST(MimeType, LegacyCommentSyntax1)
+{
   const auto in = NS_LITERAL_STRING("text/html;charset=gbk(");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;charset=\"gbk(\""))
-      << "Legacy comment syntax #1";
+  << "Legacy comment syntax #1";
 }
 
-TEST(MimeType, LegacyCommentSyntax2) {
+TEST(MimeType, LegacyCommentSyntax2)
+{
   const auto in = NS_LITERAL_STRING("text/html;x=(;charset=gbk");
   UniquePtr<MimeType> parsed = MimeType::Parse(in);
-  ASSERT_TRUE(parsed) << "Parsing succeeded";
+  ASSERT_TRUE(parsed)
+  << "Parsing succeeded";
   nsAutoString out;
   parsed->Serialize(out);
   ASSERT_TRUE(out.EqualsLiteral("text/html;x=\"(\";charset=gbk"))
-      << "Legacy comment syntax #2";
+  << "Legacy comment syntax #2";
 }
--- a/dom/base/test/gtest/TestPlainTextSerializer.cpp
+++ b/dom/base/test/gtest/TestPlainTextSerializer.cpp
@@ -13,17 +13,18 @@
 #include "nsIParserUtils.h"
 
 void ConvertBufToPlainText(nsString &aConBuf, int aFlag) {
   nsCOMPtr<nsIParserUtils> utils = do_GetService(NS_PARSERUTILS_CONTRACTID);
   utils->ConvertToPlainText(aConBuf, aFlag, 72, aConBuf);
 }
 
 // Test for ASCII with format=flowed; delsp=yes
-TEST(PlainTextSerializer, ASCIIWithFlowedDelSp) {
+TEST(PlainTextSerializer, ASCIIWithFlowedDelSp)
+{
   nsString test;
   nsString result;
 
   test.AssignLiteral(
       "<html><body>"
       "Firefox Firefox Firefox Firefox "
       "Firefox Firefox Firefox Firefox "
       "Firefox Firefox Firefox Firefox"
@@ -37,21 +38,22 @@ TEST(PlainTextSerializer, ASCIIWithFlowe
 
   // create result case
   result.AssignLiteral(
       "Firefox Firefox Firefox Firefox "
       "Firefox Firefox Firefox Firefox "
       "Firefox  \r\nFirefox Firefox Firefox\r\n");
 
   ASSERT_TRUE(test.Equals(result))
-      << "Wrong HTML to ASCII text serialization with format=flowed; delsp=yes";
+  << "Wrong HTML to ASCII text serialization with format=flowed; delsp=yes";
 }
 
 // Test for CJK with format=flowed; delsp=yes
-TEST(PlainTextSerializer, CJKWithFlowedDelSp) {
+TEST(PlainTextSerializer, CJKWithFlowedDelSp)
+{
   nsString test;
   nsString result;
 
   test.AssignLiteral("<html><body>");
   for (uint32_t i = 0; i < 40; i++) {
     // Insert Kanji (U+5341)
     test.Append(0x5341);
   }
@@ -69,21 +71,22 @@ TEST(PlainTextSerializer, CJKWithFlowedD
   }
   result.AppendLiteral(" \r\n");
   for (uint32_t i = 0; i < 4; i++) {
     result.Append(0x5341);
   }
   result.AppendLiteral("\r\n");
 
   ASSERT_TRUE(test.Equals(result))
-      << "Wrong HTML to CJK text serialization with format=flowed; delsp=yes";
+  << "Wrong HTML to CJK text serialization with format=flowed; delsp=yes";
 }
 
 // Test for CJK with DisallowLineBreaking
-TEST(PlainTextSerializer, CJKWithDisallowLineBreaking) {
+TEST(PlainTextSerializer, CJKWithDisallowLineBreaking)
+{
   nsString test;
   nsString result;
 
   test.AssignLiteral("<html><body>");
   for (uint32_t i = 0; i < 400; i++) {
     // Insert Kanji (U+5341)
     test.Append(0x5341);
   }
@@ -98,21 +101,22 @@ TEST(PlainTextSerializer, CJKWithDisallo
 
   // create result case
   for (uint32_t i = 0; i < 400; i++) {
     result.Append(0x5341);
   }
   result.AppendLiteral("\r\n");
 
   ASSERT_TRUE(test.Equals(result))
-      << "Wrong HTML to CJK text serialization with OutputDisallowLineBreaking";
+  << "Wrong HTML to CJK text serialization with OutputDisallowLineBreaking";
 }
 
 // Test for ASCII with format=flowed; and quoted lines in preformatted span.
-TEST(PlainTextSerializer, PreformatFlowedQuotes) {
+TEST(PlainTextSerializer, PreformatFlowedQuotes)
+{
   nsString test;
   nsString result;
 
   test.AssignLiteral(
       "<html><body>"
       "<span style=\"white-space: pre-wrap;\">"
       "&gt; Firefox Firefox Firefox Firefox <br>"
       "&gt; Firefox Firefox Firefox Firefox<br>"
@@ -129,79 +133,85 @@ TEST(PlainTextSerializer, PreformatFlowe
   // create result case
   result.AssignLiteral(
       "> Firefox Firefox Firefox Firefox \r\n"
       "> Firefox Firefox Firefox Firefox\r\n"
       ">\r\n"
       ">> Firefox Firefox Firefox Firefox \r\n"
       ">> Firefox Firefox Firefox Firefox\r\n");
 
-  ASSERT_TRUE(test.Equals(result)) << "Wrong HTML to ASCII text serialization "
-                                      "with format=flowed; and quoted "
-                                      "lines";
+  ASSERT_TRUE(test.Equals(result))
+  << "Wrong HTML to ASCII text serialization "
+     "with format=flowed; and quoted "
+     "lines";
 }
 
-TEST(PlainTextSerializer, PrettyPrintedHtml) {
+TEST(PlainTextSerializer, PrettyPrintedHtml)
+{
   nsString test;
   test.AppendLiteral("<html>" NS_LINEBREAK "<body>" NS_LINEBREAK
                      "  first<br>" NS_LINEBREAK "  second<br>" NS_LINEBREAK
                      "</body>" NS_LINEBREAK "</html>");
 
   ConvertBufToPlainText(test, 0);
   ASSERT_TRUE(test.EqualsLiteral("first" NS_LINEBREAK "second" NS_LINEBREAK))
-      << "Wrong prettyprinted html to text serialization";
+  << "Wrong prettyprinted html to text serialization";
 }
 
-TEST(PlainTextSerializer, PreElement) {
+TEST(PlainTextSerializer, PreElement)
+{
   nsString test;
   test.AppendLiteral("<html>" NS_LINEBREAK "<body>" NS_LINEBREAK
                      "<pre>" NS_LINEBREAK "  first" NS_LINEBREAK
                      "  second" NS_LINEBREAK "</pre>" NS_LINEBREAK
                      "</body>" NS_LINEBREAK "</html>");
 
   ConvertBufToPlainText(test, 0);
   ASSERT_TRUE(test.EqualsLiteral("  first" NS_LINEBREAK
                                  "  second" NS_LINEBREAK NS_LINEBREAK))
-      << "Wrong prettyprinted html to text serialization";
+  << "Wrong prettyprinted html to text serialization";
 }
 
-TEST(PlainTextSerializer, BlockElement) {
+TEST(PlainTextSerializer, BlockElement)
+{
   nsString test;
   test.AppendLiteral("<html>" NS_LINEBREAK "<body>" NS_LINEBREAK
                      "<div>" NS_LINEBREAK "  first" NS_LINEBREAK
                      "</div>" NS_LINEBREAK "<div>" NS_LINEBREAK
                      "  second" NS_LINEBREAK "</div>" NS_LINEBREAK
                      "</body>" NS_LINEBREAK "</html>");
 
   ConvertBufToPlainText(test, 0);
   ASSERT_TRUE(test.EqualsLiteral("first" NS_LINEBREAK "second" NS_LINEBREAK))
-      << "Wrong prettyprinted html to text serialization";
+  << "Wrong prettyprinted html to text serialization";
 }
 
-TEST(PlainTextSerializer, PreWrapElementForThunderbird) {
+TEST(PlainTextSerializer, PreWrapElementForThunderbird)
+{
   // This test examines the magic pre-wrap setup that Thunderbird relies on.
   nsString test;
   test.AppendLiteral(
       "<html>" NS_LINEBREAK
       "<body style=\"white-space: pre-wrap; width: 10ch;\">" NS_LINEBREAK
       "<pre>" NS_LINEBREAK "  first line is too long" NS_LINEBREAK
       "  second line is even loooonger  " NS_LINEBREAK "</pre>" NS_LINEBREAK
       "</body>" NS_LINEBREAK "</html>");
 
   ConvertBufToPlainText(test, nsIDocumentEncoder::OutputWrap);
   // "\n\n  first\nline is\ntoo long\n  second\nline is\neven\nloooonger\n\n\n"
   ASSERT_TRUE(test.EqualsLiteral(
       NS_LINEBREAK NS_LINEBREAK
       "  first" NS_LINEBREAK "line is" NS_LINEBREAK "too long" NS_LINEBREAK
       "  second" NS_LINEBREAK "line is" NS_LINEBREAK "even" NS_LINEBREAK
       "loooonger" NS_LINEBREAK NS_LINEBREAK NS_LINEBREAK))
-      << "Wrong prettyprinted html to text serialization";
+  << "Wrong prettyprinted html to text serialization";
 }
 
-TEST(PlainTextSerializer, Simple) {
+TEST(PlainTextSerializer, Simple)
+{
   nsString test;
   test.AppendLiteral(
       "<html><base>base</base><head><span>span</span></head>"
       "<body>body</body></html>");
   ConvertBufToPlainText(test, 0);
   ASSERT_TRUE(test.EqualsLiteral("basespanbody"))
-      << "Wrong html to text serialization";
+  << "Wrong html to text serialization";
 }
--- a/dom/base/test/gtest/TestXPathGenerator.cpp
+++ b/dom/base/test/gtest/TestXPathGenerator.cpp
@@ -3,134 +3,143 @@
 /* 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 "gtest/gtest.h"
 #include "XPathGenerator.h"
 #include "nsString.h"
 
-TEST(TestXPathGenerator, TestQuoteArgumentWithoutQuote) {
+TEST(TestXPathGenerator, TestQuoteArgumentWithoutQuote)
+{
   nsAutoString arg;
   arg.AssignLiteral(u"testing");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"\'testing\'");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestQuoteArgumentWithSingleQuote) {
+TEST(TestXPathGenerator, TestQuoteArgumentWithSingleQuote)
+{
   nsAutoString arg;
   arg.AssignLiteral(u"\'testing\'");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"\"\'testing\'\"");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestQuoteArgumentWithDoubleQuote) {
+TEST(TestXPathGenerator, TestQuoteArgumentWithDoubleQuote)
+{
   nsAutoString arg;
   arg.AssignLiteral(u"\"testing\"");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"\'\"testing\"\'");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestQuoteArgumentWithSingleAndDoubleQuote) {
+TEST(TestXPathGenerator, TestQuoteArgumentWithSingleAndDoubleQuote)
+{
   nsAutoString arg;
   arg.AssignLiteral(u"\'testing\"");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"concat(\'\',\"\'\",\'testing\"\')");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
   printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(),
          NS_ConvertUTF16toUTF8(expectedResult).get());
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
 TEST(TestXPathGenerator,
-     TestQuoteArgumentWithDoubleQuoteAndASequenceOfSingleQuote) {
+     TestQuoteArgumentWithDoubleQuoteAndASequenceOfSingleQuote)
+{
   nsAutoString arg;
   arg.AssignLiteral(u"\'\'\'\'testing\"");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"concat(\'\',\"\'\'\'\'\",\'testing\"\')");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
   printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(),
          NS_ConvertUTF16toUTF8(expectedResult).get());
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
 TEST(TestXPathGenerator,
-     TestQuoteArgumentWithDoubleQuoteAndTwoSequencesOfSingleQuote) {
+     TestQuoteArgumentWithDoubleQuoteAndTwoSequencesOfSingleQuote)
+{
   nsAutoString arg;
   arg.AssignLiteral(u"\'\'\'\'testing\'\'\'\'\'\'\"");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(
       u"concat(\'\',\"\'\'\'\'\",\'testing\',\"\'\'\'\'\'\'\",\'\"\')");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
   printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(),
          NS_ConvertUTF16toUTF8(expectedResult).get());
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
 TEST(TestXPathGenerator,
-     TestQuoteArgumentWithDoubleQuoteAndTwoSequencesOfSingleQuoteInMiddle) {
+     TestQuoteArgumentWithDoubleQuoteAndTwoSequencesOfSingleQuoteInMiddle)
+{
   nsAutoString arg;
   arg.AssignLiteral(u"t\'\'\'\'estin\'\'\'\'\'\'\"g");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(
       u"concat(\'t\',\"\'\'\'\'\",\'estin\',\"\'\'\'\'\'\'\",\'\"g\')");
 
   nsAutoString result;
   XPathGenerator::QuoteArgument(arg, result);
   printf("Result: %s\nExpected: %s\n", NS_ConvertUTF16toUTF8(result).get(),
          NS_ConvertUTF16toUTF8(expectedResult).get());
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestEscapeNameWithNormalCharacters) {
+TEST(TestXPathGenerator, TestEscapeNameWithNormalCharacters)
+{
   nsAutoString arg;
   arg.AssignLiteral(u"testing");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"testing");
 
   nsAutoString result;
   XPathGenerator::EscapeName(arg, result);
 
   ASSERT_TRUE(expectedResult.Equals(result));
 }
 
-TEST(TestXPathGenerator, TestEscapeNameWithSpecialCharacters) {
+TEST(TestXPathGenerator, TestEscapeNameWithSpecialCharacters)
+{
   nsAutoString arg;
   arg.AssignLiteral(u"^testing!");
 
   nsAutoString expectedResult;
   expectedResult.AssignLiteral(u"*[local-name()=\'^testing!\']");
 
   nsAutoString result;
   XPathGenerator::EscapeName(arg, result);
--- a/dom/canvas/gtest/TestImageBitmapColorUtils.cpp
+++ b/dom/canvas/gtest/TestImageBitmapColorUtils.cpp
@@ -715,17 +715,18 @@ class LabData : public SimpleImage<float
     mData[i + 7] = 0.0f;
     mData[i + 8] = 0.0f;
   }
 };
 
 /*
  * From RGB24.
  */
-TEST(ImageBitmapColorUtils, RGB24ToBGR24_) {
+TEST(ImageBitmapColorUtils, RGB24ToBGR24_)
+{
   const RGB24Data srcData;
   const BGR24Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = RGB24ToBGR24(srcData.mData, srcData.mStride, result_.mData,
                         result_.mStride, result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -740,17 +741,18 @@ TEST(ImageBitmapColorUtils, RGB24ToBGR24
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 2]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGB24ToRGBA32) {
+TEST(ImageBitmapColorUtils, RGB24ToRGBA32)
+{
   const RGB24Data srcData;
   const RGBA32Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = RGB24ToRGBA32(srcData.mData, srcData.mStride, result_.mData,
                          result_.mStride, result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -768,17 +770,18 @@ TEST(ImageBitmapColorUtils, RGB24ToRGBA3
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 2]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           255);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGB24ToBGRA32) {
+TEST(ImageBitmapColorUtils, RGB24ToBGRA32)
+{
   const RGB24Data srcData;
   const BGRA32Data dstData;
 
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = RGB24ToBGRA32(srcData.mData, srcData.mStride, result_.mData,
                          result_.mStride, result_.mWidth, result_.mHeight);
@@ -840,17 +843,18 @@ TEST(ImageBitmapColorUtils, RGB24ToBGRA3
 //                              1, 1);
 //
 //  printf_stderr(
 //    "\nlibyuv: (%hhu, %hhu, %hhu) --> (%hhu, %hhu, %hhu, %hhu) \n",
 //    yuvPixel[0], yuvPixel[1], yuvPixel[2],
 //    gbaPixel[0], rgbaPixel[1], rgbaPixel[2], rgbaPixel[3]);
 //}
 
-TEST(ImageBitmapColorUtils, RGB24ToYUV444P) {
+TEST(ImageBitmapColorUtils, RGB24ToYUV444P)
+{
   const RGB24Data srcData;
   const YUV444PData dstData;
 
   YUVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth, srcData.mHeight, srcData.mStride);
 
   int rv = RGB24ToYUV444P(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -867,17 +871,18 @@ TEST(ImageBitmapColorUtils, RGB24ToYUV44
       EXPECT_EQ(dstData.UBuffer()[i * dstData.mUStride + j],
                 result_.UBuffer()[i * result_.mUStride + j]);
       EXPECT_EQ(dstData.VBuffer()[i * dstData.mVStride + j],
                 result_.VBuffer()[i * result_.mVStride + j]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGB24ToYUV422P) {
+TEST(ImageBitmapColorUtils, RGB24ToYUV422P)
+{
   const RGB24Data srcData;
   const YUV422PData dstData;
 
   YUVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth / 2 + 1, srcData.mHeight, srcData.mStride,
                    srcData.mWidth / 2 + 1, srcData.mHeight, srcData.mStride);
 
   int rv = RGB24ToYUV422P(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -899,17 +904,18 @@ TEST(ImageBitmapColorUtils, RGB24ToYUV42
       EXPECT_EQ(dstData.UBuffer()[i * dstData.mUStride + j],
                 result_.UBuffer()[i * result_.mUStride + j]);
       EXPECT_EQ(dstData.VBuffer()[i * dstData.mVStride + j],
                 result_.VBuffer()[i * result_.mVStride + j]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGB24ToYUV420P) {
+TEST(ImageBitmapColorUtils, RGB24ToYUV420P)
+{
   const RGB24Data srcData;
   const YUV420PData dstData;
 
   YUVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth / 2 + 1, srcData.mHeight / 2 + 1,
                    srcData.mStride, srcData.mWidth / 2 + 1,
                    srcData.mHeight / 2 + 1, srcData.mStride);
 
@@ -932,17 +938,18 @@ TEST(ImageBitmapColorUtils, RGB24ToYUV42
       EXPECT_EQ(dstData.UBuffer()[i * dstData.mUStride + j],
                 result_.UBuffer()[i * result_.mUStride + j]);
       EXPECT_EQ(dstData.VBuffer()[i * dstData.mVStride + j],
                 result_.VBuffer()[i * result_.mVStride + j]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGB24ToNV12) {
+TEST(ImageBitmapColorUtils, RGB24ToNV12)
+{
   const RGB24Data srcData;
   const NV12Data dstData;
 
   NVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                   srcData.mWidth / 2 + 1, srcData.mHeight / 2 + 1,
                   srcData.mStride + 10);
 
   int rv = RGB24ToNV12(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -963,17 +970,18 @@ TEST(ImageBitmapColorUtils, RGB24ToNV12)
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 0],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 0]);
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 1],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 1]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGB24ToNV21) {
+TEST(ImageBitmapColorUtils, RGB24ToNV21)
+{
   const RGB24Data srcData;
   const NV21Data dstData;
 
   NVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                   srcData.mWidth / 2 + 1, srcData.mHeight / 2 + 1,
                   srcData.mStride + 10);
 
   int rv = RGB24ToNV21(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -994,17 +1002,18 @@ TEST(ImageBitmapColorUtils, RGB24ToNV21)
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 0],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 0]);
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 1],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 1]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGB24ToHSV) {
+TEST(ImageBitmapColorUtils, RGB24ToHSV)
+{
   const RGB24Data srcData;
   const HSVData dstData;
 
   SimpleImage<float> result_(srcData.mWidth, srcData.mHeight, 3);
 
   int rv = RGB24ToHSV(srcData.mData, srcData.mStride, result_.mData,
                       result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -1017,17 +1026,18 @@ TEST(ImageBitmapColorUtils, RGB24ToHSV) 
         const double expectedValue = dstData.GetPixelValue(i, j, c);
         const double diff = std::abs(actualValue - expectedValue);
         EXPECT_LT(diff, 1.0);
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGB24ToLab) {
+TEST(ImageBitmapColorUtils, RGB24ToLab)
+{
   const RGB24Data srcData;
   const LabData dstData;
 
   SimpleImage<float> result_(srcData.mWidth, srcData.mHeight, 3);
 
   int rv = RGB24ToLab(srcData.mData, srcData.mStride, result_.mData,
                       result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -1040,17 +1050,18 @@ TEST(ImageBitmapColorUtils, RGB24ToLab) 
         const double expectedValue = dstData.GetPixelValue(i, j, c);
         const double diff = std::abs(actualValue - expectedValue);
         EXPECT_LT(diff, 1.0);
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGB24ToGray8) {
+TEST(ImageBitmapColorUtils, RGB24ToGray8)
+{
   const RGB24Data srcData;
   const GrayData dstData;
 
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight, 1);
 
   int rv = RGB24ToGray8(srcData.mData, srcData.mStride, result_.mData,
                         result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -1063,17 +1074,18 @@ TEST(ImageBitmapColorUtils, RGB24ToGray8
     }
   }
 }
 
 /*
  * From BGR24.
  */
 
-TEST(ImageBitmapColorUtils, BGR24ToRGB24_) {
+TEST(ImageBitmapColorUtils, BGR24ToRGB24_)
+{
   const BGR24Data srcData;
   const RGB24Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = BGR24ToRGB24(srcData.mData, srcData.mStride, result_.mData,
                         result_.mStride, result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -1088,17 +1100,18 @@ TEST(ImageBitmapColorUtils, BGR24ToRGB24
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 2]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGR24ToRGBA32) {
+TEST(ImageBitmapColorUtils, BGR24ToRGBA32)
+{
   const BGR24Data srcData;
   const RGBA32Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = BGR24ToRGBA32(srcData.mData, srcData.mStride, result_.mData,
                          result_.mStride, result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -1116,17 +1129,18 @@ TEST(ImageBitmapColorUtils, BGR24ToRGBA3
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 2]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           255);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGR24ToBGRA32) {
+TEST(ImageBitmapColorUtils, BGR24ToBGRA32)
+{
   const BGR24Data srcData;
   const BGRA32Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = BGR24ToBGRA32(srcData.mData, srcData.mStride, result_.mData,
                          result_.mStride, result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -1144,17 +1158,18 @@ TEST(ImageBitmapColorUtils, BGR24ToBGRA3
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 2]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           255);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGR24ToYUV444P) {
+TEST(ImageBitmapColorUtils, BGR24ToYUV444P)
+{
   const BGR24Data srcData;
   const YUV444PData dstData;
 
   YUVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth, srcData.mHeight, srcData.mStride);
 
   int rv = BGR24ToYUV444P(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -1171,17 +1186,18 @@ TEST(ImageBitmapColorUtils, BGR24ToYUV44
       EXPECT_EQ(dstData.UBuffer()[i * dstData.mUStride + j],
                 result_.UBuffer()[i * result_.mUStride + j]);
       EXPECT_EQ(dstData.VBuffer()[i * dstData.mVStride + j],
                 result_.VBuffer()[i * result_.mVStride + j]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGR24ToYUV422P) {
+TEST(ImageBitmapColorUtils, BGR24ToYUV422P)
+{
   const BGR24Data srcData;
   const YUV422PData dstData;
 
   YUVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth / 2 + 1, srcData.mHeight, srcData.mStride,
                    srcData.mWidth / 2 + 1, srcData.mHeight, srcData.mStride);
 
   int rv = BGR24ToYUV422P(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -1203,17 +1219,18 @@ TEST(ImageBitmapColorUtils, BGR24ToYUV42
       EXPECT_EQ(dstData.UBuffer()[i * dstData.mUStride + j],
                 result_.UBuffer()[i * result_.mUStride + j]);
       EXPECT_EQ(dstData.VBuffer()[i * dstData.mVStride + j],
                 result_.VBuffer()[i * result_.mVStride + j]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGR24ToYUV420P) {
+TEST(ImageBitmapColorUtils, BGR24ToYUV420P)
+{
   const BGR24Data srcData;
   const YUV420PData dstData;
 
   YUVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth / 2 + 1, srcData.mHeight / 2 + 1,
                    srcData.mStride, srcData.mWidth / 2 + 1,
                    srcData.mHeight / 2 + 1, srcData.mStride);
 
@@ -1236,17 +1253,18 @@ TEST(ImageBitmapColorUtils, BGR24ToYUV42
       EXPECT_EQ(dstData.UBuffer()[i * dstData.mUStride + j],
                 result_.UBuffer()[i * result_.mUStride + j]);
       EXPECT_EQ(dstData.VBuffer()[i * dstData.mVStride + j],
                 result_.VBuffer()[i * result_.mVStride + j]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGR24ToNV12) {
+TEST(ImageBitmapColorUtils, BGR24ToNV12)
+{
   const BGR24Data srcData;
   const NV12Data dstData;
 
   NVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                   srcData.mWidth / 2 + 1, srcData.mHeight / 2 + 1,
                   srcData.mStride + 10);
 
   int rv = BGR24ToNV12(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -1267,17 +1285,18 @@ TEST(ImageBitmapColorUtils, BGR24ToNV12)
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 0],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 0]);
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 1],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 1]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGR24ToNV21) {
+TEST(ImageBitmapColorUtils, BGR24ToNV21)
+{
   const BGR24Data srcData;
   const NV21Data dstData;
 
   NVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                   srcData.mWidth / 2 + 1, srcData.mHeight / 2 + 1,
                   srcData.mStride + 10);
 
   int rv = BGR24ToNV21(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -1298,17 +1317,18 @@ TEST(ImageBitmapColorUtils, BGR24ToNV21)
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 0],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 0]);
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 1],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 1]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGR24ToHSV) {
+TEST(ImageBitmapColorUtils, BGR24ToHSV)
+{
   const BGR24Data srcData;
   const HSVData dstData;
 
   SimpleImage<float> result_(srcData.mWidth, srcData.mHeight, 3);
 
   int rv = BGR24ToHSV(srcData.mData, srcData.mStride, result_.mData,
                       result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -1321,17 +1341,18 @@ TEST(ImageBitmapColorUtils, BGR24ToHSV) 
         const double expectedValue = dstData.GetPixelValue(i, j, c);
         const double diff = std::abs(actualValue - expectedValue);
         EXPECT_LT(diff, 1.0);
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGR24ToLab) {
+TEST(ImageBitmapColorUtils, BGR24ToLab)
+{
   const BGR24Data srcData;
   const LabData dstData;
 
   SimpleImage<float> result_(srcData.mWidth, srcData.mHeight, 3);
 
   int rv = BGR24ToLab(srcData.mData, srcData.mStride, result_.mData,
                       result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -1344,17 +1365,18 @@ TEST(ImageBitmapColorUtils, BGR24ToLab) 
         const double expectedValue = dstData.GetPixelValue(i, j, c);
         const double diff = std::abs(actualValue - expectedValue);
         EXPECT_LT(diff, 1.0);
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGR24ToGray8) {
+TEST(ImageBitmapColorUtils, BGR24ToGray8)
+{
   const BGR24Data srcData;
   const GrayData dstData;
 
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight, 1);
 
   int rv = BGR24ToGray8(srcData.mData, srcData.mStride, result_.mData,
                         result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -1366,17 +1388,18 @@ TEST(ImageBitmapColorUtils, BGR24ToGray8
                 dstData.mData[i * dstData.mStride + j]);
     }
   }
 }
 
 /*
  * From RGBA32.
  */
-TEST(ImageBitmapColorUtils, RGBA32ToRGB24) {
+TEST(ImageBitmapColorUtils, RGBA32ToRGB24)
+{
   const RGBA32Data srcData;
   const RGB24Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = RGBA32ToRGB24(srcData.mData, srcData.mStride, result_.mData,
                          result_.mStride, result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -1391,17 +1414,18 @@ TEST(ImageBitmapColorUtils, RGBA32ToRGB2
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 2]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGBA32ToBGR24) {
+TEST(ImageBitmapColorUtils, RGBA32ToBGR24)
+{
   const RGBA32Data srcData;
   const BGR24Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = RGBA32ToBGR24(srcData.mData, srcData.mStride, result_.mData,
                          result_.mStride, result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -1416,17 +1440,18 @@ TEST(ImageBitmapColorUtils, RGBA32ToBGR2
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 2]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGBA32ToYUV444P) {
+TEST(ImageBitmapColorUtils, RGBA32ToYUV444P)
+{
   const RGBA32Data srcData;
   const YUV444PData dstData;
 
   YUVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth, srcData.mHeight, srcData.mStride);
 
   int rv = RGBA32ToYUV444P(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -1443,17 +1468,18 @@ TEST(ImageBitmapColorUtils, RGBA32ToYUV4
       EXPECT_EQ(dstData.UBuffer()[i * dstData.mUStride + j],
                 result_.UBuffer()[i * result_.mUStride + j]);
       EXPECT_EQ(dstData.VBuffer()[i * dstData.mVStride + j],
                 result_.VBuffer()[i * result_.mVStride + j]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGBA32ToYUV422P) {
+TEST(ImageBitmapColorUtils, RGBA32ToYUV422P)
+{
   const RGBA32Data srcData;
   const YUV422PData dstData;
 
   YUVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth / 2 + 1, srcData.mHeight, srcData.mStride,
                    srcData.mWidth / 2 + 1, srcData.mHeight, srcData.mStride);
 
   int rv = RGBA32ToYUV422P(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -1475,17 +1501,18 @@ TEST(ImageBitmapColorUtils, RGBA32ToYUV4
       EXPECT_EQ(dstData.UBuffer()[i * dstData.mUStride + j],
                 result_.UBuffer()[i * result_.mUStride + j]);
       EXPECT_EQ(dstData.VBuffer()[i * dstData.mVStride + j],
                 result_.VBuffer()[i * result_.mVStride + j]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGBA32ToYUV420P) {
+TEST(ImageBitmapColorUtils, RGBA32ToYUV420P)
+{
   const RGBA32Data srcData;
   const YUV420PData dstData;
 
   YUVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth / 2 + 1, srcData.mHeight / 2 + 1,
                    srcData.mStride, srcData.mWidth / 2 + 1,
                    srcData.mHeight / 2 + 1, srcData.mStride);
 
@@ -1508,17 +1535,18 @@ TEST(ImageBitmapColorUtils, RGBA32ToYUV4
       EXPECT_EQ(dstData.UBuffer()[i * dstData.mUStride + j],
                 result_.UBuffer()[i * result_.mUStride + j]);
       EXPECT_EQ(dstData.VBuffer()[i * dstData.mVStride + j],
                 result_.VBuffer()[i * result_.mVStride + j]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGBA32ToNV12) {
+TEST(ImageBitmapColorUtils, RGBA32ToNV12)
+{
   const RGBA32Data srcData;
   const NV12Data dstData;
 
   NVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                   srcData.mWidth / 2 + 1, srcData.mHeight / 2 + 1,
                   srcData.mStride + 10);
 
   int rv = RGBA32ToNV12(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -1539,17 +1567,18 @@ TEST(ImageBitmapColorUtils, RGBA32ToNV12
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 0],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 0]);
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 1],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 1]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGBA32ToNV21) {
+TEST(ImageBitmapColorUtils, RGBA32ToNV21)
+{
   const RGBA32Data srcData;
   const NV21Data dstData;
 
   NVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                   srcData.mWidth / 2 + 1, srcData.mHeight / 2 + 1,
                   srcData.mStride + 10);
 
   int rv = RGBA32ToNV21(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -1570,17 +1599,18 @@ TEST(ImageBitmapColorUtils, RGBA32ToNV21
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 0],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 0]);
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 1],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 1]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGBA32ToHSV) {
+TEST(ImageBitmapColorUtils, RGBA32ToHSV)
+{
   const RGBA32Data srcData;
   const HSVData dstData;
 
   SimpleImage<float> result_(srcData.mWidth, srcData.mHeight, 3);
 
   int rv = RGBA32ToHSV(srcData.mData, srcData.mStride, result_.mData,
                        result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -1593,17 +1623,18 @@ TEST(ImageBitmapColorUtils, RGBA32ToHSV)
         const double expectedValue = dstData.GetPixelValue(i, j, c);
         const double diff = std::abs(actualValue - expectedValue);
         EXPECT_LT(diff, 1.0);
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGBA32ToLab) {
+TEST(ImageBitmapColorUtils, RGBA32ToLab)
+{
   const RGBA32Data srcData;
   const LabData dstData;
 
   SimpleImage<float> result_(srcData.mWidth, srcData.mHeight, 3);
 
   int rv = RGBA32ToLab(srcData.mData, srcData.mStride, result_.mData,
                        result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -1616,17 +1647,18 @@ TEST(ImageBitmapColorUtils, RGBA32ToLab)
         const double expectedValue = dstData.GetPixelValue(i, j, c);
         const double diff = std::abs(actualValue - expectedValue);
         EXPECT_LT(diff, 1.0);
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, RGBA32ToGray8) {
+TEST(ImageBitmapColorUtils, RGBA32ToGray8)
+{
   const RGBA32Data srcData;
   const GrayData dstData;
 
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight, 1);
 
   int rv = RGBA32ToGray8(srcData.mData, srcData.mStride, result_.mData,
                          result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -1638,17 +1670,18 @@ TEST(ImageBitmapColorUtils, RGBA32ToGray
                 dstData.mData[i * dstData.mStride + j]);
     }
   }
 }
 
 /*
  * From BGRA32.
  */
-TEST(ImageBitmapColorUtils, BGRA32ToRGB24) {
+TEST(ImageBitmapColorUtils, BGRA32ToRGB24)
+{
   const BGRA32Data srcData;
   const RGB24Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = BGRA32ToRGB24(srcData.mData, srcData.mStride, result_.mData,
                          result_.mStride, result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -1663,17 +1696,18 @@ TEST(ImageBitmapColorUtils, BGRA32ToRGB2
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 2]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGRA32ToBGR24) {
+TEST(ImageBitmapColorUtils, BGRA32ToBGR24)
+{
   const BGRA32Data srcData;
   const BGR24Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = BGRA32ToBGR24(srcData.mData, srcData.mStride, result_.mData,
                          result_.mStride, result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -1688,17 +1722,18 @@ TEST(ImageBitmapColorUtils, BGRA32ToBGR2
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.mData[i * dstData.mStride + j * dstData.mChannelCount + 2]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGRA32ToYUV444P) {
+TEST(ImageBitmapColorUtils, BGRA32ToYUV444P)
+{
   const BGRA32Data srcData;
   const YUV444PData dstData;
 
   YUVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth, srcData.mHeight, srcData.mStride);
 
   int rv = BGRA32ToYUV444P(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -1715,17 +1750,18 @@ TEST(ImageBitmapColorUtils, BGRA32ToYUV4
       EXPECT_EQ(dstData.UBuffer()[i * dstData.mUStride + j],
                 result_.UBuffer()[i * result_.mUStride + j]);
       EXPECT_EQ(dstData.VBuffer()[i * dstData.mVStride + j],
                 result_.VBuffer()[i * result_.mVStride + j]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGRA32ToYUV422P) {
+TEST(ImageBitmapColorUtils, BGRA32ToYUV422P)
+{
   const BGRA32Data srcData;
   const YUV422PData dstData;
 
   YUVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth / 2 + 1, srcData.mHeight, srcData.mStride,
                    srcData.mWidth / 2 + 1, srcData.mHeight, srcData.mStride);
 
   int rv = BGRA32ToYUV422P(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -1747,17 +1783,18 @@ TEST(ImageBitmapColorUtils, BGRA32ToYUV4
       EXPECT_EQ(dstData.UBuffer()[i * dstData.mUStride + j],
                 result_.UBuffer()[i * result_.mUStride + j]);
       EXPECT_EQ(dstData.VBuffer()[i * dstData.mVStride + j],
                 result_.VBuffer()[i * result_.mVStride + j]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGRA32ToYUV420P) {
+TEST(ImageBitmapColorUtils, BGRA32ToYUV420P)
+{
   const BGRA32Data srcData;
   const YUV420PData dstData;
 
   YUVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                    srcData.mWidth / 2 + 1, srcData.mHeight / 2 + 1,
                    srcData.mStride, srcData.mWidth / 2 + 1,
                    srcData.mHeight / 2 + 1, srcData.mStride);
 
@@ -1780,17 +1817,18 @@ TEST(ImageBitmapColorUtils, BGRA32ToYUV4
       EXPECT_EQ(dstData.UBuffer()[i * dstData.mUStride + j],
                 result_.UBuffer()[i * result_.mUStride + j]);
       EXPECT_EQ(dstData.VBuffer()[i * dstData.mVStride + j],
                 result_.VBuffer()[i * result_.mVStride + j]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGRA32ToNV12) {
+TEST(ImageBitmapColorUtils, BGRA32ToNV12)
+{
   const BGRA32Data srcData;
   const NV12Data dstData;
 
   NVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                   srcData.mWidth / 2 + 1, srcData.mHeight / 2 + 1,
                   srcData.mStride + 10);
 
   int rv = BGRA32ToNV12(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -1811,17 +1849,18 @@ TEST(ImageBitmapColorUtils, BGRA32ToNV12
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 0],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 0]);
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 1],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 1]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGRA32ToNV21) {
+TEST(ImageBitmapColorUtils, BGRA32ToNV21)
+{
   const BGRA32Data srcData;
   const NV21Data dstData;
 
   NVImage result_(srcData.mWidth, srcData.mHeight, srcData.mStride,
                   srcData.mWidth / 2 + 1, srcData.mHeight / 2 + 1,
                   srcData.mStride + 10);
 
   int rv = BGRA32ToNV21(srcData.mData, srcData.mStride, result_.YBuffer(),
@@ -1842,17 +1881,18 @@ TEST(ImageBitmapColorUtils, BGRA32ToNV21
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 0],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 0]);
       EXPECT_EQ(dstData.UVBuffer()[i * dstData.mUVStride + j * 2 + 1],
                 result_.UVBuffer()[i * result_.mUVStride + j * 2 + 1]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGRA32ToHSV) {
+TEST(ImageBitmapColorUtils, BGRA32ToHSV)
+{
   const BGRA32Data srcData;
   const HSVData dstData;
 
   SimpleImage<float> result_(srcData.mWidth, srcData.mHeight, 3);
 
   int rv = BGRA32ToHSV(srcData.mData, srcData.mStride, result_.mData,
                        result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -1865,17 +1905,18 @@ TEST(ImageBitmapColorUtils, BGRA32ToHSV)
         const double expectedValue = dstData.GetPixelValue(i, j, c);
         const double diff = std::abs(actualValue - expectedValue);
         EXPECT_LT(diff, 1.0);
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGRA32ToLab) {
+TEST(ImageBitmapColorUtils, BGRA32ToLab)
+{
   const BGRA32Data srcData;
   const LabData dstData;
 
   SimpleImage<float> result_(srcData.mWidth, srcData.mHeight, 3);
 
   int rv = BGRA32ToLab(srcData.mData, srcData.mStride, result_.mData,
                        result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -1888,17 +1929,18 @@ TEST(ImageBitmapColorUtils, BGRA32ToLab)
         const double expectedValue = dstData.GetPixelValue(i, j, c);
         const double diff = std::abs(actualValue - expectedValue);
         EXPECT_LT(diff, 1.0);
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, BGRA32ToGray8) {
+TEST(ImageBitmapColorUtils, BGRA32ToGray8)
+{
   const BGRA32Data srcData;
   const GrayData dstData;
 
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight, 1);
 
   int rv = BGRA32ToGray8(srcData.mData, srcData.mStride, result_.mData,
                          result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -1910,17 +1952,18 @@ TEST(ImageBitmapColorUtils, BGRA32ToGray
                 dstData.mData[i * dstData.mStride + j]);
     }
   }
 }
 
 /*
  * From YUV444P.
  */
-TEST(ImageBitmapColorUtils, YUV444PToRGB24) {
+TEST(ImageBitmapColorUtils, YUV444PToRGB24)
+{
   const YUV444PData srcData;
   const RGBA32DataFromYUV444PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 3);
 
   int rv = YUV444PToRGB24(srcData.YBuffer(), srcData.mYStride,
                           srcData.UBuffer(), srcData.mUStride,
                           srcData.VBuffer(), srcData.mVStride, result_.mData,
                           result_.mStride, result_.mWidth, result_.mHeight);
@@ -1936,17 +1979,18 @@ TEST(ImageBitmapColorUtils, YUV444PToRGB
           dstData.GetPixel(j, i)[1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.GetPixel(j, i)[2]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, YUV444PToBGR24) {
+TEST(ImageBitmapColorUtils, YUV444PToBGR24)
+{
   const YUV444PData srcData;
   const RGBA32DataFromYUV444PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 3);
 
   int rv = YUV444PToBGR24(srcData.YBuffer(), srcData.mYStride,
                           srcData.UBuffer(), srcData.mUStride,
                           srcData.VBuffer(), srcData.mVStride, result_.mData,
                           result_.mStride, result_.mWidth, result_.mHeight);
@@ -1962,17 +2006,18 @@ TEST(ImageBitmapColorUtils, YUV444PToBGR
           dstData.GetPixel(j, i)[1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.GetPixel(j, i)[0]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, YUV444PToRGBA32) {
+TEST(ImageBitmapColorUtils, YUV444PToRGBA32)
+{
   const YUV444PData srcData;
   const RGBA32DataFromYUV444PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight,
                                dstData.mChannelCount);
 
   int rv = YUV444PToRGBA32(srcData.YBuffer(), srcData.mYStride,
                            srcData.UBuffer(), srcData.mUStride,
                            srcData.VBuffer(), srcData.mVStride, result_.mData,
@@ -1992,17 +2037,18 @@ TEST(ImageBitmapColorUtils, YUV444PToRGB
           dstData.GetPixel(j, i)[2]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           dstData.GetPixel(j, i)[3]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, YUV444PToBGRA32) {
+TEST(ImageBitmapColorUtils, YUV444PToBGRA32)
+{
   const YUV444PData srcData;
   const RGBA32DataFromYUV444PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight,
                                dstData.mChannelCount);
 
   int rv = YUV444PToBGRA32(srcData.YBuffer(), srcData.mYStride,
                            srcData.UBuffer(), srcData.mUStride,
                            srcData.VBuffer(), srcData.mVStride, result_.mData,
@@ -2022,17 +2068,18 @@ TEST(ImageBitmapColorUtils, YUV444PToBGR
           dstData.GetPixel(j, i)[0]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           dstData.GetPixel(j, i)[3]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, YUV444PToGray8) {
+TEST(ImageBitmapColorUtils, YUV444PToGray8)
+{
   const YUV444PData srcData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 1);
 
   int rv = YUV444PToGray8(srcData.YBuffer(), srcData.mYStride,
                           srcData.UBuffer(), srcData.mUStride,
                           srcData.VBuffer(), srcData.mVStride, result_.mData,
                           result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -2044,17 +2091,18 @@ TEST(ImageBitmapColorUtils, YUV444PToGra
                 srcData.YBuffer()[i * srcData.mYStride + j]);
     }
   }
 }
 
 /*
  * From YUV422P.
  */
-TEST(ImageBitmapColorUtils, YUV422PToRGB24) {
+TEST(ImageBitmapColorUtils, YUV422PToRGB24)
+{
   const YUV422PData srcData;
   const RGBA32DataFromYUV422PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 3);
 
   int rv = YUV422PToRGB24(srcData.YBuffer(), srcData.mYStride,
                           srcData.UBuffer(), srcData.mUStride,
                           srcData.VBuffer(), srcData.mVStride, result_.mData,
                           result_.mStride, result_.mWidth, result_.mHeight);
@@ -2070,17 +2118,18 @@ TEST(ImageBitmapColorUtils, YUV422PToRGB
           dstData.GetPixel(j, i)[1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.GetPixel(j, i)[2]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, YUV422PToBGR24) {
+TEST(ImageBitmapColorUtils, YUV422PToBGR24)
+{
   const YUV422PData srcData;
   const RGBA32DataFromYUV422PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 3);
 
   int rv = YUV422PToBGR24(srcData.YBuffer(), srcData.mYStride,
                           srcData.UBuffer(), srcData.mUStride,
                           srcData.VBuffer(), srcData.mVStride, result_.mData,
                           result_.mStride, result_.mWidth, result_.mHeight);
@@ -2096,17 +2145,18 @@ TEST(ImageBitmapColorUtils, YUV422PToBGR
           dstData.GetPixel(j, i)[1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.GetPixel(j, i)[0]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, YUV422PToRGBA32) {
+TEST(ImageBitmapColorUtils, YUV422PToRGBA32)
+{
   const YUV422PData srcData;
   const RGBA32DataFromYUV422PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight,
                                dstData.mChannelCount);
 
   int rv = YUV422PToRGBA32(srcData.YBuffer(), srcData.mYStride,
                            srcData.UBuffer(), srcData.mUStride,
                            srcData.VBuffer(), srcData.mVStride, result_.mData,
@@ -2126,17 +2176,18 @@ TEST(ImageBitmapColorUtils, YUV422PToRGB
           dstData.GetPixel(j, i)[2]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           dstData.GetPixel(j, i)[3]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, YUV422PToBGRA32) {
+TEST(ImageBitmapColorUtils, YUV422PToBGRA32)
+{
   const YUV422PData srcData;
   const RGBA32DataFromYUV422PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight,
                                dstData.mChannelCount);
 
   int rv = YUV422PToBGRA32(srcData.YBuffer(), srcData.mYStride,
                            srcData.UBuffer(), srcData.mUStride,
                            srcData.VBuffer(), srcData.mVStride, result_.mData,
@@ -2156,17 +2207,18 @@ TEST(ImageBitmapColorUtils, YUV422PToBGR
           dstData.GetPixel(j, i)[0]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           dstData.GetPixel(j, i)[3]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, YUV422PToGray8) {
+TEST(ImageBitmapColorUtils, YUV422PToGray8)
+{
   const YUV422PData srcData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 1);
 
   int rv = YUV422PToGray8(srcData.YBuffer(), srcData.mYStride,
                           srcData.UBuffer(), srcData.mUStride,
                           srcData.VBuffer(), srcData.mVStride, result_.mData,
                           result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -2178,17 +2230,18 @@ TEST(ImageBitmapColorUtils, YUV422PToGra
                 srcData.YBuffer()[i * srcData.mYStride + j]);
     }
   }
 }
 
 /*
  * From YUV420P.
  */
-TEST(ImageBitmapColorUtils, YUV420PToRGB24) {
+TEST(ImageBitmapColorUtils, YUV420PToRGB24)
+{
   const YUV420PData srcData;
   const RGBA32DataFromYUV420PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 3);
 
   int rv = YUV420PToRGB24(srcData.YBuffer(), srcData.mYStride,
                           srcData.UBuffer(), srcData.mUStride,
                           srcData.VBuffer(), srcData.mVStride, result_.mData,
                           result_.mStride, result_.mWidth, result_.mHeight);
@@ -2204,17 +2257,18 @@ TEST(ImageBitmapColorUtils, YUV420PToRGB
           dstData.GetPixel(j, i)[1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.GetPixel(j, i)[2]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, YUV420PToBGR24) {
+TEST(ImageBitmapColorUtils, YUV420PToBGR24)
+{
   const YUV420PData srcData;
   const RGBA32DataFromYUV420PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 3);
 
   int rv = YUV420PToBGR24(srcData.YBuffer(), srcData.mYStride,
                           srcData.UBuffer(), srcData.mUStride,
                           srcData.VBuffer(), srcData.mVStride, result_.mData,
                           result_.mStride, result_.mWidth, result_.mHeight);
@@ -2230,17 +2284,18 @@ TEST(ImageBitmapColorUtils, YUV420PToBGR
           dstData.GetPixel(j, i)[1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.GetPixel(j, i)[0]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, YUV420PToRGBA32) {
+TEST(ImageBitmapColorUtils, YUV420PToRGBA32)
+{
   const YUV420PData srcData;
   const RGBA32DataFromYUV420PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight,
                                dstData.mChannelCount);
 
   int rv = YUV420PToRGBA32(srcData.YBuffer(), srcData.mYStride,
                            srcData.UBuffer(), srcData.mUStride,
                            srcData.VBuffer(), srcData.mVStride, result_.mData,
@@ -2260,17 +2315,18 @@ TEST(ImageBitmapColorUtils, YUV420PToRGB
           dstData.GetPixel(j, i)[2]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           dstData.GetPixel(j, i)[3]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, YUV420PToBGRA32) {
+TEST(ImageBitmapColorUtils, YUV420PToBGRA32)
+{
   const YUV420PData srcData;
   const RGBA32DataFromYUV420PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight,
                                dstData.mChannelCount);
 
   int rv = YUV420PToBGRA32(srcData.YBuffer(), srcData.mYStride,
                            srcData.UBuffer(), srcData.mUStride,
                            srcData.VBuffer(), srcData.mVStride, result_.mData,
@@ -2290,17 +2346,18 @@ TEST(ImageBitmapColorUtils, YUV420PToBGR
           dstData.GetPixel(j, i)[0]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           dstData.GetPixel(j, i)[3]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, YUV420PToGray8) {
+TEST(ImageBitmapColorUtils, YUV420PToGray8)
+{
   const YUV420PData srcData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 1);
 
   int rv = YUV420PToGray8(srcData.YBuffer(), srcData.mYStride,
                           srcData.UBuffer(), srcData.mUStride,
                           srcData.VBuffer(), srcData.mVStride, result_.mData,
                           result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -2312,17 +2369,18 @@ TEST(ImageBitmapColorUtils, YUV420PToGra
                 srcData.YBuffer()[i * srcData.mYStride + j]);
     }
   }
 }
 
 /*
  * From NV12.
  */
-TEST(ImageBitmapColorUtils, NV12ToRGB24) {
+TEST(ImageBitmapColorUtils, NV12ToRGB24)
+{
   const NV12Data srcData;
   const RGBA32DataFromYUV420PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 3);
 
   int rv = NV12ToRGB24(srcData.YBuffer(), srcData.mYStride, srcData.UVBuffer(),
                        srcData.mUVStride, result_.mData, result_.mStride,
                        result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -2337,17 +2395,18 @@ TEST(ImageBitmapColorUtils, NV12ToRGB24)
           dstData.GetPixel(j, i)[1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.GetPixel(j, i)[2]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, NV12ToBGR24) {
+TEST(ImageBitmapColorUtils, NV12ToBGR24)
+{
   const NV12Data srcData;
   const RGBA32DataFromYUV420PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 3);
 
   int rv = NV12ToBGR24(srcData.YBuffer(), srcData.mYStride, srcData.UVBuffer(),
                        srcData.mUVStride, result_.mData, result_.mStride,
                        result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -2362,17 +2421,18 @@ TEST(ImageBitmapColorUtils, NV12ToBGR24)
           dstData.GetPixel(j, i)[1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.GetPixel(j, i)[0]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, NV12ToRGBA32) {
+TEST(ImageBitmapColorUtils, NV12ToRGBA32)
+{
   const NV12Data srcData;
   const RGBA32DataFromYUV420PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight,
                                dstData.mChannelCount);
 
   int rv = NV12ToRGBA32(srcData.YBuffer(), srcData.mYStride, srcData.UVBuffer(),
                         srcData.mUVStride, result_.mData, result_.mStride,
                         result_.mWidth, result_.mHeight);
@@ -2391,17 +2451,18 @@ TEST(ImageBitmapColorUtils, NV12ToRGBA32
           dstData.GetPixel(j, i)[2]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           dstData.GetPixel(j, i)[3]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, NV12ToBGRA32) {
+TEST(ImageBitmapColorUtils, NV12ToBGRA32)
+{
   const NV12Data srcData;
   const RGBA32DataFromYUV420PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight,
                                dstData.mChannelCount);
 
   int rv = NV12ToBGRA32(srcData.YBuffer(), srcData.mYStride, srcData.UVBuffer(),
                         srcData.mUVStride, result_.mData, result_.mStride,
                         result_.mWidth, result_.mHeight);
@@ -2420,17 +2481,18 @@ TEST(ImageBitmapColorUtils, NV12ToBGRA32
           dstData.GetPixel(j, i)[0]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           dstData.GetPixel(j, i)[3]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, NV12ToGray8) {
+TEST(ImageBitmapColorUtils, NV12ToGray8)
+{
   const NV12Data srcData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 1);
 
   int rv = NV12ToGray8(srcData.YBuffer(), srcData.mYStride, srcData.UVBuffer(),
                        srcData.mUVStride, result_.mData, result_.mStride,
                        result_.mWidth, result_.mHeight);
 
   ASSERT_TRUE(rv == 0);
@@ -2441,17 +2503,18 @@ TEST(ImageBitmapColorUtils, NV12ToGray8)
                 srcData.YBuffer()[i * srcData.mYStride + j]);
     }
   }
 }
 
 /*
  * From NV21.
  */
-TEST(ImageBitmapColorUtils, NV21ToRGB24) {
+TEST(ImageBitmapColorUtils, NV21ToRGB24)
+{
   const NV21Data srcData;
   const RGBA32DataFromYUV420PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 3);
 
   int rv = NV21ToRGB24(srcData.YBuffer(), srcData.mYStride, srcData.UVBuffer(),
                        srcData.mUVStride, result_.mData, result_.mStride,
                        result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -2466,17 +2529,18 @@ TEST(ImageBitmapColorUtils, NV21ToRGB24)
           dstData.GetPixel(j, i)[1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.GetPixel(j, i)[2]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, NV21ToBGR24) {
+TEST(ImageBitmapColorUtils, NV21ToBGR24)
+{
   const NV21Data srcData;
   const RGBA32DataFromYUV420PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 3);
 
   int rv = NV21ToBGR24(srcData.YBuffer(), srcData.mYStride, srcData.UVBuffer(),
                        srcData.mUVStride, result_.mData, result_.mStride,
                        result_.mWidth, result_.mHeight);
   ASSERT_TRUE(rv == 0);
@@ -2491,17 +2555,18 @@ TEST(ImageBitmapColorUtils, NV21ToBGR24)
           dstData.GetPixel(j, i)[1]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 2],
           dstData.GetPixel(j, i)[0]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, NV21ToRGBA32) {
+TEST(ImageBitmapColorUtils, NV21ToRGBA32)
+{
   const NV21Data srcData;
   const RGBA32DataFromYUV420PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight,
                                dstData.mChannelCount);
 
   int rv = NV21ToRGBA32(srcData.YBuffer(), srcData.mYStride, srcData.UVBuffer(),
                         srcData.mUVStride, result_.mData, result_.mStride,
                         result_.mWidth, result_.mHeight);
@@ -2520,17 +2585,18 @@ TEST(ImageBitmapColorUtils, NV21ToRGBA32
           dstData.GetPixel(j, i)[2]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           dstData.GetPixel(j, i)[3]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, NV21ToBGRA32) {
+TEST(ImageBitmapColorUtils, NV21ToBGRA32)
+{
   const NV21Data srcData;
   const RGBA32DataFromYUV420PData dstData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight,
                                dstData.mChannelCount);
 
   int rv = NV21ToBGRA32(srcData.YBuffer(), srcData.mYStride, srcData.UVBuffer(),
                         srcData.mUVStride, result_.mData, result_.mStride,
                         result_.mWidth, result_.mHeight);
@@ -2549,17 +2615,18 @@ TEST(ImageBitmapColorUtils, NV21ToBGRA32
           dstData.GetPixel(j, i)[0]);
       EXPECT_EQ(
           result_.mData[i * result_.mStride + j * result_.mChannelCount + 3],
           dstData.GetPixel(j, i)[3]);
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, NV21ToGray8) {
+TEST(ImageBitmapColorUtils, NV21ToGray8)
+{
   const NV21Data srcData;
   SimpleImage<uint8_t> result_(srcData.mYWidth, srcData.mYHeight, 1);
 
   int rv = NV21ToGray8(srcData.YBuffer(), srcData.mYStride, srcData.UVBuffer(),
                        srcData.mUVStride, result_.mData, result_.mStride,
                        result_.mWidth, result_.mHeight);
 
   ASSERT_TRUE(rv == 0);
@@ -2570,17 +2637,18 @@ TEST(ImageBitmapColorUtils, NV21ToGray8)
                 srcData.YBuffer()[i * srcData.mYStride + j]);
     }
   }
 }
 
 /*
  * From HSV.
  */
-TEST(ImageBitmapColorUtils, HSVToRGB24) {
+TEST(ImageBitmapColorUtils, HSVToRGB24)
+{
   const HSVData srcData;
   const RGB24Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = HSVToRGB24(srcData.mData, srcData.mStride, result_.mData,
                       result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -2591,17 +2659,18 @@ TEST(ImageBitmapColorUtils, HSVToRGB24) 
       for (int c = 0; c < dstData.mChannelCount; ++c) {
         EXPECT_EQ(result_.GetPixelValue(i, j, c),
                   dstData.GetPixelValue(i, j, c));
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, HSVToBGR24) {
+TEST(ImageBitmapColorUtils, HSVToBGR24)
+{
   const HSVData srcData;
   const BGR24Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = HSVToBGR24(srcData.mData, srcData.mStride, result_.mData,
                       result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -2612,17 +2681,18 @@ TEST(ImageBitmapColorUtils, HSVToBGR24) 
       for (int c = 0; c < dstData.mChannelCount; ++c) {
         EXPECT_EQ(result_.GetPixelValue(i, j, c),
                   dstData.GetPixelValue(i, j, c));
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, HSVToRGBA32) {
+TEST(ImageBitmapColorUtils, HSVToRGBA32)
+{
   const HSVData srcData;
   const RGBA32Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = HSVToRGBA32(srcData.mData, srcData.mStride, result_.mData,
                        result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -2633,17 +2703,18 @@ TEST(ImageBitmapColorUtils, HSVToRGBA32)
       for (int c = 0; c < dstData.mChannelCount; ++c) {
         EXPECT_EQ(result_.GetPixelValue(i, j, c),
                   dstData.GetPixelValue(i, j, c));
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, HSVToBGRA32) {
+TEST(ImageBitmapColorUtils, HSVToBGRA32)
+{
   const HSVData srcData;
   const BGRA32Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = HSVToBGRA32(srcData.mData, srcData.mStride, result_.mData,
                        result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -2657,17 +2728,18 @@ TEST(ImageBitmapColorUtils, HSVToBGRA32)
       }
     }
   }
 }
 
 /*
  * From Lab.
  */
-TEST(ImageBitmapColorUtils, LabToRGB24) {
+TEST(ImageBitmapColorUtils, LabToRGB24)
+{
   const LabData srcData;
   const RGB24Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = LabToRGB24(srcData.mData, srcData.mStride, result_.mData,
                       result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -2680,17 +2752,18 @@ TEST(ImageBitmapColorUtils, LabToRGB24) 
         const uint8_t expectedValue = dstData.GetPixelValue(i, j, c);
         const int diff = std::abs(actualValue - expectedValue);
         EXPECT_LE(diff, 1);
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, LabToBGR24) {
+TEST(ImageBitmapColorUtils, LabToBGR24)
+{
   const LabData srcData;
   const BGR24Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = LabToBGR24(srcData.mData, srcData.mStride, result_.mData,
                       result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -2703,17 +2776,18 @@ TEST(ImageBitmapColorUtils, LabToBGR24) 
         const uint8_t expectedValue = dstData.GetPixelValue(i, j, c);
         const int diff = std::abs(actualValue - expectedValue);
         EXPECT_LE(diff, 1);
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, LabToRGBA32) {
+TEST(ImageBitmapColorUtils, LabToRGBA32)
+{
   const LabData srcData;
   const RGBA32Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = LabToRGBA32(srcData.mData, srcData.mStride, result_.mData,
                        result_.mStride, result_.mWidth, result_.mHeight);
 
@@ -2726,17 +2800,18 @@ TEST(ImageBitmapColorUtils, LabToRGBA32)
         const uint8_t expectedValue = dstData.GetPixelValue(i, j, c);
         const int diff = std::abs(actualValue - expectedValue);
         EXPECT_LE(diff, 1);
       }
     }
   }
 }
 
-TEST(ImageBitmapColorUtils, LabToBGRA32) {
+TEST(ImageBitmapColorUtils, LabToBGRA32)
+{
   const LabData srcData;
   const BGRA32Data dstData;
   SimpleImage<uint8_t> result_(srcData.mWidth, srcData.mHeight,
                                dstData.mChannelCount);
 
   int rv = LabToBGRA32(srcData.mData, srcData.mStride, result_.mData,
                        result_.mStride, result_.mWidth, result_.mHeight);
 
--- a/dom/localstorage/test/gtest/TestLocalStorage.cpp
+++ b/dom/localstorage/test/gtest/TestLocalStorage.cpp
@@ -64,31 +64,35 @@ void CheckGeneratedOriginKey(nsIPrincipa
     EXPECT_TRUE(originKey == nsDependentCString(aOriginKey));
   } else {
     ASSERT_NE(rv, NS_OK) << "GenerateOriginKey2 should fail";
   }
 }
 
 }  // namespace
 
-TEST(LocalStorage, OriginKey) {
+TEST(LocalStorage, OriginKey)
+{
   // Check the system principal.
   nsCOMPtr<nsIScriptSecurityManager> secMan =
       nsContentUtils::GetSecurityManager();
-  ASSERT_TRUE(secMan) << "GetSecurityManager() should not fail";
+  ASSERT_TRUE(secMan)
+  << "GetSecurityManager() should not fail";
 
   nsCOMPtr<nsIPrincipal> principal;
   secMan->GetSystemPrincipal(getter_AddRefs(principal));
-  ASSERT_TRUE(principal) << "GetSystemPrincipal() should not fail";
+  ASSERT_TRUE(principal)
+  << "GetSystemPrincipal() should not fail";
 
   CheckGeneratedOriginKey(principal, nullptr);
 
   // Check the null principal.
   principal = NullPrincipal::CreateWithoutOriginAttributes();
-  ASSERT_TRUE(principal) << "CreateWithoutOriginAttributes() should not fail";
+  ASSERT_TRUE(principal)
+  << "CreateWithoutOriginAttributes() should not fail";
 
   CheckGeneratedOriginKey(principal, nullptr);
 
   // Check content principals.
   static const OriginKeyTest tests[] = {
       {"http://www.mozilla.org", "gro.allizom.www.:http:80"},
       {"https://www.mozilla.org", "gro.allizom.www.:https:443"},
       {"http://www.mozilla.org:32400", "gro.allizom.www.:http:32400"},
@@ -101,13 +105,14 @@ TEST(LocalStorage, OriginKey) {
       {"moz-extension://53711a8f-65ed-e742-9671-1f02e267c0bc/"
        "_generated_background_page.html",
        "cb0c762e20f1-1769-247e-de56-f8a11735.:moz-extension"},
       {"http://[::1]:8/test.html", "1::.:http:8"},
   };
 
   for (const auto& test : tests) {
     principal = GetCodebasePrincipal(test.mSpec);
-    ASSERT_TRUE(principal) << "GetCodebasePrincipal() should not fail";
+    ASSERT_TRUE(principal)
+    << "GetCodebasePrincipal() should not fail";
 
     CheckGeneratedOriginKey(principal, test.mOriginKey);
   }
 }
--- a/dom/media/doctor/gtest/TestMultiWriterQueue.cpp
+++ b/dom/media/doctor/gtest/TestMultiWriterQueue.cpp
@@ -40,17 +40,18 @@ static void TestMultiWriterQueueST(const
     // We should have got all numbers.
     EXPECT_EQ(max, x);
 
     // Nothing left.
     q.PopAll([&](int&) { EXPECT_TRUE(false); });
   }
 }
 
-TEST(MultiWriterQueue, SingleThreaded) {
+TEST(MultiWriterQueue, SingleThreaded)
+{
   TestMultiWriterQueueST<1>(10);
   TestMultiWriterQueueST<2>(10);
   TestMultiWriterQueueST<4>(10);
 
   TestMultiWriterQueueST<10>(9);
   TestMultiWriterQueueST<10>(10);
   TestMultiWriterQueueST<10>(11);
   TestMultiWriterQueueST<10>(19);
@@ -150,17 +151,18 @@ static void TestMultiWriterQueueMT(int a
       "alloc=%d (w %d)\n",
       aPrintPrefix, aWriterThreads, aReaderThreads, loops, pushes, duration,
       pushes / duration, q.LiveBuffersStats().mCount,
       q.LiveBuffersStats().mWatermark, q.ReusableBuffersStats().mCount,
       q.ReusableBuffersStats().mWatermark, q.AllocatedBuffersStats().mCount,
       q.AllocatedBuffersStats().mWatermark);
 }
 
-TEST(MultiWriterQueue, MultiWriterSingleReader) {
+TEST(MultiWriterQueue, MultiWriterSingleReader)
+{
   // Small BufferSize, to exercize the buffer management code.
   TestMultiWriterQueueMT<
       MultiWriterQueue<int, 10, MultiWriterQueueReaderLocking_None>>(
       1, 0, 2 * 1024 * 1024, "MultiWriterQueue<int, 10, Locking_None>");
   TestMultiWriterQueueMT<
       MultiWriterQueue<int, 10, MultiWriterQueueReaderLocking_None>>(
       1, 1, 2 * 1024 * 1024, "MultiWriterQueue<int, 10, Locking_None>");
   TestMultiWriterQueueMT<
@@ -209,17 +211,18 @@ TEST(MultiWriterQueue, MultiWriterSingle
 
   // DEBUG-mode thread-safety checks should make the following (multi-reader
   // with no locking) crash; uncomment to verify.
   // TestMultiWriterQueueMT<
   //   MultiWriterQueue<int, MultiWriterQueueDefaultBufferSize,
   //   MultiWriterQueueReaderLocking_None>>(64, 2, 2*1024*1024);
 }
 
-TEST(MultiWriterQueue, MultiWriterMultiReader) {
+TEST(MultiWriterQueue, MultiWriterMultiReader)
+{
   static_assert(
       mozilla::IsSame<MultiWriterQueue<int, 10>,
                       MultiWriterQueue<
                           int, 10, MultiWriterQueueReaderLocking_Mutex>>::value,
       "MultiWriterQueue reader locking should use Mutex by default");
 
   // Small BufferSize, to exercize the buffer management code.
   TestMultiWriterQueueMT<
@@ -338,17 +341,18 @@ struct DequeWrapperMT : DequeWrapperMW {
         mozilla::MutexAutoLock lock(mMutex);
         i = static_cast<int>(reinterpret_cast<uintptr_t>(mDQ.Pop()));
       }
       aF(i);
     }
   }
 };
 
-TEST(MultiWriterQueue, nsDequeBenchmark) {
+TEST(MultiWriterQueue, nsDequeBenchmark)
+{
   TestMultiWriterQueueMT<DequeWrapperST>(1, 0, 2 * 1024 * 1024,
                                          "DequeWrapperST ");
 
   TestMultiWriterQueueMT<DequeWrapperAW>(1, 0, 2 * 1024 * 1024,
                                          "DequeWrapperAW ");
   TestMultiWriterQueueMT<DequeWrapperMW>(1, 0, 2 * 1024 * 1024,
                                          "DequeWrapperMW ");
   TestMultiWriterQueueMT<DequeWrapperMT>(1, 0, 2 * 1024 * 1024,
--- a/dom/media/doctor/gtest/TestRollingNumber.cpp
+++ b/dom/media/doctor/gtest/TestRollingNumber.cpp
@@ -9,17 +9,18 @@
 #include "mozilla/Assertions.h"
 #include "mozilla/TypeTraits.h"
 
 #include <cstdint>
 #include <gtest/gtest.h>
 
 using RN8 = mozilla::RollingNumber<uint8_t>;
 
-TEST(RollingNumber, Value) {
+TEST(RollingNumber, Value)
+{
   // Value type should reflect template argument.
   static_assert(mozilla::IsSame<RN8::ValueType, uint8_t>::value, "");
 
   // Default init to 0.
   const RN8 n;
   // Access through Value().
   EXPECT_EQ(0, n.Value());
 
@@ -35,17 +36,18 @@ TEST(RollingNumber, Value) {
   RN8 n42Assigned = n42;
   EXPECT_EQ(42, n42Assigned.Value());
 
   // Assignment.
   n42 = n;
   EXPECT_EQ(0, n42.Value());
 }
 
-TEST(RollingNumber, Operations) {
+TEST(RollingNumber, Operations)
+{
   RN8 n;
   EXPECT_EQ(0, n.Value());
 
   RN8 nPreInc = ++n;
   EXPECT_EQ(1, n.Value());
   EXPECT_EQ(1, nPreInc.Value());
 
   RN8 nPostInc = n++;
@@ -85,17 +87,18 @@ TEST(RollingNumber, Operations) {
   n++;
   EXPECT_EQ(0, n.Value());
   n -= 10;
   EXPECT_EQ(246, n.Value());
   n += 20;
   EXPECT_EQ(10, n.Value());
 }
 
-TEST(RollingNumber, Comparisons) {
+TEST(RollingNumber, Comparisons)
+{
   uint8_t i = 0;
   do {
     RN8 n{i};
     EXPECT_EQ(i, n.Value());
     EXPECT_TRUE(n == n);
     EXPECT_FALSE(n != n);
     EXPECT_FALSE(n < n);
     EXPECT_TRUE(n <= n);
--- a/dom/media/gtest/TestAudioBuffers.cpp
+++ b/dom/media/gtest/TestAudioBuffers.cpp
@@ -37,22 +37,23 @@ void test_for_number_of_channels(const u
   // Fill the buffer with the rest of the data
   mBuffer.WriteFrames(other.data() + 32 * channels, FRAMES - 32);
 
   // Check the buffer is now full
   ASSERT_TRUE(mBuffer.Available() == 0);
 
   for (uint32_t i = 0; i < samples; i++) {
     ASSERT_TRUE(fromCallback[i] == 1.0)
-        << "Difference at " << i << " (" << fromCallback[i] << " != " << 1.0
-        << ")\n";
+    << "Difference at " << i << " (" << fromCallback[i] << " != " << 1.0
+    << ")\n";
   }
 
   ASSERT_TRUE(b.Fill(other.data(), FRAMES) == 128);
   ASSERT_TRUE(b.Fill(other.data(), FRAMES) == 0);
   ASSERT_TRUE(b.Empty(mBuffer) == 0);
 }
 
-TEST(AudioBuffers, Test) {
+TEST(AudioBuffers, Test)
+{
   for (uint32_t ch = 1; ch <= 8; ++ch) {
     test_for_number_of_channels(ch);
   }
 }
--- a/dom/media/gtest/TestAudioCompactor.cpp
+++ b/dom/media/gtest/TestAudioCompactor.cpp
@@ -70,25 +70,30 @@ static void TestAudioCompactor(size_t aB
 
   MemoryFunctor memoryFunc;
   queue.LockedForEach(memoryFunc);
   size_t allocSize = memoryFunc.mSize - (callCount * sizeof(AudioData));
   size_t slop = allocSize - aBytes;
   EXPECT_LE(slop, maxSlop) << "allowed too much allocation slop";
 }
 
-TEST(Media, AudioCompactor_4000) { TestAudioCompactor(4000); }
+TEST(Media, AudioCompactor_4000)
+{ TestAudioCompactor(4000); }
 
-TEST(Media, AudioCompactor_4096) { TestAudioCompactor(4096); }
+TEST(Media, AudioCompactor_4096)
+{ TestAudioCompactor(4096); }
 
-TEST(Media, AudioCompactor_5000) { TestAudioCompactor(5000); }
+TEST(Media, AudioCompactor_5000)
+{ TestAudioCompactor(5000); }
 
-TEST(Media, AudioCompactor_5256) { TestAudioCompactor(5256); }
+TEST(Media, AudioCompactor_5256)
+{ TestAudioCompactor(5256); }
 
-TEST(Media, AudioCompactor_NativeCopy) {
+TEST(Media, AudioCompactor_NativeCopy)
+{
   const uint32_t channels = 2;
   const size_t srcBytes = 32;
   const uint32_t srcSamples = srcBytes / sizeof(AudioDataValue);
   const uint32_t srcFrames = srcSamples / channels;
   uint8_t src[srcBytes];
 
   for (uint32_t i = 0; i < srcBytes; ++i) {
     src[i] = i;
--- a/dom/media/gtest/TestAudioDeviceEnumerator.cpp
+++ b/dom/media/gtest/TestAudioDeviceEnumerator.cpp
@@ -477,17 +477,18 @@ void AddDevices(MockCubeb* mock, uint32_
     if (i == device_count - 1) {
       device.preferred = CUBEB_DEVICE_PREF_ALL;
     }
     mock->AddDevice(device);
   }
 }
 
 #ifndef ANDROID
-TEST(CubebDeviceEnumerator, EnumerateSimple) {
+TEST(CubebDeviceEnumerator, EnumerateSimple)
+{
   // It looks like we're leaking this object, but in fact it will be freed by
   // gecko sometime later: `cubeb_destroy` is called when layout statics are
   // shutdown and we cast back to a MockCubeb* and call the dtor.
   MockCubeb* mock = new MockCubeb();
   mozilla::CubebUtils::ForceSetCubebContext(mock->AsCubebContext());
 
   // We want to test whether CubebDeviceEnumerator works with and without a
   // backend that can notify of a device collection change via callback.
@@ -513,17 +514,18 @@ TEST(CubebDeviceEnumerator, EnumerateSim
       TestEnumeration(mock, device_count, op, deviceType);
     }
   }
   // Shutdown to clean up the last `supports` effect
   CubebDeviceEnumerator::Shutdown();
 }
 
 #else  // building for Android, which has no device enumeration support
-TEST(CubebDeviceEnumerator, EnumerateAndroid) {
+TEST(CubebDeviceEnumerator, EnumerateAndroid)
+{
   MockCubeb* mock = new MockCubeb();
   mozilla::CubebUtils::ForceSetCubebContext(mock->AsCubebContext());
 
   RefPtr<CubebDeviceEnumerator> enumerator =
       CubebDeviceEnumerator::GetInstance();
 
   nsTArray<RefPtr<AudioDeviceInfo>> inputDevices;
   enumerator->EnumerateAudioInputDevices(inputDevices);
@@ -542,17 +544,18 @@ TEST(CubebDeviceEnumerator, EnumerateAnd
   EXPECT_EQ(outputDevices[0]->MaxChannels(), 2u) << "With stereo channels.";
   EXPECT_EQ(outputDevices[0]->DeviceID(), nullptr)
       << "It's always the default output device.";
   EXPECT_TRUE(outputDevices[0]->Preferred())
       << "it's always the prefered output device.";
 }
 #endif
 
-TEST(CubebDeviceEnumerator, ForceNullCubebContext) {
+TEST(CubebDeviceEnumerator, ForceNullCubebContext)
+{
   mozilla::CubebUtils::ForceSetCubebContext(nullptr);
   RefPtr<CubebDeviceEnumerator> enumerator =
       CubebDeviceEnumerator::GetInstance();
 
   nsTArray<RefPtr<AudioDeviceInfo>> inputDevices;
   enumerator->EnumerateAudioInputDevices(inputDevices);
   EXPECT_EQ(inputDevices.Length(), 0u)
       << "Enumeration must fail, input device list must be empty.";
@@ -561,17 +564,18 @@ TEST(CubebDeviceEnumerator, ForceNullCub
   enumerator->EnumerateAudioOutputDevices(outputDevices);
   EXPECT_EQ(outputDevices.Length(), 0u)
       << "Enumeration must fail, output device list must be empty.";
 
   // Shutdown to clean up the null context effect
   CubebDeviceEnumerator::Shutdown();
 }
 
-TEST(CubebDeviceEnumerator, DeviceInfoFromId) {
+TEST(CubebDeviceEnumerator, DeviceInfoFromId)
+{
   MockCubeb* mock = new MockCubeb();
   mozilla::CubebUtils::ForceSetCubebContext(mock->AsCubebContext());
 
   uint32_t device_count = 4;
   cubeb_device_type deviceTypes[2] = {CUBEB_DEVICE_TYPE_INPUT,
                                       CUBEB_DEVICE_TYPE_OUTPUT};
 
   bool supportsDeviceChangeCallback[2] = {true, false};
@@ -599,17 +603,18 @@ TEST(CubebDeviceEnumerator, DeviceInfoFr
       EXPECT_TRUE(devInfo) << "newly added device must exist";
       EXPECT_EQ(devInfo->DeviceID(), id_5) << "verify the device";
     }
   }
   // Shutdown for `supports` to take effect
   CubebDeviceEnumerator::Shutdown();
 }
 
-TEST(CubebDeviceEnumerator, DeviceInfoFromName) {
+TEST(CubebDeviceEnumerator, DeviceInfoFromName)
+{
   MockCubeb* mock = new MockCubeb();
   mozilla::CubebUtils::ForceSetCubebContext(mock->AsCubebContext());
 
   cubeb_device_type deviceTypes[2] = {CUBEB_DEVICE_TYPE_INPUT,
                                       CUBEB_DEVICE_TYPE_OUTPUT};
 
   bool supportsDeviceChangeCallback[2] = {true, false};
   for (bool supports : supportsDeviceChangeCallback) {
--- a/dom/media/gtest/TestAudioMixer.cpp
+++ b/dom/media/gtest/TestAudioMixer.cpp
@@ -65,17 +65,18 @@ short GetHighValue<short>() {
 void FillBuffer(AudioDataValue* aBuffer, uint32_t aLength,
                 AudioDataValue aValue) {
   AudioDataValue* end = aBuffer + aLength;
   while (aBuffer != end) {
     *aBuffer++ = aValue;
   }
 }
 
-TEST(AudioMixer, Test) {
+TEST(AudioMixer, Test)
+{
   const uint32_t CHANNEL_LENGTH = 256;
   const uint32_t AUDIO_RATE = 44100;
   MixerConsumer consumer;
   AudioDataValue a[CHANNEL_LENGTH * 2];
   AudioDataValue b[CHANNEL_LENGTH * 2];
   FillBuffer(a, CHANNEL_LENGTH, GetLowValue<AudioDataValue>());
   FillBuffer(a + CHANNEL_LENGTH, CHANNEL_LENGTH,
              GetHighValue<AudioDataValue>());
--- a/dom/media/gtest/TestAudioPacketizer.cpp
+++ b/dom/media/gtest/TestAudioPacketizer.cpp
@@ -29,31 +29,32 @@ int16_t Sequence(int16_t* aBuffer, uint3
   }
   return aStart + i;
 }
 
 void IsSequence(std::unique_ptr<int16_t[]> aBuffer, uint32_t aSize,
                 uint32_t aStart = 0) {
   for (uint32_t i = 0; i < aSize; i++) {
     ASSERT_TRUE(aBuffer[i] == static_cast<int64_t>(aStart + i))
-        << "Buffer is not a sequence at offset " << i << std::endl;
+    << "Buffer is not a sequence at offset " << i << std::endl;
   }
   // Buffer is a sequence.
 }
 
 void Zero(std::unique_ptr<int16_t[]> aBuffer, uint32_t aSize) {
   for (uint32_t i = 0; i < aSize; i++) {
     ASSERT_TRUE(aBuffer[i] == 0)
-        << "Buffer is not null at offset " << i << std::endl;
+    << "Buffer is not null at offset " << i << std::endl;
   }
 }
 
 double sine(uint32_t aPhase) { return sin(aPhase * 2 * M_PI * 440 / 44100); }
 
-TEST(AudioPacketizer, Test) {
+TEST(AudioPacketizer, Test)
+{
   for (int16_t channels = 1; channels < 2; channels++) {
     // Test that the packetizer returns zero on underrun
     {
       AudioPacketizer<int16_t, int16_t> ap(441, channels);
       for (int16_t i = 0; i < 10; i++) {
         std::unique_ptr<int16_t[]> out(ap.Output());
         Zero(std::move(out), 441);
       }
--- a/dom/media/gtest/TestAudioSegment.cpp
+++ b/dom/media/gtest/TestAudioSegment.cpp
@@ -219,17 +219,18 @@ void TestDownmixStereo() {
     ASSERT_TRUE(output[0][i] == GetSilentValue<T>());
     ASSERT_TRUE(output[0][i] == GetSilentValue<T>());
   }
 
   delete[] output[0];
   delete[] output;
 }
 
-TEST(AudioSegment, Test) {
+TEST(AudioSegment, Test)
+{
   TestInterleaveAndConvert<float, float>();
   TestInterleaveAndConvert<float, int16_t>();
   TestInterleaveAndConvert<int16_t, float>();
   TestInterleaveAndConvert<int16_t, int16_t>();
   TestDeinterleaveAndConvert<float, float>();
   TestDeinterleaveAndConvert<float, int16_t>();
   TestDeinterleaveAndConvert<int16_t, float>();
   TestDeinterleaveAndConvert<int16_t, int16_t>();
--- a/dom/media/gtest/TestAudioTrackEncoder.cpp
+++ b/dom/media/gtest/TestAudioTrackEncoder.cpp
@@ -54,17 +54,18 @@ class TestOpusTrackEncoder : public Opus
   }
 };
 
 static bool TestOpusInit(int aChannels, int aSamplingRate) {
   TestOpusTrackEncoder encoder;
   return encoder.TestOpusRawCreation(aChannels, aSamplingRate);
 }
 
-TEST(OpusAudioTrackEncoder, InitRaw) {
+TEST(OpusAudioTrackEncoder, InitRaw)
+{
   // Expect false with 0 or negative channels of input signal.
   EXPECT_FALSE(TestOpusInit(0, 16000));
   EXPECT_FALSE(TestOpusInit(-1, 16000));
 
   // The Opus format supports up to 8 channels, and supports multitrack audio up
   // to 255 channels, but the current implementation supports only mono and
   // stereo, and downmixes any more than that.
   // Expect false with channels of input signal exceed the max supported number.
@@ -84,17 +85,18 @@ TEST(OpusAudioTrackEncoder, InitRaw) {
   EXPECT_FALSE(TestOpusInit(2, 4000));
   EXPECT_FALSE(TestOpusInit(2, 7999));
   EXPECT_TRUE(TestOpusInit(2, 8000));
   EXPECT_TRUE(TestOpusInit(2, 192000));
   EXPECT_FALSE(TestOpusInit(2, 192001));
   EXPECT_FALSE(TestOpusInit(2, 200000));
 }
 
-TEST(OpusAudioTrackEncoder, Init) {
+TEST(OpusAudioTrackEncoder, Init)
+{
   {
     // The encoder does not normally recieve enough info from null data to
     // init. However, multiple attempts to do so, with sufficiently long
     // duration segments, should result in a best effort attempt. The first
     // attempt should never do this though, even if the duration is long:
     OpusTrackEncoder encoder(48000);
     AudioSegment segment;
     segment.AppendNullData(48000 * 100);
@@ -170,46 +172,49 @@ TEST(OpusAudioTrackEncoder, Init) {
 }
 
 static int TestOpusResampler(int aChannels, int aSamplingRate) {
   TestOpusTrackEncoder encoder;
   EXPECT_TRUE(encoder.TestOpusRawCreation(aChannels, aSamplingRate));
   return encoder.TestGetOutputSampleRate();
 }
 
-TEST(OpusAudioTrackEncoder, Resample) {
+TEST(OpusAudioTrackEncoder, Resample)
+{
   // Sampling rates of data to be fed to Opus encoder, should remain unchanged
   // if it is one of Opus supported rates (8000, 12000, 16000, 24000 and 48000
   // (kHz)) at initialization.
   EXPECT_TRUE(TestOpusResampler(1, 8000) == 8000);
   EXPECT_TRUE(TestOpusResampler(1, 12000) == 12000);
   EXPECT_TRUE(TestOpusResampler(1, 16000) == 16000);
   EXPECT_TRUE(TestOpusResampler(1, 24000) == 24000);
   EXPECT_TRUE(TestOpusResampler(1, 48000) == 48000);
 
   // Otherwise, it should be resampled to 48kHz by resampler.
   EXPECT_TRUE(TestOpusResampler(1, 9600) == 48000);
   EXPECT_TRUE(TestOpusResampler(1, 44100) == 48000);
 }
 
-TEST(OpusAudioTrackEncoder, FetchMetadata) {
+TEST(OpusAudioTrackEncoder, FetchMetadata)
+{
   const int32_t channels = 1;
   const int32_t sampleRate = 44100;
   TestOpusTrackEncoder encoder;
   EXPECT_TRUE(encoder.TestOpusRawCreation(channels, sampleRate));
 
   RefPtr<TrackMetadataBase> metadata = encoder.GetMetadata();
   ASSERT_EQ(TrackMetadataBase::METADATA_OPUS, metadata->GetKind());
 
   RefPtr<OpusMetadata> opusMeta = static_cast<OpusMetadata*>(metadata.get());
   EXPECT_EQ(channels, opusMeta->mChannels);
   EXPECT_EQ(sampleRate, opusMeta->mSamplingFrequency);
 }
 
-TEST(OpusAudioTrackEncoder, FrameEncode) {
+TEST(OpusAudioTrackEncoder, FrameEncode)
+{
   const int32_t channels = 1;
   const int32_t sampleRate = 44100;
   TestOpusTrackEncoder encoder;
   EXPECT_TRUE(encoder.TestOpusRawCreation(channels, sampleRate));
 
   // Generate five seconds of raw audio data.
   AudioGenerator generator(channels, sampleRate);
   AudioSegment segment;
--- a/dom/media/gtest/TestBitWriter.cpp
+++ b/dom/media/gtest/TestBitWriter.cpp
@@ -5,17 +5,18 @@
 
 #include "gtest/gtest.h"
 #include "BitReader.h"
 #include "BitWriter.h"
 #include "H264.h"
 
 using namespace mozilla;
 
-TEST(BitWriter, BitWriter) {
+TEST(BitWriter, BitWriter)
+{
   RefPtr<MediaByteBuffer> test = new MediaByteBuffer();
   BitWriter b(test);
   b.WriteBit(false);
   b.WriteBits(~1ULL, 1);  // ensure that extra bits don't modify byte buffer.
   b.WriteBits(3, 1);
   b.WriteUE(1280 / 16 - 1);
   b.WriteUE(720 / 16 - 1);
   b.WriteUE(1280);
@@ -44,17 +45,18 @@ TEST(BitWriter, BitWriter) {
   EXPECT_EQ(c.ReadBit(), true);
   EXPECT_EQ(c.ReadBits(8), 7u);
   EXPECT_EQ(c.ReadU32(), 16356u);
   EXPECT_EQ(c.ReadU64(), 116356u);
   EXPECT_EQ(c.ReadBits(16), 0xfffeu);
   EXPECT_EQ(length, BitReader::GetBitLength(test));
 }
 
-TEST(BitWriter, SPS) {
+TEST(BitWriter, SPS)
+{
   uint8_t sps_pps[] = {0x01, 0x4d, 0x40, 0x0c, 0xff, 0xe1, 0x00, 0x1b, 0x67,
                        0x4d, 0x40, 0x0c, 0xe8, 0x80, 0x80, 0x9d, 0x80, 0xb5,
                        0x01, 0x01, 0x01, 0x40, 0x00, 0x00, 0x03, 0x00, 0x40,
                        0x00, 0x00, 0x0f, 0x03, 0xc5, 0x0a, 0x44, 0x80, 0x01,
                        0x00, 0x04, 0x68, 0xeb, 0xef, 0x20};
 
   RefPtr<MediaByteBuffer> extraData = new MediaByteBuffer();
   extraData->AppendElements(sps_pps, sizeof(sps_pps));
--- a/dom/media/gtest/TestBlankVideoDataCreator.cpp
+++ b/dom/media/gtest/TestBlankVideoDataCreator.cpp
@@ -3,25 +3,27 @@
  * 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 "gtest/gtest.h"
 #include "BlankDecoderModule.h"
 
 using namespace mozilla;
 
-TEST(BlankVideoDataCreator, ShouldNotOverflow) {
+TEST(BlankVideoDataCreator, ShouldNotOverflow)
+{
   RefPtr<MediaRawData> mrd = new MediaRawData();
   const uint32_t width = 1;
   const uint32_t height = 1;
   BlankVideoDataCreator creater(width, height, nullptr);
   RefPtr<MediaData> data = creater.Create(mrd);
   EXPECT_NE(data.get(), nullptr);
 }
 
-TEST(BlankVideoDataCreator, ShouldOverflow) {
+TEST(BlankVideoDataCreator, ShouldOverflow)
+{
   RefPtr<MediaRawData> mrd = new MediaRawData();
   const uint32_t width = UINT_MAX;
   const uint32_t height = UINT_MAX;
   BlankVideoDataCreator creater(width, height, nullptr);
   RefPtr<MediaData> data = creater.Create(mrd);
   EXPECT_EQ(data.get(), nullptr);
 }
--- a/dom/media/gtest/TestBufferReader.cpp
+++ b/dom/media/gtest/TestBufferReader.cpp
@@ -1,17 +1,18 @@
 /* -*- 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 "gtest/gtest.h"
 #include "BufferReader.h"
 
-TEST(BufferReader, ReaderCursor) {
+TEST(BufferReader, ReaderCursor)
+{
   // Allocate a buffer and create a BufferReader.
   const size_t BUFFER_SIZE = 10;
   uint8_t buffer[BUFFER_SIZE] = {0};
 
   const uint8_t* const HEAD = reinterpret_cast<uint8_t*>(buffer);
   const uint8_t* const TAIL = HEAD + BUFFER_SIZE;
 
   BufferReader reader(HEAD, BUFFER_SIZE);
--- a/dom/media/gtest/TestCDMStorage.cpp
+++ b/dom/media/gtest/TestCDMStorage.cpp
@@ -1025,59 +1025,69 @@ class CDMStorageTest {
    private:
     // Warning: Weak ref.
     CDMStorageTest* mRunner;
   };
 
   UniquePtr<CallbackProxy> mCallback;
 };  // class CDMStorageTest
 
-TEST(GeckoMediaPlugins, CDMStorageGetNodeId) {
+TEST(GeckoMediaPlugins, CDMStorageGetNodeId)
+{
   RefPtr<CDMStorageTest> runner = new CDMStorageTest();
   runner->DoTest(&CDMStorageTest::TestGetNodeId);
 }
 
-TEST(GeckoMediaPlugins, CDMStorageBasic) {
+TEST(GeckoMediaPlugins, CDMStorageBasic)
+{
   RefPtr<CDMStorageTest> runner = new CDMStorageTest();
   runner->DoTest(&CDMStorageTest::TestBasicStorage);
 }
 
-TEST(GeckoMediaPlugins, CDMStorageForgetThisSite) {
+TEST(GeckoMediaPlugins, CDMStorageForgetThisSite)
+{
   RefPtr<CDMStorageTest> runner = new CDMStorageTest();
   runner->DoTest(&CDMStorageTest::TestForgetThisSite);
 }
 
-TEST(GeckoMediaPlugins, CDMStorageClearRecentHistory1) {
+TEST(GeckoMediaPlugins, CDMStorageClearRecentHistory1)
+{
   RefPtr<CDMStorageTest> runner = new CDMStorageTest();
   runner->DoTest(&CDMStorageTest::TestClearRecentHistory1);
 }
 
-TEST(GeckoMediaPlugins, CDMStorageClearRecentHistory2) {
+TEST(GeckoMediaPlugins, CDMStorageClearRecentHistory2)
+{
   RefPtr<CDMStorageTest> runner = new CDMStorageTest();
   runner->DoTest(&CDMStorageTest::TestClearRecentHistory2);
 }
 
-TEST(GeckoMediaPlugins, CDMStorageClearRecentHistory3) {
+TEST(GeckoMediaPlugins, CDMStorageClearRecentHistory3)
+{
   RefPtr<CDMStorageTest> runner = new CDMStorageTest();
   runner->DoTest(&CDMStorageTest::TestClearRecentHistory3);
 }
 
-TEST(GeckoMediaPlugins, CDMStorageCrossOrigin) {
+TEST(GeckoMediaPlugins, CDMStorageCrossOrigin)
+{
   RefPtr<CDMStorageTest> runner = new CDMStorageTest();
   runner->DoTest(&CDMStorageTest::TestCrossOriginStorage);
 }
 
-TEST(GeckoMediaPlugins, CDMStoragePrivateBrowsing) {
+TEST(GeckoMediaPlugins, CDMStoragePrivateBrowsing)
+{
   RefPtr<CDMStorageTest> runner = new CDMStorageTest();
   runner->DoTest(&CDMStorageTest::TestPBStorage);
 }
 
 #if defined(XP_WIN)
-TEST(GeckoMediaPlugins, GMPOutputProtection) {
+TEST(GeckoMediaPlugins, GMPOutputProtection)
+{
   RefPtr<CDMStorageTest> runner = new CDMStorageTest();
   runner->DoTest(&CDMStorageTest::TestOutputProtection);
 }
 #endif
 
-TEST(GeckoMediaPlugins, CDMStorageLongRecordNames) {
+TEST(GeckoMediaPlugins, CDMStorageLongRecordNames)
+{
   RefPtr<CDMStorageTest> runner = new CDMStorageTest();
   runner->DoTest(&CDMStorageTest::TestLongRecordNames);
 }
--- a/dom/media/gtest/TestDataMutex.cpp
+++ b/dom/media/gtest/TestDataMutex.cpp
@@ -9,17 +9,18 @@
 
 using mozilla::DataMutex;
 
 struct A {
   void Set(int a) { mValue = a; }
   int mValue;
 };
 
-TEST(DataMutex, Basic) {
+TEST(DataMutex, Basic)
+{
   {
     DataMutex<uint32_t> i(1, "1");
     auto x = i.Lock();
     *x = 4;
     ASSERT_EQ(*x, 4u);
   }
   {
     DataMutex<A> a({4}, "StructA");
--- a/dom/media/gtest/TestGMPCrossOrigin.cpp
+++ b/dom/media/gtest/TestGMPCrossOrigin.cpp
@@ -193,22 +193,24 @@ void GMPTestRunner::DoTest(
 
   GMPTestMonitor monitor;
   thread->Dispatch(NewRunnableMethod<GMPTestMonitor&>(
                        "GMPTestRunner::DoTest", this, aTestMethod, monitor),
                    NS_DISPATCH_NORMAL);
   monitor.AwaitFinished();
 }
 
-TEST(GeckoMediaPlugins, GMPTestCodec) {
+TEST(GeckoMediaPlugins, GMPTestCodec)
+{
   RefPtr<GMPTestRunner> runner = new GMPTestRunner();
   runner->DoTest(&GMPTestRunner::RunTestGMPTestCodec1);
   runner->DoTest(&GMPTestRunner::RunTestGMPTestCodec2);
   runner->DoTest(&GMPTestRunner::RunTestGMPTestCodec3);
 }
 
-TEST(GeckoMediaPlugins, GMPCrossOrigin) {
+TEST(GeckoMediaPlugins, GMPCrossOrigin)
+{
   RefPtr<GMPTestRunner> runner = new GMPTestRunner();
   runner->DoTest(&GMPTestRunner::RunTestGMPCrossOrigin1);
   runner->DoTest(&GMPTestRunner::RunTestGMPCrossOrigin2);
   runner->DoTest(&GMPTestRunner::RunTestGMPCrossOrigin3);
   runner->DoTest(&GMPTestRunner::RunTestGMPCrossOrigin4);
 }
--- a/dom/media/gtest/TestGMPRemoveAndDelete.cpp
+++ b/dom/media/gtest/TestGMPRemoveAndDelete.cpp
@@ -100,40 +100,43 @@ class GMPRemoveTest : public nsIObserver
   GMPVideoDecoderProxy* mDecoder;
   GMPVideoHost* mHost;
   GMPErr mDecodeResult;
 };
 
 /*
  * Simple test that the plugin is deleted when forcibly removed and deleted.
  */
-TEST(GeckoMediaPlugins, RemoveAndDeleteForcedSimple) {
+TEST(GeckoMediaPlugins, RemoveAndDeleteForcedSimple)
+{
   RefPtr<GMPRemoveTest> test(new GMPRemoveTest());
 
   test->Setup();
   test->DeletePluginDirectory(false /* force immediate */);
   test->Wait();
 }
 
 /*
  * Simple test that the plugin is deleted when deferred deletion is allowed.
  */
-TEST(GeckoMediaPlugins, RemoveAndDeleteDeferredSimple) {
+TEST(GeckoMediaPlugins, RemoveAndDeleteDeferredSimple)
+{
   RefPtr<GMPRemoveTest> test(new GMPRemoveTest());
 
   test->Setup();
   test->DeletePluginDirectory(true /* can defer */);
   test->Wait();
 }
 
 /*
  * Test that the plugin is unavailable immediately after a forced
  * RemoveAndDelete, and that the plugin is deleted afterwards.
  */
-TEST(GeckoMediaPlugins, RemoveAndDeleteForcedInUse) {
+TEST(GeckoMediaPlugins, RemoveAndDeleteForcedInUse)
+{
   RefPtr<GMPRemoveTest> test(new GMPRemoveTest());
 
   test->Setup();
   EXPECT_TRUE(test->CreateVideoDecoder(NS_LITERAL_CSTRING("thisOrigin")));
 
   // Test that we can decode a frame.
   GMPErr err = test->Decode();
   EXPECT_EQ(err, GMPNoErr);
@@ -147,17 +150,18 @@ TEST(GeckoMediaPlugins, RemoveAndDeleteF
   // Test that we were notified of the plugin's destruction.
   EXPECT_TRUE(test->IsTerminated());
 }
 
 /*
  * Test that the plugin is still usable after a deferred RemoveAndDelete, and
  * that the plugin is deleted afterwards.
  */
-TEST(GeckoMediaPlugins, RemoveAndDeleteDeferredInUse) {
+TEST(GeckoMediaPlugins, RemoveAndDeleteDeferredInUse)
+{
   RefPtr<GMPRemoveTest> test(new GMPRemoveTest());
 
   test->Setup();
   EXPECT_TRUE(test->CreateVideoDecoder(NS_LITERAL_CSTRING("thisOrigin")));
 
   // Make sure decoding works before we do anything.
   GMPErr err = test->Decode();
   EXPECT_EQ(err, GMPNoErr);
--- a/dom/media/gtest/TestGMPUtils.cpp
+++ b/dom/media/gtest/TestGMPUtils.cpp
@@ -23,17 +23,18 @@ void TestSplitAt(const char* aInput, con
       << "Should get expected number of tokens";
   for (size_t i = 0; i < tokens.Length(); i++) {
     EXPECT_TRUE(tokens[i].EqualsASCII(aExpectedTokens[i]))
         << "Tokenize fail; expected=" << aExpectedTokens[i]
         << " got=" << tokens[i].BeginReading();
   }
 }
 
-TEST(GeckoMediaPlugins, TestSplitAt) {
+TEST(GeckoMediaPlugins, TestSplitAt)
+{
   {
     const char* input = "1,2,3,4";
     const char* delims = ",";
     const char* tokens[] = {"1", "2", "3", "4"};
     TestSplitAt(input, delims, MOZ_ARRAY_LENGTH(tokens), tokens);
   }
 
   {
@@ -50,17 +51,18 @@ TEST(GeckoMediaPlugins, TestSplitAt) {
         "line3\n"        // Unix
         "line4";
     const char* delims = "\r\n";
     const char* tokens[] = {"line1", "line2", "line3", "line4"};
     TestSplitAt(input, delims, MOZ_ARRAY_LENGTH(tokens), tokens);
   }
 }
 
-TEST(GeckoMediaPlugins, ToHexString) {
+TEST(GeckoMediaPlugins, ToHexString)
+{
   struct Test {
     nsTArray<uint8_t> bytes;
     string hex;
   };
 
   static const Test tests[] = {
       {{0x00, 0x00}, "0000"},
       {{0xff, 0xff}, "ffff"},
--- a/dom/media/gtest/TestGroupId.cpp
+++ b/dom/media/gtest/TestGroupId.cpp
@@ -85,17 +85,18 @@ RefPtr<MediaDevice> MakeSpeakerDevice(co
   return MakeRefPtr<MediaDevice>(MakeAudioDeviceInfo(aName),
                                  NS_LITERAL_STRING("ID"), aGroupId,
                                  NS_LITERAL_STRING("RawID"));
 }
 
 /* Verify that when an audio input device name contains the video input device
  * name the video device group id is updated to become equal to the audio
  * device group id. */
-TEST(TestGroupId, MatchInput_PartOfName) {
+TEST(TestGroupId, MatchInput_PartOfName)
+{
   MediaManager::MediaDeviceSet devices;
 
   devices.AppendElement(
       MakeCameraDevice(NS_LITERAL_STRING("Vendor Model"),
                        NS_LITERAL_STRING("Cam-Model-GroupId")));
 
   devices.AppendElement(
       MakeMicDevice(NS_LITERAL_STRING("Vendor Model Analog Stereo"),
@@ -105,17 +106,18 @@ TEST(TestGroupId, MatchInput_PartOfName)
 
   EXPECT_EQ(devices[0]->mGroupID, devices[1]->mGroupID)
       << "Video group id is the same as audio input group id.";
 }
 
 /* Verify that when an audio input device name is the same as the video input
  * device name the video device group id is updated to become equal to the audio
  * device group id. */
-TEST(TestGroupId, MatchInput_FullName) {
+TEST(TestGroupId, MatchInput_FullName)
+{
   MediaManager::MediaDeviceSet devices;
 
   devices.AppendElement(
       MakeCameraDevice(NS_LITERAL_STRING("Vendor Model"),
                        NS_LITERAL_STRING("Cam-Model-GroupId")));
 
   devices.AppendElement(MakeMicDevice(NS_LITERAL_STRING("Vendor Model"),
                                       NS_LITERAL_STRING("Mic-Model-GroupId")));
@@ -123,17 +125,18 @@ TEST(TestGroupId, MatchInput_FullName) {
   MediaManager::GuessVideoDeviceGroupIDs(devices);
 
   EXPECT_EQ(devices[0]->mGroupID, devices[1]->mGroupID)
       << "Video group id is the same as audio input group id.";
 }
 
 /* Verify that when an audio input device name does not contain the video input
  * device name the video device group id does not change. */
-TEST(TestGroupId, NoMatchInput) {
+TEST(TestGroupId, NoMatchInput)
+{
   MediaManager::MediaDeviceSet devices;
 
   nsString Cam_Model_GroupId = NS_LITERAL_STRING("Cam-Model-GroupId");
   devices.AppendElement(
       MakeCameraDevice(NS_LITERAL_STRING("Vendor Model"), Cam_Model_GroupId));
 
   devices.AppendElement(MakeMicDevice(NS_LITERAL_STRING("Model Analog Stereo"),
                                       NS_LITERAL_STRING("Mic-Model-GroupId")));
@@ -144,17 +147,18 @@ TEST(TestGroupId, NoMatchInput) {
       << "Video group id has not been updated.";
   EXPECT_NE(devices[0]->mGroupID, devices[1]->mGroupID)
       << "Video group id is different than audio input group id.";
 }
 
 /* Verify that when more that one audio input and more than one audio output
  * device name contain the video input device name the video device group id
  * does not change. */
-TEST(TestGroupId, NoMatch_TwoIdenticalDevices) {
+TEST(TestGroupId, NoMatch_TwoIdenticalDevices)
+{
   MediaManager::MediaDeviceSet devices;
 
   nsString Cam_Model_GroupId = NS_LITERAL_STRING("Cam-Model-GroupId");
   devices.AppendElement(
       MakeCameraDevice(NS_LITERAL_STRING("Vendor Model"), Cam_Model_GroupId));
 
   devices.AppendElement(
       MakeMicDevice(NS_LITERAL_STRING("Vendor Model Analog Stereo"),
@@ -179,17 +183,18 @@ TEST(TestGroupId, NoMatch_TwoIdenticalDe
   EXPECT_NE(devices[0]->mGroupID, devices[3]->mGroupID)
       << "Video group id is different than audio output group id.";
 }
 
 /* Verify that when more that one audio input device name contain the video
  * input device name the video device group id is not updated by audio input
  * device group id but it continues looking at audio output devices where it
  * finds a match so video input group id is updated by audio output group id. */
-TEST(TestGroupId, Match_TwoIdenticalInputsMatchOutput) {
+TEST(TestGroupId, Match_TwoIdenticalInputsMatchOutput)
+{
   MediaManager::MediaDeviceSet devices;
 
   nsString Cam_Model_GroupId = NS_LITERAL_STRING("Cam-Model-GroupId");
   devices.AppendElement(
       MakeCameraDevice(NS_LITERAL_STRING("Vendor Model"), Cam_Model_GroupId));
 
   devices.AppendElement(
       MakeMicDevice(NS_LITERAL_STRING("Vendor Model Analog Stereo"),
@@ -206,17 +211,18 @@ TEST(TestGroupId, Match_TwoIdenticalInpu
 
   EXPECT_EQ(devices[0]->mGroupID, devices[3]->mGroupID)
       << "Video group id is the same as audio output group id.";
 }
 
 /* Verify that when more that one audio input and more than one audio output
  * device names contain the video input device name the video device group id
  * does not change. */
-TEST(TestGroupId, NoMatch_ThreeIdenticalDevices) {
+TEST(TestGroupId, NoMatch_ThreeIdenticalDevices)
+{
   MediaManager::MediaDeviceSet devices;
 
   nsString Cam_Model_GroupId = NS_LITERAL_STRING("Cam-Model-GroupId");
   devices.AppendElement(
       MakeCameraDevice(NS_LITERAL_STRING("Vendor Model"), Cam_Model_GroupId));
 
   devices.AppendElement(
       MakeMicDevice(NS_LITERAL_STRING("Vendor Model Analog Stereo"),
@@ -246,17 +252,18 @@ TEST(TestGroupId, NoMatch_ThreeIdentical
       << "Video group id is different than audio input group id.";
   EXPECT_NE(devices[0]->mGroupID, devices[4]->mGroupID)
       << "Video group id is different than audio output group id.";
 }
 
 /* Verify that when an audio output device name contains the video input device
  * name the video device group id is updated to become equal to the audio
  * device group id. */
-TEST(TestGroupId, MatchOutput) {
+TEST(TestGroupId, MatchOutput)
+{
   MediaManager::MediaDeviceSet devices;
 
   devices.AppendElement(
       MakeCameraDevice(NS_LITERAL_STRING("Vendor Model"),
                        NS_LITERAL_STRING("Cam-Model-GroupId")));
 
   devices.AppendElement(MakeMicDevice(NS_LITERAL_STRING("Mic Analog Stereo"),
                                       NS_LITERAL_STRING("Mic-Model-GroupId")));
@@ -269,17 +276,18 @@ TEST(TestGroupId, MatchOutput) {
 
   EXPECT_EQ(devices[0]->mGroupID, devices[2]->mGroupID)
       << "Video group id is the same as audio output group id.";
 }
 
 /* Verify that when an audio input device name is the same as audio output
  * device and video input device name the video device group id is updated to
  * become equal to the audio input device group id. */
-TEST(TestGroupId, InputOutputSameName) {
+TEST(TestGroupId, InputOutputSameName)
+{
   MediaManager::MediaDeviceSet devices;
 
   devices.AppendElement(
       MakeCameraDevice(NS_LITERAL_STRING("Vendor Model"),
                        NS_LITERAL_STRING("Cam-Model-GroupId")));
 
   devices.AppendElement(MakeMicDevice(NS_LITERAL_STRING("Vendor Model"),
                                       NS_LITERAL_STRING("Mic-Model-GroupId")));
@@ -292,17 +300,18 @@ TEST(TestGroupId, InputOutputSameName) {
 
   EXPECT_EQ(devices[0]->mGroupID, devices[1]->mGroupID)
       << "Video input group id is the same as audio input group id.";
 }
 
 /* Verify that when an audio input device name contains the video input device
  * and the audio input group id is an empty string, the video device group id
  * is updated to become equal to the audio device group id. */
-TEST(TestGroupId, InputEmptyGroupId) {
+TEST(TestGroupId, InputEmptyGroupId)
+{
   MediaManager::MediaDeviceSet devices;
 
   devices.AppendElement(
       MakeCameraDevice(NS_LITERAL_STRING("Vendor Model"),
                        NS_LITERAL_STRING("Cam-Model-GroupId")));
 
   devices.AppendElement(
       MakeMicDevice(NS_LITERAL_STRING("Vendor Model"), NS_LITERAL_STRING("")));
@@ -311,17 +320,18 @@ TEST(TestGroupId, InputEmptyGroupId) {
 
   EXPECT_EQ(devices[0]->mGroupID, devices[1]->mGroupID)
       << "Video input group id is the same as audio input group id.";
 }
 
 /* Verify that when an audio output device name contains the video input device
  * and the audio output group id is an empty string, the video device group id
  * is updated to become equal to the audio output device group id. */
-TEST(TestGroupId, OutputEmptyGroupId) {
+TEST(TestGroupId, OutputEmptyGroupId)
+{
   MediaManager::MediaDeviceSet devices;
 
   devices.AppendElement(
       MakeCameraDevice(NS_LITERAL_STRING("Vendor Model"),
                        NS_LITERAL_STRING("Cam-Model-GroupId")));
 
   devices.AppendElement(MakeSpeakerDevice(NS_LITERAL_STRING("Vendor Model"),
                                           NS_LITERAL_STRING("")));
--- a/dom/media/gtest/TestIntervalSet.cpp
+++ b/dom/media/gtest/TestIntervalSet.cpp
@@ -23,17 +23,18 @@ ByteInterval CreateByteInterval(int32_t 
 
 media::IntervalSet<uint8_t> CreateByteIntervalSet(int32_t aStart,
                                                   int32_t aEnd) {
   media::IntervalSet<uint8_t> test;
   test += ByteInterval(aStart, aEnd);
   return test;
 }
 
-TEST(IntervalSet, Constructors) {
+TEST(IntervalSet, Constructors)
+{
   const int32_t start = 1;
   const int32_t end = 2;
   const int32_t fuzz = 0;
 
   // Compiler exercise.
   ByteInterval test1(start, end);
   ByteInterval test2(test1);
   ByteInterval test3(start, end, fuzz);
@@ -68,17 +69,18 @@ media::TimeInterval CreateTimeInterval(i
 }
 
 media::TimeIntervals CreateTimeIntervals(int32_t aStart, int32_t aEnd) {
   media::TimeIntervals test;
   test += CreateTimeInterval(aStart, aEnd);
   return test;
 }
 
-TEST(IntervalSet, TimeIntervalsConstructors) {
+TEST(IntervalSet, TimeIntervalsConstructors)
+{
   const auto start = media::TimeUnit::FromMicroseconds(1);
   const auto end = media::TimeUnit::FromMicroseconds(2);
   const media::TimeUnit fuzz;
 
   // Compiler exercise.
   media::TimeInterval test1(start, end);
   media::TimeInterval test2(test1);
   media::TimeInterval test3(start, end, fuzz);
@@ -103,66 +105,71 @@ TEST(IntervalSet, TimeIntervalsConstruct
   (void)blah4;
   (void)blah5;
 
   media::TimeIntervals i0{media::TimeInterval(media::TimeUnit::FromSeconds(0),
                                               media::TimeUnit::FromSeconds(0))};
   EXPECT_EQ(0u, i0.Length());  // Constructing with an empty time interval.
 }
 
-TEST(IntervalSet, Length) {
+TEST(IntervalSet, Length)
+{
   IntInterval i(15, 25);
   EXPECT_EQ(10, i.Length());
 }
 
-TEST(IntervalSet, Intersects) {
+TEST(IntervalSet, Intersects)
+{
   EXPECT_TRUE(IntInterval(1, 5).Intersects(IntInterval(3, 4)));
   EXPECT_TRUE(IntInterval(1, 5).Intersects(IntInterval(3, 7)));
   EXPECT_TRUE(IntInterval(1, 5).Intersects(IntInterval(-1, 3)));
   EXPECT_TRUE(IntInterval(1, 5).Intersects(IntInterval(-1, 7)));
   EXPECT_FALSE(IntInterval(1, 5).Intersects(IntInterval(6, 7)));
   EXPECT_FALSE(IntInterval(1, 5).Intersects(IntInterval(-1, 0)));
   // End boundary is exclusive of the interval.
   EXPECT_FALSE(IntInterval(1, 5).Intersects(IntInterval(5, 7)));
   EXPECT_FALSE(IntInterval(1, 5).Intersects(IntInterval(0, 1)));
   // Empty identical interval do not intersect.
   EXPECT_FALSE(IntInterval(1, 1).Intersects(IntInterval(1, 1)));
   // Empty interval do not intersect.
   EXPECT_FALSE(IntInterval(1, 1).Intersects(IntInterval(2, 2)));
 }
 
-TEST(IntervalSet, Intersection) {
+TEST(IntervalSet, Intersection)
+{
   IntInterval i0(10, 20);
   IntInterval i1(15, 25);
   IntInterval i = i0.Intersection(i1);
   EXPECT_EQ(15, i.mStart);
   EXPECT_EQ(20, i.mEnd);
   IntInterval j0(10, 20);
   IntInterval j1(20, 25);
   IntInterval j = j0.Intersection(j1);
   EXPECT_TRUE(j.IsEmpty());
   IntInterval k0(2, 2);
   IntInterval k1(2, 2);
   IntInterval k = k0.Intersection(k1);
   EXPECT_TRUE(k.IsEmpty());
 }
 
-TEST(IntervalSet, Equals) {
+TEST(IntervalSet, Equals)
+{
   IntInterval i0(10, 20);
   IntInterval i1(10, 20);
   EXPECT_EQ(i0, i1);
 
   IntInterval i2(5, 20);
   EXPECT_NE(i0, i2);
 
   IntInterval i3(10, 15);
   EXPECT_NE(i0, i2);
 }
 
-TEST(IntervalSet, IntersectionIntervalSet) {
+TEST(IntervalSet, IntersectionIntervalSet)
+{
   IntIntervals i0;
   i0 += IntInterval(5, 10);
   i0 += IntInterval(20, 25);
   i0 += IntInterval(40, 60);
 
   IntIntervals i1;
   i1.Add(IntInterval(7, 15));
   i1.Add(IntInterval(16, 27));
@@ -227,60 +234,64 @@ static void GeneratePermutations(const I
       }
       Compare(aI2, i_1);
       // Check intersections yield the same result.
       Compare(i_0.Intersection(i_1), i_ref);
     } while (std::next_permutation(comb2.begin(), comb2.end()));
   } while (std::next_permutation(comb1.begin(), comb1.end()));
 }
 
-TEST(IntervalSet, IntersectionNormalizedIntervalSet) {
+TEST(IntervalSet, IntersectionNormalizedIntervalSet)
+{
   IntIntervals i0;
   i0 += IntInterval(5, 10);
   i0 += IntInterval(20, 25);
   i0 += IntInterval(40, 60);
 
   IntIntervals i1;
   i1.Add(IntInterval(7, 15));
   i1.Add(IntInterval(16, 27));
   i1.Add(IntInterval(45, 50));
   i1.Add(IntInterval(53, 57));
 
   GeneratePermutations(i0, i1);
 }
 
-TEST(IntervalSet, IntersectionUnorderedNonNormalizedIntervalSet) {
+TEST(IntervalSet, IntersectionUnorderedNonNormalizedIntervalSet)
+{
   IntIntervals i0;
   i0 += IntInterval(5, 10);
   i0 += IntInterval(8, 25);
   i0 += IntInterval(24, 60);
 
   IntIntervals i1;
   i1.Add(IntInterval(7, 15));
   i1.Add(IntInterval(10, 27));
   i1.Add(IntInterval(45, 50));
   i1.Add(IntInterval(53, 57));
 
   GeneratePermutations(i0, i1);
 }
 
-TEST(IntervalSet, IntersectionNonNormalizedInterval) {
+TEST(IntervalSet, IntersectionNonNormalizedInterval)
+{
   IntIntervals i0;
   i0 += IntInterval(5, 10);
   i0 += IntInterval(8, 25);
   i0 += IntInterval(30, 60);
 
   media::Interval<int> i1(9, 15);
   i0.Intersection(i1);
   EXPECT_EQ(1u, i0.Length());
   EXPECT_EQ(i0[0].mStart, i1.mStart);
   EXPECT_EQ(i0[0].mEnd, i1.mEnd);
 }
 
-TEST(IntervalSet, IntersectionUnorderedNonNormalizedInterval) {
+TEST(IntervalSet, IntersectionUnorderedNonNormalizedInterval)
+{
   IntIntervals i0;
   i0 += IntInterval(1, 3);
   i0 += IntInterval(1, 10);
   i0 += IntInterval(9, 12);
   i0 += IntInterval(12, 15);
   i0 += IntInterval(8, 25);
   i0 += IntInterval(30, 60);
   i0 += IntInterval(5, 10);
@@ -293,17 +304,18 @@ TEST(IntervalSet, IntersectionUnorderedN
   EXPECT_EQ(i0[0].mEnd, i1.mEnd);
 }
 
 static IntIntervals Duplicate(const IntIntervals& aValue) {
   IntIntervals value(aValue);
   return value;
 }
 
-TEST(IntervalSet, Normalize) {
+TEST(IntervalSet, Normalize)
+{
   IntIntervals i;
   // Test IntervalSet<T> + Interval<T> operator.
   i = i + IntInterval(20, 30);
   // Test Internal<T> + IntervalSet<T> operator.
   i = IntInterval(2, 7) + i;
   // Test Interval<T> + IntervalSet<T> operator
   i = IntInterval(1, 8) + i;
   IntIntervals interval;
@@ -327,55 +339,59 @@ TEST(IntervalSet, Normalize) {
   ti += media::TimeInterval(media::TimeUnit::FromSeconds(3.203366),
                             media::TimeUnit::FromSeconds(10.010065));
   EXPECT_EQ(2u, ti.Length());
   ti += media::TimeInterval(ti.Start(0), ti.End(0),
                             media::TimeUnit::FromMicroseconds(35000));
   EXPECT_EQ(1u, ti.Length());
 }
 
-TEST(IntervalSet, ContainValue) {
+TEST(IntervalSet, ContainValue)
+{
   IntIntervals i0;
   i0 += IntInterval(0, 10);
   i0 += IntInterval(15, 20);
   i0 += IntInterval(30, 50);
   EXPECT_TRUE(i0.Contains(0));  // start is inclusive.
   EXPECT_TRUE(i0.Contains(17));
   EXPECT_FALSE(i0.Contains(20));  // end boundary is exclusive.
   EXPECT_FALSE(i0.Contains(25));
 }
 
-TEST(IntervalSet, ContainValueWithFuzz) {
+TEST(IntervalSet, ContainValueWithFuzz)
+{
   IntIntervals i0;
   i0 += IntInterval(0, 10);
   i0 += IntInterval(15, 20, 1);
   i0 += IntInterval(30, 50);
   EXPECT_TRUE(i0.Contains(0));  // start is inclusive.
   EXPECT_TRUE(i0.Contains(17));
   EXPECT_TRUE(
       i0.Contains(20));  // end boundary is exclusive but we have a fuzz of 1.
   EXPECT_FALSE(i0.Contains(25));
 }
 
-TEST(IntervalSet, ContainInterval) {
+TEST(IntervalSet, ContainInterval)
+{
   IntIntervals i0;
   i0 += IntInterval(0, 10);
   i0 += IntInterval(15, 20);
   i0 += IntInterval(30, 50);
   EXPECT_TRUE(i0.Contains(IntInterval(2, 8)));
   EXPECT_TRUE(i0.Contains(IntInterval(31, 50)));
   EXPECT_TRUE(i0.Contains(IntInterval(0, 10)));
   EXPECT_FALSE(i0.Contains(IntInterval(0, 11)));
   EXPECT_TRUE(i0.Contains(IntInterval(0, 5)));
   EXPECT_FALSE(i0.Contains(IntInterval(8, 15)));
   EXPECT_FALSE(i0.Contains(IntInterval(15, 30)));
   EXPECT_FALSE(i0.Contains(IntInterval(30, 55)));
 }
 
-TEST(IntervalSet, ContainIntervalWithFuzz) {
+TEST(IntervalSet, ContainIntervalWithFuzz)
+{
   IntIntervals i0;
   i0 += IntInterval(0, 10);
   i0 += IntInterval(15, 20);
   i0 += IntInterval(30, 50);
   EXPECT_TRUE(i0.Contains(IntInterval(2, 8)));
   EXPECT_TRUE(i0.Contains(IntInterval(31, 50)));
   EXPECT_TRUE(i0.Contains(IntInterval(0, 11, 1)));
   EXPECT_TRUE(i0.Contains(IntInterval(0, 5)));
@@ -389,26 +405,28 @@ TEST(IntervalSet, ContainIntervalWithFuz
   i1 += IntInterval(15, 20, 1);
   i1 += IntInterval(30, 50, 1);
   EXPECT_TRUE(i1.Contains(IntInterval(2, 8)));
   EXPECT_TRUE(i1.Contains(IntInterval(29, 51)));
   EXPECT_TRUE(i1.Contains(IntInterval(0, 11, 1)));
   EXPECT_TRUE(i1.Contains(IntInterval(15, 21)));
 }
 
-TEST(IntervalSet, Span) {
+TEST(IntervalSet, Span)
+{
   IntInterval i0(0, 10);
   IntInterval i1(20, 30);
   IntInterval i{i0.Span(i1)};
 
   EXPECT_EQ(i.mStart, 0);
   EXPECT_EQ(i.mEnd, 30);
 }
 
-TEST(IntervalSet, Union) {
+TEST(IntervalSet, Union)
+{
   IntIntervals i0;
   i0 += IntInterval(5, 10);
   i0 += IntInterval(20, 25);
   i0 += IntInterval(40, 60);
 
   IntIntervals i1;
   i1.Add(IntInterval(7, 15));
   i1.Add(IntInterval(16, 27));
@@ -424,17 +442,18 @@ TEST(IntervalSet, Union) {
 
   EXPECT_EQ(16, i[1].mStart);
   EXPECT_EQ(27, i[1].mEnd);
 
   EXPECT_EQ(40, i[2].mStart);
   EXPECT_EQ(60, i[2].mEnd);
 }
 
-TEST(IntervalSet, UnionNotOrdered) {
+TEST(IntervalSet, UnionNotOrdered)
+{
   IntIntervals i0;
   i0 += IntInterval(20, 25);
   i0 += IntInterval(40, 60);
   i0 += IntInterval(5, 10);
 
   IntIntervals i1;
   i1.Add(IntInterval(16, 27));
   i1.Add(IntInterval(7, 15));
@@ -450,32 +469,34 @@ TEST(IntervalSet, UnionNotOrdered) {
 
   EXPECT_EQ(16, i[1].mStart);
   EXPECT_EQ(27, i[1].mEnd);
 
   EXPECT_EQ(40, i[2].mStart);
   EXPECT_EQ(60, i[2].mEnd);
 }
 
-TEST(IntervalSet, NormalizeFuzz) {
+TEST(IntervalSet, NormalizeFuzz)
+{
   IntIntervals i0;
   i0 += IntInterval(11, 25, 0);
   i0 += IntInterval(5, 10, 1);
   i0 += IntInterval(40, 60, 1);
 
   EXPECT_EQ(2u, i0.Length());
 
   EXPECT_EQ(5, i0[0].mStart);
   EXPECT_EQ(25, i0[0].mEnd);
 
   EXPECT_EQ(40, i0[1].mStart);
   EXPECT_EQ(60, i0[1].mEnd);
 }
 
-TEST(IntervalSet, UnionFuzz) {
+TEST(IntervalSet, UnionFuzz)
+{
   IntIntervals i0;
   i0 += IntInterval(5, 10, 1);
   i0 += IntInterval(11, 25, 0);
   i0 += IntInterval(40, 60, 1);
   EXPECT_EQ(2u, i0.Length());
   EXPECT_EQ(5, i0[0].mStart);
   EXPECT_EQ(25, i0[0].mEnd);
   EXPECT_EQ(40, i0[1].mStart);
@@ -500,24 +521,26 @@ TEST(IntervalSet, UnionFuzz) {
 
   EXPECT_EQ(5, i[0].mStart);
   EXPECT_EQ(27, i[0].mEnd);
 
   EXPECT_EQ(40, i[1].mStart);
   EXPECT_EQ(60, i[1].mEnd);
 }
 
-TEST(IntervalSet, Contiguous) {
+TEST(IntervalSet, Contiguous)
+{
   EXPECT_FALSE(IntInterval(5, 10).Contiguous(IntInterval(11, 25)));
   EXPECT_TRUE(IntInterval(5, 10).Contiguous(IntInterval(10, 25)));
   EXPECT_TRUE(IntInterval(5, 10, 1).Contiguous(IntInterval(11, 25)));
   EXPECT_TRUE(IntInterval(5, 10).Contiguous(IntInterval(11, 25, 1)));
 }
 
-TEST(IntervalSet, TimeRangesSeconds) {
+TEST(IntervalSet, TimeRangesSeconds)
+{
   media::TimeIntervals i0;
   i0 += media::TimeInterval(media::TimeUnit::FromSeconds(20),
                             media::TimeUnit::FromSeconds(25));
   i0 += media::TimeInterval(media::TimeUnit::FromSeconds(40),
                             media::TimeUnit::FromSeconds(60));
   i0 += media::TimeInterval(media::TimeUnit::FromSeconds(5),
                             media::TimeUnit::FromSeconds(10));
 
@@ -552,17 +575,18 @@ static void CheckTimeRanges(dom::TimeRan
     ErrorResult rv;
     EXPECT_EQ(tr->Start(i, rv), aTi[i].mStart.ToSeconds());
     EXPECT_EQ(tr->Start(i, rv), aTi.Start(i).ToSeconds());
     EXPECT_EQ(tr->End(i, rv), aTi[i].mEnd.ToSeconds());
     EXPECT_EQ(tr->End(i, rv), aTi.End(i).ToSeconds());
   }
 }
 
-TEST(IntervalSet, TimeRangesConversion) {
+TEST(IntervalSet, TimeRangesConversion)
+{
   RefPtr<dom::TimeRanges> tr = new dom::TimeRanges();
   tr->Add(20, 25);
   tr->Add(40, 60);
   tr->Add(5, 10);
   tr->Add(16, 27);
   tr->Add(53, 57);
   tr->Add(45, 50);
 
@@ -570,17 +594,18 @@ TEST(IntervalSet, TimeRangesConversion) 
   media::TimeIntervals i1(tr->ToTimeIntervals());
   CheckTimeRanges(tr, i1);
 
   // ctor(const TimeIntervals&)
   RefPtr<dom::TimeRanges> tr2 = new dom::TimeRanges(tr->ToTimeIntervals());
   CheckTimeRanges(tr2, i1);
 }
 
-TEST(IntervalSet, TimeRangesMicroseconds) {
+TEST(IntervalSet, TimeRangesMicroseconds)
+{
   media::TimeIntervals i0;
 
   i0 += media::TimeInterval(media::TimeUnit::FromMicroseconds(20),
                             media::TimeUnit::FromMicroseconds(25));
   i0 += media::TimeInterval(media::TimeUnit::FromMicroseconds(40),
                             media::TimeUnit::FromMicroseconds(60));
   i0 += media::TimeInterval(media::TimeUnit::FromMicroseconds(5),
                             media::TimeUnit::FromMicroseconds(10));
@@ -656,43 +681,46 @@ class Foo {
   bool operator<=(const Foo<T>& aOther) const { return mArg1 <= aOther.mArg1; }
 
  private:
   int32_t mArg1;
   int32_t mArg2;
   int32_t mArg3;
 };
 
-TEST(IntervalSet, FooIntervalSet) {
+TEST(IntervalSet, FooIntervalSet)
+{
   media::Interval<Foo<int>> i(Foo<int>(), Foo<int>(4, 5, 6));
   media::IntervalSet<Foo<int>> is;
   is += i;
   is += i;
   is.Add(i);
   is = is + i;
   is = i + is;
   EXPECT_EQ(1u, is.Length());
   EXPECT_EQ(Foo<int>(), is[0].mStart);
   EXPECT_EQ(Foo<int>(4, 5, 6), is[0].mEnd);
 }
 
-TEST(IntervalSet, StaticAssert) {
+TEST(IntervalSet, StaticAssert)
+{
   media::Interval<int> i;
 
   static_assert(
       mozilla::IsSame<nsTArray_CopyChooser<IntIntervals>::Type,
                       nsTArray_CopyWithConstructors<IntIntervals>>::value,
       "Must use copy constructor");
   static_assert(mozilla::IsSame<
                     nsTArray_CopyChooser<media::TimeIntervals>::Type,
                     nsTArray_CopyWithConstructors<media::TimeIntervals>>::value,
                 "Must use copy constructor");
 }
 
-TEST(IntervalSet, Substraction) {
+TEST(IntervalSet, Substraction)
+{
   IntIntervals i0;
   i0 += IntInterval(5, 10);
   i0 += IntInterval(20, 25);
   i0 += IntInterval(40, 60);
 
   IntInterval i1(8, 15);
   i0 -= i1;
 
--- a/dom/media/gtest/TestMP4Demuxer.cpp
+++ b/dom/media/gtest/TestMP4Demuxer.cpp
@@ -141,17 +141,18 @@ class MP4DemuxerBinding {
     RefPtr<Runnable> r =
         NS_NewRunnableFunction("MP4DemuxerBinding::DispatchTask", aFun);
     Unused << mTaskQueue->Dispatch(r.forget());
   }
 
   virtual ~MP4DemuxerBinding() {}
 };
 
-TEST(MP4Demuxer, Seek) {
+TEST(MP4Demuxer, Seek)
+{
   RefPtr<MP4DemuxerBinding> binding = new MP4DemuxerBinding();
 
   binding->RunTestAndWait([binding]() {
     binding->mVideoTrack =
         binding->mDemuxer->GetTrackDemuxer(TrackInfo::kVideoTrack, 0);
     binding->CheckTrackSamples(binding->mVideoTrack)
         ->Then(
             binding->mTaskQueue, __func__,
@@ -183,17 +184,18 @@ static nsCString ToCryptoString(const Cr
                        aCrypto.mEncryptedSizes[i]);
     }
   } else {
     res.AppendLiteral("no crypto");
   }
   return res;
 }
 
-TEST(MP4Demuxer, CENCFragVideo) {
+TEST(MP4Demuxer, CENCFragVideo)
+{
   const char* video[] = {
       "16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000000 "
       "5,684 5,16980",
       "16 7e571d037e571d037e571d037e571d03 00000000000000000000000000000450 "
       "5,1826",
       "16 7e571d037e571d037e571d037e571d03 000000000000000000000000000004c3 "
       "5,1215",
       "16 7e571d037e571d037e571d037e571d03 0000000000000000000000000000050f "
@@ -328,17 +330,18 @@ TEST(MP4Demuxer, CENCFragVideo) {
               }
               EXPECT_EQ(ArrayLength(video), binding->mSamples.Length());
               binding->mTaskQueue->BeginShutdown();
             },
             DO_FAIL);
   });
 }
 
-TEST(MP4Demuxer, CENCFragAudio) {
+TEST(MP4Demuxer, CENCFragAudio)
+{
   const char* audio[] = {
       "16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000000 "
       "0,281",
       "16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000012 "
       "0,257",
       "16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000023 "
       "0,246",
       "16 7e571d047e571d047e571d047e571d04 00000000000000000000000000000033 "
@@ -542,17 +545,18 @@ TEST(MP4Demuxer, CENCFragAudio) {
               }
               EXPECT_EQ(ArrayLength(audio), binding->mSamples.Length());
               binding->mTaskQueue->BeginShutdown();
             },
             DO_FAIL);
   });
 }
 
-TEST(MP4Demuxer, GetNextKeyframe) {
+TEST(MP4Demuxer, GetNextKeyframe)
+{
   RefPtr<MP4DemuxerBinding> binding = new MP4DemuxerBinding("gizmo-frag.mp4");
 
   binding->RunTestAndWait([binding]() {
     // Insert a [0,end] buffered range, to simulate Moof's being buffered
     // via MSE.
     auto len = binding->resource->GetLength();
     binding->resource->MockAddBufferedRange(0, len);
 
@@ -571,35 +575,38 @@ TEST(MP4Demuxer, GetNextKeyframe) {
           binding->mVideoTrack->GetNextRandomAccessPoint(&time);
           EXPECT_EQ(time.ToMicroseconds(), 1000000);
           binding->mTaskQueue->BeginShutdown();
         },
         DO_FAIL);
   });
 }
 
-TEST(MP4Demuxer, ZeroInLastMoov) {
+TEST(MP4Demuxer, ZeroInLastMoov)
+{
   RefPtr<MP4DemuxerBinding> binding =
       new MP4DemuxerBinding("short-zero-in-moov.mp4");
   binding->RunTestAndWait([binding]() {
     // It demuxes without error. That is sufficient.
     binding->mTaskQueue->BeginShutdown();
   });
 }
 
-TEST(MP4Demuxer, ZeroInMoovQuickTime) {
+TEST(MP4Demuxer, ZeroInMoovQuickTime)
+{
   RefPtr<MP4DemuxerBinding> binding =
       new MP4DemuxerBinding("short-zero-inband.mov");
   binding->RunTestAndWait([binding]() {
     // It demuxes without error. That is sufficient.
     binding->mTaskQueue->BeginShutdown();
   });
 }
 
-TEST(MP4Demuxer, IgnoreMinus1Duration) {
+TEST(MP4Demuxer, IgnoreMinus1Duration)
+{
   RefPtr<MP4DemuxerBinding> binding =
       new MP4DemuxerBinding("negative_duration.mp4");
   binding->RunTestAndWait([binding]() {
     // It demuxes without error. That is sufficient.
     binding->mTaskQueue->BeginShutdown();
   });
 }
 
--- a/dom/media/gtest/TestMediaDataDecoder.cpp
+++ b/dom/media/gtest/TestMediaDataDecoder.cpp
@@ -39,32 +39,34 @@ class BenchmarkRunner {
     SpinEventLoopUntil([&]() { return done; });
     return result;
   }
 
  private:
   RefPtr<Benchmark> mBenchmark;
 };
 
-TEST(MediaDataDecoder, H264) {
+TEST(MediaDataDecoder, H264)
+{
   if (!DecoderTraits::IsMP4SupportedType(
           MediaContainerType(MEDIAMIMETYPE(VIDEO_MP4)),
           /* DecoderDoctorDiagnostics* */ nullptr)) {
     EXPECT_TRUE(true);
   } else {
     RefPtr<MockMediaResource> resource = new MockMediaResource("gizmo.mp4");
     nsresult rv = resource->Open();
     EXPECT_TRUE(NS_SUCCEEDED(rv));
 
     BenchmarkRunner runner(new Benchmark(new MP4Demuxer(resource)));
     EXPECT_GT(runner.Run(), 0u);
   }
 }
 
-TEST(MediaDataDecoder, VP9) {
+TEST(MediaDataDecoder, VP9)
+{
   if (!WebMDecoder::IsSupportedType(
           MediaContainerType(MEDIAMIMETYPE(VIDEO_WEBM)))) {
     EXPECT_TRUE(true);
   } else {
     RefPtr<MockMediaResource> resource = new MockMediaResource("vp9cake.webm");
     nsresult rv = resource->Open();
     EXPECT_TRUE(NS_SUCCEEDED(rv));
 
--- a/dom/media/gtest/TestMediaEventSource.cpp
+++ b/dom/media/gtest/TestMediaEventSource.cpp
@@ -11,17 +11,18 @@
 #include "MediaEventSource.h"
 #include "VideoUtils.h"
 
 using namespace mozilla;
 
 /*
  * Test if listeners receive the event data correctly.
  */
-TEST(MediaEventSource, SingleListener) {
+TEST(MediaEventSource, SingleListener)
+{
   RefPtr<TaskQueue> queue =
       new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK));
 
   MediaEventProducer<int> source;
   int i = 0;
 
   auto func = [&](int j) { i += j; };
   MediaEventListener listener = source.Connect(queue, func);
@@ -34,17 +35,18 @@ TEST(MediaEventSource, SingleListener) {
   queue->BeginShutdown();
   queue->AwaitShutdownAndIdle();
 
   // Verify the event data is passed correctly to the listener.
   EXPECT_EQ(i, 15);  // 3 + 5 + 7
   listener.Disconnect();
 }
 
-TEST(MediaEventSource, MultiListener) {
+TEST(MediaEventSource, MultiListener)
+{
   RefPtr<TaskQueue> queue =
       new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK));
 
   MediaEventProducer<int> source;
   int i = 0;
   int j = 0;
 
   auto func1 = [&](int k) { i = k * 2; };
@@ -64,17 +66,18 @@ TEST(MediaEventSource, MultiListener) {
 
   listener1.Disconnect();
   listener2.Disconnect();
 }
 
 /*
  * Test if disconnecting a listener prevents events from coming.
  */
-TEST(MediaEventSource, DisconnectAfterNotification) {
+TEST(MediaEventSource, DisconnectAfterNotification)
+{
   RefPtr<TaskQueue> queue =
       new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK));
 
   MediaEventProducer<int> source;
   int i = 0;
 
   MediaEventListener listener;
   auto func = [&](int j) {
@@ -90,17 +93,18 @@ TEST(MediaEventSource, DisconnectAfterNo
 
   queue->BeginShutdown();
   queue->AwaitShutdownAndIdle();
 
   // Check only the 1st event is received.
   EXPECT_EQ(i, 11);
 }
 
-TEST(MediaEventSource, DisconnectBeforeNotification) {
+TEST(MediaEventSource, DisconnectBeforeNotification)
+{
   RefPtr<TaskQueue> queue =
       new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK));
 
   MediaEventProducer<int> source;
   int i = 0;
   int j = 0;
 
   auto func1 = [&](int k) { i = k * 2; };
@@ -121,29 +125,31 @@ TEST(MediaEventSource, DisconnectBeforeN
 
   listener1.Disconnect();
 }
 
 /*
  * Test we don't hit the assertion when calling Connect() and Disconnect()
  * repeatedly.
  */
-TEST(MediaEventSource, DisconnectAndConnect) {
+TEST(MediaEventSource, DisconnectAndConnect)
+{
   RefPtr<TaskQueue> queue;
   MediaEventProducerExc<int> source;
   MediaEventListener listener = source.Connect(queue, []() {});
   listener.Disconnect();
   listener = source.Connect(queue, []() {});
   listener.Disconnect();
 }
 
 /*
  * Test void event type.
  */
-TEST(MediaEventSource, VoidEventType) {
+TEST(MediaEventSource, VoidEventType)
+{
   RefPtr<TaskQueue> queue =
       new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK));
 
   MediaEventProducer<void> source;
   int i = 0;
 
   // Test function object.
   auto func = [&]() { ++i; };
@@ -169,17 +175,18 @@ TEST(MediaEventSource, VoidEventType) {
   EXPECT_EQ(foo.j, 4);  // |j *= 2| called twice
   listener1.Disconnect();
   listener2.Disconnect();
 }
 
 /*
  * Test listeners can take various event types (T, T&&, const T& and void).
  */
-TEST(MediaEventSource, ListenerType1) {
+TEST(MediaEventSource, ListenerType1)
+{
   RefPtr<TaskQueue> queue =
       new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK));
 
   MediaEventProducer<int> source;
   int i = 0;
 
   // Test various argument types.
   auto func1 = [&](int&& j) { i += j; };
@@ -196,17 +203,18 @@ TEST(MediaEventSource, ListenerType1) {
 
   EXPECT_EQ(i, 3);
 
   listener1.Disconnect();
   listener2.Disconnect();
   listener3.Disconnect();
 }
 
-TEST(MediaEventSource, ListenerType2) {
+TEST(MediaEventSource, ListenerType2)
+{
   RefPtr<TaskQueue> queue =
       new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK));
 
   MediaEventProducer<int> source;
 
   struct Foo {
     Foo() : mInt(0) {}
     void OnNotify1(int&& i) { mInt += i; }
@@ -245,17 +253,18 @@ struct SomeEvent {
   SomeEvent(const SomeEvent& aOther) : mCount(aOther.mCount) { ++mCount; }
   SomeEvent(SomeEvent&& aOther) : mCount(aOther.mCount) {}
   int& mCount;
 };
 
 /*
  * Test we don't have unnecessary copies of the event data.
  */
-TEST(MediaEventSource, CopyEvent1) {
+TEST(MediaEventSource, CopyEvent1)
+{
   RefPtr<TaskQueue> queue =
       new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK));
 
   MediaEventProducer<SomeEvent> source;
   int i = 0;
 
   auto func = [](SomeEvent&& aEvent) {};
   struct Foo {
@@ -271,17 +280,18 @@ TEST(MediaEventSource, CopyEvent1) {
 
   queue->BeginShutdown();
   queue->AwaitShutdownAndIdle();
   EXPECT_EQ(i, 2);
   listener1.Disconnect();
   listener2.Disconnect();
 }
 
-TEST(MediaEventSource, CopyEvent2) {
+TEST(MediaEventSource, CopyEvent2)
+{
   RefPtr<TaskQueue> queue =
       new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK));
 
   MediaEventProducer<SomeEvent> source;
   int i = 0;
 
   auto func = []() {};
   struct Foo {
@@ -299,17 +309,18 @@ TEST(MediaEventSource, CopyEvent2) {
   EXPECT_EQ(i, 0);
   listener1.Disconnect();
   listener2.Disconnect();
 }
 
 /*
  * Test move-only types.
  */
-TEST(MediaEventSource, MoveOnly) {
+TEST(MediaEventSource, MoveOnly)
+{
   RefPtr<TaskQueue> queue =
       new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK));
 
   MediaEventProducerExc<UniquePtr<int>> source;
 
   auto func = [](UniquePtr<int>&& aEvent) { EXPECT_EQ(*aEvent, 20); };
   MediaEventListener listener = source.Connect(queue, func);
 
@@ -332,17 +343,18 @@ struct RefCounter {
  private:
   ~RefCounter() {}
 };
 
 /*
  * Test we should copy instead of move in NonExclusive mode
  * for each listener must get a copy.
  */
-TEST(MediaEventSource, NoMove) {
+TEST(MediaEventSource, NoMove)
+{
   RefPtr<TaskQueue> queue =
       new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK));
 
   MediaEventProducer<RefPtr<RefCounter>> source;
 
   auto func1 = [](RefPtr<RefCounter>&& aEvent) { EXPECT_EQ(aEvent->mVal, 20); };
   auto func2 = [](RefPtr<RefCounter>&& aEvent) { EXPECT_EQ(aEvent->mVal, 20); };
   MediaEventListener listener1 = source.Connect(queue, func1);
@@ -356,17 +368,18 @@ TEST(MediaEventSource, NoMove) {
   queue->AwaitShutdownAndIdle();
   listener1.Disconnect();
   listener2.Disconnect();
 }
 
 /*
  * Rvalue lambda should be moved instead of copied.
  */
-TEST(MediaEventSource, MoveLambda) {
+TEST(MediaEventSource, MoveLambda)
+{
   RefPtr<TaskQueue> queue;
   MediaEventProducer<void> source;
 
   int counter = 0;
   SomeEvent someEvent(counter);
 
   auto func = [someEvent]() {};
   // someEvent is copied when captured by the lambda.
--- a/dom/media/gtest/TestMediaMIMETypes.cpp
+++ b/dom/media/gtest/TestMediaMIMETypes.cpp
@@ -4,17 +4,18 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "gtest/gtest.h"
 #include "MediaMIMETypes.h"
 #include "mozilla/Unused.h"
 
 using namespace mozilla;
 
-TEST(MediaMIMETypes, DependentMIMEType) {
+TEST(MediaMIMETypes, DependentMIMEType)
+{
   static const struct {
     const char* mString;
     DependentMediaMIMEType mDependentMediaMIMEType;
   } tests[] = {{"audio/mp4", MEDIAMIMETYPE("audio/mp4")},
                {"video/mp4", MEDIAMIMETYPE("video/mp4")},
                {"application/x-mp4", MEDIAMIMETYPE("application/x-mp4")}};
   for (const auto& test : tests) {
     EXPECT_TRUE(test.mDependentMediaMIMEType.AsDependentString().EqualsASCII(
@@ -22,28 +23,30 @@ TEST(MediaMIMETypes, DependentMIMEType) 
     MediaMIMEType mimetype(test.mDependentMediaMIMEType);
     EXPECT_TRUE(mimetype.AsString().Equals(
         test.mDependentMediaMIMEType.AsDependentString()));
     EXPECT_EQ(mimetype, test.mDependentMediaMIMEType);
     EXPECT_EQ(mimetype, MediaMIMEType(test.mDependentMediaMIMEType));
   }
 }
 
-TEST(MediaMIMETypes, MakeMediaMIMEType_bad) {
+TEST(MediaMIMETypes, MakeMediaMIMEType_bad)
+{
   static const char* tests[] = {"",       " ",   "/",    "audio",
                                 "audio/", "mp4", "/mp4", "a/b"};
 
   for (const auto& test : tests) {
     Maybe<MediaMIMEType> type = MakeMediaMIMEType(test);
     EXPECT_TRUE(type.isNothing())
         << "MakeMediaMIMEType(\"" << test << "\").isNothing()";
   }
 }
 
-TEST(MediaMIMETypes, MediaMIMEType) {
+TEST(MediaMIMETypes, MediaMIMEType)
+{
   static const struct {
     const char* mTypeString;
     const char* mAsString;
     bool mApplication;
     bool mAudio;
     bool mVideo;
     bool mEqualsLiteralVideoSlashMp4;  // tests `== "video/mp4"`
   } tests[] = {
@@ -73,17 +76,18 @@ TEST(MediaMIMETypes, MediaMIMEType) {
         << "\")->HasVideoMajorType() == " << (test.mVideo ? "true" : "false");
     EXPECT_EQ(test.mEqualsLiteralVideoSlashMp4,
               *type == MEDIAMIMETYPE("video/mp4"))
         << "*MakeMediaMIMEType(\"" << test.mTypeString
         << "\") == MEDIAMIMETYPE(\"video/mp4\")";
   }
 }
 
-TEST(MediaMIMETypes, MediaCodecs) {
+TEST(MediaMIMETypes, MediaCodecs)
+{
   MediaCodecs empty("");
   EXPECT_TRUE(empty.IsEmpty());
   EXPECT_TRUE(empty.AsString().EqualsLiteral(""));
   EXPECT_FALSE(empty.Contains(NS_LITERAL_STRING("")));
   EXPECT_FALSE(empty.Contains(NS_LITERAL_STRING("c1")));
   EXPECT_FALSE(empty.ContainsPrefix(NS_LITERAL_STRING("")));
   EXPECT_FALSE(empty.ContainsPrefix(NS_LITERAL_STRING("c1")));
   int iterations = 0;
@@ -147,28 +151,30 @@ TEST(MediaMIMETypes, MediaCodecs) {
   }
   EXPECT_EQ(2, iterations);
 
   EXPECT_TRUE(two.ContainsAll(two));
   EXPECT_TRUE(two.ContainsAll(one));
   EXPECT_FALSE(one.ContainsAll(two));
 }
 
-TEST(MediaMIMETypes, MakeMediaExtendedMIMEType_bad) {
+TEST(MediaMIMETypes, MakeMediaExtendedMIMEType_bad)
+{
   static const char* tests[] = {"",       " ",   "/",    "audio",
                                 "audio/", "mp4", "/mp4", "a/b"};
 
   for (const auto& test : tests) {
     Maybe<MediaExtendedMIMEType> type = MakeMediaExtendedMIMEType(test);
     EXPECT_TRUE(type.isNothing())
         << "MakeMediaExtendedMIMEType(\"" << test << "\").isNothing()";
   }
 }
 
-TEST(MediaMIMETypes, MediaExtendedMIMEType) {
+TEST(MediaMIMETypes, MediaExtendedMIMEType)
+{
   // Some generic tests first.
   static const struct {
     const char* mTypeString;
     const char* mTypeAsString;
     bool mApplication;
     bool mAudio;
     bool mVideo;
     bool mEqualsLiteralVideoSlashMp4;  // tests `== "video/mp4"`
--- a/dom/media/gtest/TestOpusParser.cpp
+++ b/dom/media/gtest/TestOpusParser.cpp
@@ -2,17 +2,18 @@
 /* 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 "gtest/gtest.h"
 #include "OpusParser.h"
 #include <algorithm>
 
-TEST(OpusParser, Mapping2) {
+TEST(OpusParser, Mapping2)
+{
   uint8_t validChannels[] = {1,   3,   4,   6,   9,   11,  16,  18,  25,  27,
                              36,  38,  49,  51,  64,  66,  81,  83,  100, 102,
                              121, 123, 144, 146, 169, 171, 196, 198, 225, 227};
   for (uint8_t channels = 0; channels < 255; channels++) {
     bool found = OpusParser::IsValidMapping2ChannelsCount(channels);
     bool foundTable =
         std::find(std::begin(validChannels), std::end(validChannels),
                   channels) != std::end(validChannels);
--- a/dom/media/gtest/TestRust.cpp
+++ b/dom/media/gtest/TestRust.cpp
@@ -1,9 +1,10 @@
 #include <stdint.h>
 #include "gtest/gtest.h"
 
 extern "C" uint8_t* test_rust();
 
-TEST(rust, CallFromCpp) {
+TEST(rust, CallFromCpp)
+{
   auto greeting = test_rust();
   EXPECT_STREQ(reinterpret_cast<char*>(greeting), "hello from rust.");
 }
--- a/dom/media/gtest/TestTimeUnit.cpp
+++ b/dom/media/gtest/TestTimeUnit.cpp
@@ -5,17 +5,18 @@
 
 #include "gtest/gtest.h"
 #include "TimeUnits.h"
 #include <algorithm>
 #include <vector>
 
 using namespace mozilla;
 
-TEST(TimeUnit, Rounding) {
+TEST(TimeUnit, Rounding)
+{
   int64_t usecs = 66261715;
   double seconds = media::TimeUnit::FromMicroseconds(usecs).ToSeconds();
   EXPECT_EQ(media::TimeUnit::FromSeconds(seconds).ToMicroseconds(), usecs);
 
   seconds = 4.169470;
   usecs = 4169470;
   EXPECT_EQ(media::TimeUnit::FromSeconds(seconds).ToMicroseconds(), usecs);
 }
--- a/dom/media/gtest/TestVPXDecoding.cpp
+++ b/dom/media/gtest/TestVPXDecoding.cpp
@@ -64,17 +64,18 @@ struct TestFileData {
   const char* mFilename;
   vpx_codec_err_t mDecodeResult;
 };
 static const TestFileData testFiles[] = {
     {"test_case_1224361.vp8.ivf", VPX_CODEC_OK},
     {"test_case_1224363.vp8.ivf", VPX_CODEC_CORRUPT_FRAME},
     {"test_case_1224369.vp8.ivf", VPX_CODEC_CORRUPT_FRAME}};
 
-TEST(libvpx, test_cases) {
+TEST(libvpx, test_cases)
+{
   for (size_t test = 0; test < ArrayLength(testFiles); ++test) {
     nsTArray<uint8_t> data;
     ReadVPXFile(testFiles[test].mFilename, data);
     ASSERT_GT(data.Length(), 0u);
 
     vpx_codec_dec_cfg_t config;
     vpx_codec_iface_t* dx = ParseIVFConfig(data, config);
     ASSERT_TRUE(dx);
--- a/dom/media/gtest/TestVideoSegment.cpp
+++ b/dom/media/gtest/TestVideoSegment.cpp
@@ -8,32 +8,34 @@
 using namespace mozilla;
 
 namespace mozilla {
 namespace layer {
 class Image;
 }  // namespace layer
 }  // namespace mozilla
 
-TEST(VideoSegment, TestAppendFrameForceBlack) {
+TEST(VideoSegment, TestAppendFrameForceBlack)
+{
   RefPtr<layers::Image> testImage = nullptr;
 
   VideoSegment segment;
   segment.AppendFrame(testImage.forget(), mozilla::gfx::IntSize(640, 480),
                       PRINCIPAL_HANDLE_NONE, true);
 
   VideoSegment::ChunkIterator iter(segment);
   while (!iter.IsEnded()) {
     VideoChunk chunk = *iter;
     EXPECT_TRUE(chunk.mFrame.GetForceBlack());
     iter.Next();
   }
 }
 
-TEST(VideoSegment, TestAppendFrameNotForceBlack) {
+TEST(VideoSegment, TestAppendFrameNotForceBlack)
+{
   RefPtr<layers::Image> testImage = nullptr;
 
   VideoSegment segment;
   segment.AppendFrame(testImage.forget(), mozilla::gfx::IntSize(640, 480),
                       PRINCIPAL_HANDLE_NONE);
 
   VideoSegment::ChunkIterator iter(segment);
   while (!iter.IsEnded()) {
--- a/dom/media/gtest/TestVideoTrackEncoder.cpp
+++ b/dom/media/gtest/TestVideoTrackEncoder.cpp
@@ -64,17 +64,18 @@ class TestVP8TrackEncoder : public VP8Tr
              << " width = " << aParam.mWidth << " height = " << aParam.mHeight;
     }
 
     return ::testing::AssertionSuccess();
   }
 };
 
 // Init test
-TEST(VP8VideoTrackEncoder, Initialization) {
+TEST(VP8VideoTrackEncoder, Initialization)
+{
   InitParam params[] = {
       // Failure cases.
       {false, 0, 0},  // Height/ width should be larger than 1.
       {false, 0, 1},  // Height/ width should be larger than 1.
       {false, 1, 0},  // Height/ width should be larger than 1.
 
       // Success cases
       {true, 640, 480},  // Standard VGA
@@ -85,17 +86,18 @@ TEST(VP8VideoTrackEncoder, Initializatio
 
   for (const InitParam& param : params) {
     TestVP8TrackEncoder encoder;
     EXPECT_TRUE(encoder.TestInit(param));
   }
 }
 
 // Get MetaData test
-TEST(VP8VideoTrackEncoder, FetchMetaData) {
+TEST(VP8VideoTrackEncoder, FetchMetaData)
+{
   InitParam params[] = {
       // Success cases
       {true, 640, 480},  // Standard VGA
       {true, 800, 480},  // Standard WVGA
       {true, 960, 540},  // Standard qHD
       {true, 1280, 720}  // Standard HD
   };
 
@@ -108,17 +110,18 @@ TEST(VP8VideoTrackEncoder, FetchMetaData
 
     // METADATA should be depend on how to initiate encoder.
     EXPECT_EQ(vp8Meta->mWidth, param.mWidth);
     EXPECT_EQ(vp8Meta->mHeight, param.mHeight);
   }
 }
 
 // Encode test
-TEST(VP8VideoTrackEncoder, FrameEncode) {
+TEST(VP8VideoTrackEncoder, FrameEncode)
+{
   TestVP8TrackEncoder encoder;
   TimeStamp now = TimeStamp::Now();
 
   // Create YUV images as source.
   nsTArray<RefPtr<Image>> images;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   images.AppendElement(generator.GenerateI420Image());
@@ -140,17 +143,18 @@ TEST(VP8VideoTrackEncoder, FrameEncode) 
   encoder.AdvanceCurrentTime(now + TimeDuration::FromSeconds(images.Length()));
 
   // Pull Encoded Data back from encoder.
   EncodedFrameContainer container;
   EXPECT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
 }
 
 // Test that encoding a single frame gives useful output.
-TEST(VP8VideoTrackEncoder, SingleFrameEncode) {
+TEST(VP8VideoTrackEncoder, SingleFrameEncode)
+{
   TestVP8TrackEncoder encoder;
   TimeStamp now = TimeStamp::Now();
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
 
   // Pass a half-second frame to the encoder.
   VideoSegment segment;
   segment.AppendFrame(generator.GenerateI420Image(), generator.GetSize(),
@@ -174,17 +178,18 @@ TEST(VP8VideoTrackEncoder, SingleFrameEn
   EXPECT_EQ(EncodedFrame::VP8_I_FRAME, frames[0]->GetFrameType())
       << "We only have one frame, so it should be a keyframe";
 
   const uint64_t halfSecond = PR_USEC_PER_SEC / 2;
   EXPECT_EQ(halfSecond, frames[0]->GetDuration());
 }
 
 // Test that encoding a couple of identical images gives useful output.
-TEST(VP8VideoTrackEncoder, SameFrameEncode) {
+TEST(VP8VideoTrackEncoder, SameFrameEncode)
+{
   TestVP8TrackEncoder encoder;
   TimeStamp now = TimeStamp::Now();
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
 
   // Pass 15 100ms frames to the encoder.
   RefPtr<Image> image = generator.GenerateI420Image();
   VideoSegment segment;
@@ -209,17 +214,18 @@ TEST(VP8VideoTrackEncoder, SameFrameEnco
   for (auto& frame : container.GetEncodedFrames()) {
     totalDuration += frame->GetDuration();
   }
   const uint64_t oneAndAHalf = (PR_USEC_PER_SEC / 2) * 3;
   EXPECT_EQ(oneAndAHalf, totalDuration);
 }
 
 // Test encoding a track that has to skip frames.
-TEST(VP8VideoTrackEncoder, SkippedFrames) {
+TEST(VP8VideoTrackEncoder, SkippedFrames)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Pass 100 frames of the shortest possible duration where we don't get
   // rounding errors between input/output rate.
   VideoSegment segment;
@@ -244,17 +250,18 @@ TEST(VP8VideoTrackEncoder, SkippedFrames
   for (auto& frame : container.GetEncodedFrames()) {
     totalDuration += frame->GetDuration();
   }
   const uint64_t hundredMillis = PR_USEC_PER_SEC / 10;
   EXPECT_EQ(hundredMillis, totalDuration);
 }
 
 // Test encoding a track with frames subject to rounding errors.
-TEST(VP8VideoTrackEncoder, RoundingErrorFramesEncode) {
+TEST(VP8VideoTrackEncoder, RoundingErrorFramesEncode)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Pass nine frames with timestamps not expressable in 90kHz sample rate,
   // then one frame to make the total duration one second.
   VideoSegment segment;
@@ -285,17 +292,18 @@ TEST(VP8VideoTrackEncoder, RoundingError
   for (auto& frame : container.GetEncodedFrames()) {
     totalDuration += frame->GetDuration();
   }
   const uint64_t oneSecond = PR_USEC_PER_SEC;
   EXPECT_EQ(oneSecond, totalDuration);
 }
 
 // Test that we're encoding timestamps rather than durations.
-TEST(VP8VideoTrackEncoder, TimestampFrameEncode) {
+TEST(VP8VideoTrackEncoder, TimestampFrameEncode)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   VideoSegment segment;
   segment.AppendFrame(generator.GenerateI420Image(), generator.GetSize(),
                       PRINCIPAL_HANDLE_NONE, false, now);
@@ -327,17 +335,18 @@ TEST(VP8VideoTrackEncoder, TimestampFram
     EXPECT_EQ(expectedDurations[i++], frame->GetDuration());
     totalDuration += frame->GetDuration();
   }
   const uint64_t pointThree = (PR_USEC_PER_SEC / 10) * 3;
   EXPECT_EQ(pointThree, totalDuration);
 }
 
 // Test that we're compensating for drift when encoding.
-TEST(VP8VideoTrackEncoder, DriftingFrameEncode) {
+TEST(VP8VideoTrackEncoder, DriftingFrameEncode)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Set up major drift -- audio that goes twice as fast as video.
   // This should make the given video durations double as they get encoded.
   EXPECT_CALL(*encoder.DriftCompensator(), GetVideoTime(_, _))
@@ -375,17 +384,18 @@ TEST(VP8VideoTrackEncoder, DriftingFrame
     EXPECT_EQ(expectedDurations[i++], frame->GetDuration());
     totalDuration += frame->GetDuration();
   }
   const uint64_t pointSix = (PR_USEC_PER_SEC / 10) * 6;
   EXPECT_EQ(pointSix, totalDuration);
 }
 
 // Test that suspending an encoding works.
-TEST(VP8VideoTrackEncoder, Suspended) {
+TEST(VP8VideoTrackEncoder, Suspended)
+{
   TestVP8TrackEncoder encoder;
   TimeStamp now = TimeStamp::Now();
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
 
   // Pass 3 frames with duration 0.1s. We suspend before and resume after the
   // second frame.
 
@@ -436,17 +446,18 @@ TEST(VP8VideoTrackEncoder, Suspended) {
   for (auto& frame : container.GetEncodedFrames()) {
     totalDuration += frame->GetDuration();
   }
   const uint64_t pointTwo = (PR_USEC_PER_SEC / 10) * 2;
   EXPECT_EQ(pointTwo, totalDuration);
 }
 
 // Test that ending a track while the video track encoder is suspended works.
-TEST(VP8VideoTrackEncoder, SuspendedUntilEnd) {
+TEST(VP8VideoTrackEncoder, SuspendedUntilEnd)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Pass 2 frames with duration 0.1s. We suspend before the second frame.
 
   {
@@ -485,17 +496,18 @@ TEST(VP8VideoTrackEncoder, SuspendedUnti
   for (auto& frame : container.GetEncodedFrames()) {
     totalDuration += frame->GetDuration();
   }
   const uint64_t pointOne = PR_USEC_PER_SEC / 10;
   EXPECT_EQ(pointOne, totalDuration);
 }
 
 // Test that ending a track that was always suspended works.
-TEST(VP8VideoTrackEncoder, AlwaysSuspended) {
+TEST(VP8VideoTrackEncoder, AlwaysSuspended)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Suspend and then pass a frame with duration 2s.
 
   encoder.Suspend(now);
@@ -516,17 +528,18 @@ TEST(VP8VideoTrackEncoder, AlwaysSuspend
   EXPECT_TRUE(encoder.IsEncodingComplete());
 
   // Verify that we have no encoded frames.
   const uint64_t none = 0;
   EXPECT_EQ(none, container.GetEncodedFrames().Length());
 }
 
 // Test that encoding a track that is suspended in the beginning works.
-TEST(VP8VideoTrackEncoder, SuspendedBeginning) {
+TEST(VP8VideoTrackEncoder, SuspendedBeginning)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Suspend and pass a frame with duration 0.5s. Then resume and pass one more.
   encoder.Suspend(now);
 
@@ -567,17 +580,18 @@ TEST(VP8VideoTrackEncoder, SuspendedBegi
     totalDuration += frame->GetDuration();
   }
   const uint64_t half = PR_USEC_PER_SEC / 2;
   EXPECT_EQ(half, totalDuration);
 }
 
 // Test that suspending and resuming in the middle of already pushed data
 // works.
-TEST(VP8VideoTrackEncoder, SuspendedOverlap) {
+TEST(VP8VideoTrackEncoder, SuspendedOverlap)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   {
     // Pass a 1s frame and suspend after 0.5s.
     VideoSegment segment;
@@ -615,17 +629,18 @@ TEST(VP8VideoTrackEncoder, SuspendedOver
   ASSERT_EQ(two, container.GetEncodedFrames().Length());
   const uint64_t pointFive = (PR_USEC_PER_SEC / 10) * 5;
   EXPECT_EQ(pointFive, container.GetEncodedFrames()[0]->GetDuration());
   const uint64_t pointSeven = (PR_USEC_PER_SEC / 10) * 7;
   EXPECT_EQ(pointSeven, container.GetEncodedFrames()[1]->GetDuration());
 }
 
 // Test that ending a track in the middle of already pushed data works.
-TEST(VP8VideoTrackEncoder, PrematureEnding) {
+TEST(VP8VideoTrackEncoder, PrematureEnding)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Pass a 1s frame and end the track after 0.5s.
   VideoSegment segment;
   segment.AppendFrame(generator.GenerateI420Image(), generator.GetSize(),
@@ -645,17 +660,18 @@ TEST(VP8VideoTrackEncoder, PrematureEndi
   for (auto& frame : container.GetEncodedFrames()) {
     totalDuration += frame->GetDuration();
   }
   const uint64_t half = PR_USEC_PER_SEC / 2;
   EXPECT_EQ(half, totalDuration);
 }
 
 // Test that a track that starts at t > 0 works as expected.
-TEST(VP8VideoTrackEncoder, DelayedStart) {
+TEST(VP8VideoTrackEncoder, DelayedStart)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Pass a 2s frame, start (pass first CurrentTime) at 0.5s, end at 1s.
   // Should result in a 0.5s encoding.
   VideoSegment segment;
@@ -677,17 +693,18 @@ TEST(VP8VideoTrackEncoder, DelayedStart)
     totalDuration += frame->GetDuration();
   }
   const uint64_t half = PR_USEC_PER_SEC / 2;
   EXPECT_EQ(half, totalDuration);
 }
 
 // Test that a track that starts at t > 0 works as expected, when
 // SetStartOffset comes after AppendVideoSegment.
-TEST(VP8VideoTrackEncoder, DelayedStartOtherEventOrder) {
+TEST(VP8VideoTrackEncoder, DelayedStartOtherEventOrder)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Pass a 2s frame, start (pass first CurrentTime) at 0.5s, end at 1s.
   // Should result in a 0.5s encoding.
   VideoSegment segment;
@@ -708,17 +725,18 @@ TEST(VP8VideoTrackEncoder, DelayedStartO
   for (auto& frame : container.GetEncodedFrames()) {
     totalDuration += frame->GetDuration();
   }
   const uint64_t half = PR_USEC_PER_SEC / 2;
   EXPECT_EQ(half, totalDuration);
 }
 
 // Test that a track that starts at t >>> 0 works as expected.
-TEST(VP8VideoTrackEncoder, VeryDelayedStart) {
+TEST(VP8VideoTrackEncoder, VeryDelayedStart)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Pass a 1s frame, start (pass first CurrentTime) at 10s, end at 10.5s.
   // Should result in a 0.5s encoding.
   VideoSegment segment;
@@ -740,17 +758,18 @@ TEST(VP8VideoTrackEncoder, VeryDelayedSt
     totalDuration += frame->GetDuration();
   }
   const uint64_t half = PR_USEC_PER_SEC / 2;
   EXPECT_EQ(half, totalDuration);
 }
 
 // Test that a video frame that hangs around for a long time gets encoded every
 // second.
-TEST(VP8VideoTrackEncoder, LongFramesReEncoded) {
+TEST(VP8VideoTrackEncoder, LongFramesReEncoded)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Pass a frame at t=0 and start encoding.
   // Advancing the current time by 1.5s should encode a 1s frame.
   // Advancing the current time by another 9.5s should encode another 10 1s
@@ -794,17 +813,18 @@ TEST(VP8VideoTrackEncoder, LongFramesReE
     const uint64_t tenSec = PR_USEC_PER_SEC * 10;
     EXPECT_EQ(tenSec, totalDuration);
     EXPECT_EQ(10U, container.GetEncodedFrames().Length());
   }
 }
 
 // Test that an encoding with a defined key frame interval encodes keyframes
 // as expected. Short here means shorter than the default (1s).
-TEST(VP8VideoTrackEncoder, ShortKeyFrameInterval) {
+TEST(VP8VideoTrackEncoder, ShortKeyFrameInterval)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Give the encoder a keyframe interval of 500ms.
   // Pass frames at 0, 400ms, 600ms, 750ms, 900ms, 1100ms
   // Expected keys: ^         ^^^^^                ^^^^^^
@@ -863,17 +883,18 @@ TEST(VP8VideoTrackEncoder, ShortKeyFrame
 
   // [1100ms, 1200ms)
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 100UL, frames[5]->GetDuration());
   EXPECT_EQ(EncodedFrame::VP8_I_FRAME, frames[5]->GetFrameType());
 }
 
 // Test that an encoding with a defined key frame interval encodes keyframes
 // as expected. Long here means longer than the default (1s).
-TEST(VP8VideoTrackEncoder, LongKeyFrameInterval) {
+TEST(VP8VideoTrackEncoder, LongKeyFrameInterval)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Give the encoder a keyframe interval of 2000ms.
   // Pass frames at 0, 600ms, 900ms, 1100ms, 1900ms, 2100ms
   // Expected keys: ^                ^^^^^^          ^^^^^^
@@ -932,17 +953,18 @@ TEST(VP8VideoTrackEncoder, LongKeyFrameI
 
   // [2100ms, 2200ms)
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 100UL, frames[5]->GetDuration());
   EXPECT_EQ(EncodedFrame::VP8_I_FRAME, frames[5]->GetFrameType());
 }
 
 // Test that an encoding with no defined key frame interval encodes keyframes
 // as expected. Default interval should be 1000ms.
-TEST(VP8VideoTrackEncoder, DefaultKeyFrameInterval) {
+TEST(VP8VideoTrackEncoder, DefaultKeyFrameInterval)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   TimeStamp now = TimeStamp::Now();
 
   // Pass frames at 0, 600ms, 900ms, 1100ms, 1900ms, 2100ms
   // Expected keys: ^                ^^^^^^          ^^^^^^
   VideoSegment segment;
@@ -999,17 +1021,18 @@ TEST(VP8VideoTrackEncoder, DefaultKeyFra
 
   // [2100ms, 2200ms)
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 100UL, frames[5]->GetDuration());
   EXPECT_EQ(EncodedFrame::VP8_I_FRAME, frames[5]->GetFrameType());
 }
 
 // Test that an encoding where the key frame interval is updated dynamically
 // encodes keyframes as expected.
-TEST(VP8VideoTrackEncoder, DynamicKeyFrameIntervalChanges) {
+TEST(VP8VideoTrackEncoder, DynamicKeyFrameIntervalChanges)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   EncodedFrameContainer container;
   TimeStamp now = TimeStamp::Now();
 
   // Set keyframe interval to 100ms.
   // Pass frames at 0, 100ms, 120ms, 130ms, 200ms, 300ms
@@ -1168,17 +1191,18 @@ TEST(VP8VideoTrackEncoder, DynamicKeyFra
 
   // [2900ms, 3000ms)
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 100UL, frames[13]->GetDuration());
   EXPECT_EQ(EncodedFrame::VP8_P_FRAME, frames[13]->GetFrameType());
 }
 
 // Test that an encoding which is disabled on a frame timestamp encodes
 // frames as expected.
-TEST(VP8VideoTrackEncoder, DisableOnFrameTime) {
+TEST(VP8VideoTrackEncoder, DisableOnFrameTime)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   EncodedFrameContainer container;
   TimeStamp now = TimeStamp::Now();
 
   // Pass a frame in at t=0.
   // Pass another frame in at t=100ms.
@@ -1212,17 +1236,18 @@ TEST(VP8VideoTrackEncoder, DisableOnFram
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 100UL, frames[0]->GetDuration());
 
   // [100ms, 200ms)
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 100UL, frames[1]->GetDuration());
 }
 
 // Test that an encoding which is disabled between two frame timestamps encodes
 // frames as expected.
-TEST(VP8VideoTrackEncoder, DisableBetweenFrames) {
+TEST(VP8VideoTrackEncoder, DisableBetweenFrames)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   EncodedFrameContainer container;
   TimeStamp now = TimeStamp::Now();
 
   // Pass a frame in at t=0.
   // Disable the track at t=50ms.
@@ -1256,17 +1281,18 @@ TEST(VP8VideoTrackEncoder, DisableBetwee
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 50UL, frames[1]->GetDuration());
 
   // [100ms, 200ms)
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 100UL, frames[2]->GetDuration());
 }
 
 // Test that an encoding which is enabled on a frame timestamp encodes
 // frames as expected.
-TEST(VP8VideoTrackEncoder, EnableOnFrameTime) {
+TEST(VP8VideoTrackEncoder, EnableOnFrameTime)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   EncodedFrameContainer container;
   TimeStamp now = TimeStamp::Now();
 
   // Disable the track at t=0.
   // Pass a frame in at t=0.
@@ -1302,17 +1328,18 @@ TEST(VP8VideoTrackEncoder, EnableOnFrame
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 100UL, frames[0]->GetDuration());
 
   // [100ms, 200ms)
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 100UL, frames[1]->GetDuration());
 }
 
 // Test that an encoding which is enabled between two frame timestamps encodes
 // frames as expected.
-TEST(VP8VideoTrackEncoder, EnableBetweenFrames) {
+TEST(VP8VideoTrackEncoder, EnableBetweenFrames)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   EncodedFrameContainer container;
   TimeStamp now = TimeStamp::Now();
 
   // Disable the track at t=0.
   // Pass a frame in at t=0.
@@ -1347,17 +1374,18 @@ TEST(VP8VideoTrackEncoder, EnableBetween
   // [50ms, 100ms)
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 50UL, frames[1]->GetDuration());
 
   // [100ms, 200ms)
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 100UL, frames[2]->GetDuration());
 }
 
 // Test that making time go backwards removes any future frames in the encoder.
-TEST(VP8VideoTrackEncoder, BackwardsTimeResets) {
+TEST(VP8VideoTrackEncoder, BackwardsTimeResets)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   EncodedFrameContainer container;
   TimeStamp now = TimeStamp::Now();
 
   encoder.SetStartOffset(now);
 
@@ -1419,17 +1447,18 @@ TEST(VP8VideoTrackEncoder, BackwardsTime
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 100UL, frames[2]->GetDuration());
 
   // [250ms, 300ms)
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 50UL, frames[3]->GetDuration());
 }
 
 // Test that trying to encode a null image removes any future frames in the
 // encoder.
-TEST(VP8VideoTrackEncoder, NullImageResets) {
+TEST(VP8VideoTrackEncoder, NullImageResets)
+{
   TestVP8TrackEncoder encoder;
   YUVBufferGenerator generator;
   generator.Init(mozilla::gfx::IntSize(640, 480));
   EncodedFrameContainer container;
   TimeStamp now = TimeStamp::Now();
 
   encoder.SetStartOffset(now);
 
@@ -1487,17 +1516,18 @@ TEST(VP8VideoTrackEncoder, NullImageRese
   // [100ms, 250ms)
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 150UL, frames[1]->GetDuration());
 
   // [250ms, 300ms)
   EXPECT_EQ(PR_USEC_PER_SEC / 1000 * 50UL, frames[2]->GetDuration());
 }
 
 // EOS test
-TEST(VP8VideoTrackEncoder, EncodeComplete) {
+TEST(VP8VideoTrackEncoder, EncodeComplete)
+{
   TestVP8TrackEncoder encoder;
 
   // track end notification.
   encoder.NotifyEndOfStream();
 
   // Pull Encoded Data back from encoder. Since we have sent
   // EOS to encoder, encoder.GetEncodedTrack should return
   // NS_OK immidiately.
--- a/dom/media/gtest/TestVideoUtils.cpp
+++ b/dom/media/gtest/TestVideoUtils.cpp
@@ -5,32 +5,34 @@
 
 #include "gtest/gtest.h"
 #include "nsMimeTypes.h"
 #include "nsString.h"
 #include "VideoUtils.h"
 
 using namespace mozilla;
 
-TEST(MediaMIMETypes, IsMediaMIMEType) {
+TEST(MediaMIMETypes, IsMediaMIMEType)
+{
   EXPECT_TRUE(IsMediaMIMEType(AUDIO_MP4));
   EXPECT_TRUE(IsMediaMIMEType(VIDEO_MP4));
   EXPECT_TRUE(IsMediaMIMEType("application/x-mp4"));
 
   EXPECT_TRUE(IsMediaMIMEType("audio/m"));
   EXPECT_FALSE(IsMediaMIMEType("audio/"));
 
   EXPECT_FALSE(IsMediaMIMEType("vide/mp4"));
   EXPECT_FALSE(IsMediaMIMEType("videos/mp4"));
 
   // Expect lowercase only.
   EXPECT_FALSE(IsMediaMIMEType("Video/mp4"));
 }
 
-TEST(StringListRange, MakeStringListRange) {
+TEST(StringListRange, MakeStringListRange)
+{
   static const struct {
     const char* mList;
     const char* mExpectedSkipEmpties;
     const char* mExpectedProcessAll;
     const char* mExpectedProcessEmpties;
   } tests[] = {
       // string              skip         all               empties
       {"", "", "|", ""},
@@ -70,17 +72,18 @@ TEST(StringListRange, MakeStringListRang
              list)) {
       out += item;
       out += "|";
     }
     EXPECT_STREQ(test.mExpectedProcessEmpties, out.Data());
   }
 }
 
-TEST(StringListRange, StringListContains) {
+TEST(StringListRange, StringListContains)
+{
   static const struct {
     const char* mList;
     const char* mItemToSearch;
     bool mExpectedSkipEmpties;
     bool mExpectedProcessAll;
     bool mExpectedProcessEmpties;
   } tests[] = {// haystack            needle  skip   all    empties
                {"", "", false, true, false},
--- a/dom/media/gtest/TestWebMBuffered.cpp
+++ b/dom/media/gtest/TestWebMBuffered.cpp
@@ -14,17 +14,18 @@ using namespace mozilla;
 // timecodes 100000000 and are 133000000 skipped by WebMBufferedParser
 // because they occur after a block with timecode 160000000 and the parser
 // expects in-order timecodes per the WebM spec.  The remaining 6
 // SimpleBlocks have the following attributes:
 static const uint64_t gTimecodes[] = {66000000,  160000000, 166000000,
                                       200000000, 233000000, 320000000};
 static const int64_t gEndOffsets[] = {501, 772, 1244, 1380, 1543, 2015};
 
-TEST(WebMBuffered, BasicTests) {
+TEST(WebMBuffered, BasicTests)
+{
   ReentrantMonitor dummy("dummy");
   WebMBufferedParser parser(0);
 
   nsTArray<WebMTimeDataOffset> mapping;
   parser.Append(nullptr, 0, mapping, dummy);
   EXPECT_TRUE(mapping.IsEmpty());
   EXPECT_EQ(parser.mStartOffset, 0);
   EXPECT_EQ(parser.mCurrentOffset, 0);
@@ -52,17 +53,18 @@ static void ReadFile(const char* aPath, 
 
   size_t got = fread(aBuffer.Elements(), 1, size, f);
   ASSERT_EQ(got, size_t(size));
 
   r = fclose(f);
   ASSERT_EQ(r, 0);
 }
 
-TEST(WebMBuffered, RealData) {
+TEST(WebMBuffered, RealData)
+{
   ReentrantMonitor dummy("dummy");
   WebMBufferedParser parser(0);
 
   nsTArray<uint8_t> webmData;
   ReadFile("test.webm", webmData);
 
   nsTArray<WebMTimeDataOffset> mapping;
   parser.Append(webmData.Elements(), webmData.Length(), mapping, dummy);
@@ -73,17 +75,18 @@ TEST(WebMBuffered, RealData) {
 
   for (uint32_t i = 0; i < mapping.Length(); ++i) {
     EXPECT_EQ(mapping[i].mEndOffset, gEndOffsets[i]);
     EXPECT_EQ(mapping[i].mSyncOffset, 361);
     EXPECT_EQ(mapping[i].mTimecode, gTimecodes[i]);
   }
 }
 
-TEST(WebMBuffered, RealDataAppend) {
+TEST(WebMBuffered, RealDataAppend)
+{
   ReentrantMonitor dummy("dummy");
   WebMBufferedParser parser(0);
   nsTArray<WebMTimeDataOffset> mapping;
 
   nsTArray<uint8_t> webmData;
   ReadFile("test.webm", webmData);
 
   uint32_t arrayEntries = mapping.Length();
--- a/dom/media/gtest/TestWebMWriter.cpp
+++ b/dom/media/gtest/TestWebMWriter.cpp
@@ -89,17 +89,18 @@ class TestWebMWriter : public WebMWriter
     return (encodedBuf.Length() > 0) ? true : false;
   }
 
   // Timestamp accumulator that increased by AppendDummyFrame.
   // Keep it public that we can do some testcases about it.
   uint64_t mTimestamp;
 };
 
-TEST(WebMWriter, Metadata) {
+TEST(WebMWriter, Metadata)
+{
   TestWebMWriter writer(ContainerWriter::CREATE_AUDIO_TRACK |
                         ContainerWriter::CREATE_VIDEO_TRACK);
 
   // The output should be empty since we didn't set any metadata in writer.
   nsTArray<nsTArray<uint8_t> > encodedBuf;
   writer.GetContainerData(&encodedBuf, ContainerWriter::GET_HEADER);
   EXPECT_TRUE(encodedBuf.Length() == 0);
   writer.GetContainerData(&encodedBuf, ContainerWriter::FLUSH_NEEDED);
@@ -124,17 +125,18 @@ TEST(WebMWriter, Metadata) {
   int32_t displayWidth = 640;
   int32_t displayHeight = 480;
   writer.SetVP8Metadata(width, height, displayWidth, displayHeight, aTrackRate);
 
   writer.GetContainerData(&encodedBuf, ContainerWriter::GET_HEADER);
   EXPECT_TRUE(encodedBuf.Length() > 0);
 }
 
-TEST(WebMWriter, Cluster) {
+TEST(WebMWriter, Cluster)
+{
   TestWebMWriter writer(ContainerWriter::CREATE_AUDIO_TRACK |
                         ContainerWriter::CREATE_VIDEO_TRACK);
   // Set opus metadata.
   int channel = 1;
   int sampleRate = 48000;
   TrackRate aTrackRate = 90000;
   writer.SetOpusMetadata(channel, sampleRate, aTrackRate);
   // Set vp8 metadata
@@ -165,17 +167,18 @@ TEST(WebMWriter, Cluster) {
   EXPECT_FALSE(writer.HaveValidCluster());
 
   // The third I-Frame.
   writer.AppendDummyFrame(EncodedFrame::VP8_I_FRAME, FIXED_DURATION);
   // Should have data because the second cluster is closed.
   EXPECT_TRUE(writer.HaveValidCluster());
 }
 
-TEST(WebMWriter, FLUSH_NEEDED) {
+TEST(WebMWriter, FLUSH_NEEDED)
+{
   TestWebMWriter writer(ContainerWriter::CREATE_AUDIO_TRACK |
                         ContainerWriter::CREATE_VIDEO_TRACK);
   // Set opus metadata.
   int channel = 2;
   int sampleRate = 44100;
   TrackRate aTrackRate = 100000;
   writer.SetOpusMetadata(channel, sampleRate, aTrackRate);
   // Set vp8 metadata
@@ -284,17 +287,18 @@ static int webm_seek(int64_t aOffset, in
 }
 
 static int64_t webm_tell(void* aUserData) {
   NS_ASSERTION(aUserData, "aUserData must point to a valid WebMioData");
   WebMioData* ioData = static_cast<WebMioData*>(aUserData);
   return ioData->offset.isValid() ? ioData->offset.value() : -1;
 }
 
-TEST(WebMWriter, bug970774_aspect_ratio) {
+TEST(WebMWriter, bug970774_aspect_ratio)
+{
   TestWebMWriter writer(ContainerWriter::CREATE_AUDIO_TRACK |
                         ContainerWriter::CREATE_VIDEO_TRACK);
   // Set opus metadata.
   int channel = 1;
   int sampleRate = 44100;
   TrackRate aTrackRate = 90000;
   writer.SetOpusMetadata(channel, sampleRate, aTrackRate);
   // Set vp8 metadata
--- a/dom/media/gtest/mp4_demuxer/TestInterval.cpp
+++ b/dom/media/gtest/mp4_demuxer/TestInterval.cpp
@@ -3,42 +3,46 @@
  * 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 "gtest/gtest.h"
 #include "MP4Interval.h"
 
 using mozilla::MP4Interval;
 
-TEST(MP4Interval, Length) {
+TEST(MP4Interval, Length)
+{
   MP4Interval<int> i(15, 25);
   EXPECT_EQ(10, i.Length());
 }
 
-TEST(MP4Interval, Intersection) {
+TEST(MP4Interval, Intersection)
+{
   MP4Interval<int> i0(10, 20);
   MP4Interval<int> i1(15, 25);
   MP4Interval<int> i = i0.Intersection(i1);
   EXPECT_EQ(15, i.start);
   EXPECT_EQ(20, i.end);
 }
 
-TEST(MP4Interval, Equals) {
+TEST(MP4Interval, Equals)
+{
   MP4Interval<int> i0(10, 20);
   MP4Interval<int> i1(10, 20);
   EXPECT_EQ(i0, i1);
 
   MP4Interval<int> i2(5, 20);
   EXPECT_NE(i0, i2);
 
   MP4Interval<int> i3(10, 15);
   EXPECT_NE(i0, i2);
 }
 
-TEST(MP4Interval, IntersectionVector) {
+TEST(MP4Interval, IntersectionVector)
+{
   nsTArray<MP4Interval<int>> i0;
   i0.AppendElement(MP4Interval<int>(5, 10));
   i0.AppendElement(MP4Interval<int>(20, 25));
   i0.AppendElement(MP4Interval<int>(40, 60));
 
   nsTArray<MP4Interval<int>> i1;
   i1.AppendElement(MP4Interval<int>(7, 15));
   i1.AppendElement(MP4Interval<int>(16, 27));
@@ -58,17 +62,18 @@ TEST(MP4Interval, IntersectionVector) {
 
   EXPECT_EQ(45, i[2].start);
   EXPECT_EQ(50, i[2].end);
 
   EXPECT_EQ(53, i[3].start);
   EXPECT_EQ(57, i[3].end);
 }
 
-TEST(MP4Interval, Normalize) {
+TEST(MP4Interval, Normalize)
+{
   nsTArray<MP4Interval<int>> i;
   i.AppendElement(MP4Interval<int>(20, 30));
   i.AppendElement(MP4Interval<int>(1, 8));
   i.AppendElement(MP4Interval<int>(5, 10));
   i.AppendElement(MP4Interval<int>(2, 7));
 
   nsTArray<MP4Interval<int>> o;
   MP4Interval<int>::Normalize(i, &o);
--- a/dom/media/gtest/mp4_demuxer/TestMP4.cpp
+++ b/dom/media/gtest/mp4_demuxer/TestMP4.cpp
@@ -46,17 +46,18 @@ static intptr_t vector_reader(uint8_t* b
   }
   uintptr_t available = source->buffer.size() - source->location;
   uintptr_t length = std::min(available, size);
   memcpy(buffer, source->buffer.data() + source->location, length);
   source->location += length;
   return length;
 }
 
-TEST(rust, MP4MetadataEmpty) {
+TEST(rust, MP4MetadataEmpty)
+{
   Mp4parseStatus rv;
   Mp4parseIo io;
 
   // Shouldn't be able to read with no context.
   rv = mp4parse_read(nullptr);
   EXPECT_EQ(rv, MP4PARSE_STATUS_BAD_ARG);
 
   // Shouldn't be able to wrap an Mp4parseIo with null members.
@@ -100,17 +101,18 @@ TEST(rust, MP4MetadataEmpty) {
   // Empty buffers should fail.
   buf.buffer.resize(4097, 0);
   context = mp4parse_new(&io);
   rv = mp4parse_read(context);
   EXPECT_EQ(rv, MP4PARSE_STATUS_UNSUPPORTED);
   mp4parse_free(context);
 }
 
-TEST(rust, MP4Metadata) {
+TEST(rust, MP4Metadata)
+{
   FILE* f = fopen("street.mp4", "rb");
   ASSERT_TRUE(f != nullptr);
   // Read just the moov header to work around the parser
   // treating mid-box eof as an error.
   // read_vector reader = read_vector(f, 1061);
   struct stat s;
   ASSERT_EQ(0, fstat(fileno(f), &s));
   read_vector reader = read_vector(f, s.st_size);
--- a/dom/media/gtest/mp4_demuxer/TestParser.cpp
+++ b/dom/media/gtest/mp4_demuxer/TestParser.cpp
@@ -63,17 +63,18 @@ class TestStream : public ByteStream,
 
  protected:
   virtual ~TestStream() {}
 
   const uint8_t* mBuffer;
   size_t mSize;
 };
 
-TEST(MP4Metadata, EmptyStream) {
+TEST(MP4Metadata, EmptyStream)
+{
   RefPtr<ByteStream> stream = new TestStream(nullptr, 0);
 
   MP4Metadata::ResultAndByteBuffer metadataBuffer =
       MP4Metadata::Metadata(stream);
   EXPECT_TRUE(NS_OK != metadataBuffer.Result());
   EXPECT_FALSE(static_cast<bool>(metadataBuffer.Ref()));
 
   MP4Metadata metadata(stream);
@@ -89,17 +90,18 @@ TEST(MP4Metadata, EmptyStream) {
   EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kAudioTrack, 0).Ref());
   EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kVideoTrack, 0).Ref());
   EXPECT_FALSE(metadata.GetTrackInfo(TrackInfo::kTextTrack, 0).Ref());
   // We can seek anywhere in any MPEG4.
   EXPECT_TRUE(metadata.CanSeek());
   EXPECT_FALSE(metadata.Crypto().Ref()->valid);
 }
 
-TEST(MoofParser, EmptyStream) {
+TEST(MoofParser, EmptyStream)
+{
   RefPtr<ByteStream> stream = new TestStream(nullptr, 0);
 
   MoofParser parser(stream, AsVariant(ParseAllTracks{}), false);
   EXPECT_EQ(0u, parser.mOffset);
   EXPECT_TRUE(parser.ReachedEnd());
 
   MediaByteRangeSet byteRanges;
   EXPECT_FALSE(parser.RebuildFragmentedIndex(byteRanges));
@@ -243,17 +245,18 @@ static const TestFileData testFiles[] = 
      530, 0, -1, false, 0, false, false,
      0},  // Uses bad track id 0 and has a sinf but no pssh
     {"test_case_1519617-track2-trafs-removed.mp4", true, 1, true, 10032000, 400,
      300, 1, 10032000, false, 0, true, true, 2},
     {"test_case_1519617-video-has-track_id-0.mp4", true, 1, true, 10032000, 400,
      300, 1, 10032000, false, 0, true, true, 2},  // Uses bad track id 0
 };
 
-TEST(MP4Metadata, test_case_mp4) {
+TEST(MP4Metadata, test_case_mp4)
+{
   const TestFileData* tests = nullptr;
   size_t length = 0;
 
   tests = testFiles;
   length = ArrayLength(testFiles);
 
   for (size_t test = 0; test < length; ++test) {
     nsTArray<uint8_t> buffer = ReadTestFile(tests[test].mFilename);
@@ -398,17 +401,18 @@ TEST(MP4Metadata, test_case_mp4_subsets)
           size -= 1;
         }
       }
     }
   }
 }
 #endif
 
-TEST(MoofParser, test_case_mp4) {
+TEST(MoofParser, test_case_mp4)
+{
   const TestFileData* tests = nullptr;
   size_t length = 0;
 
   tests = testFiles;
   length = ArrayLength(testFiles);
 
   for (size_t test = 0; test < length; ++test) {
     nsTArray<uint8_t> buffer = ReadTestFile(tests[test].mFilename);
@@ -443,17 +447,18 @@ TEST(MoofParser, test_case_mp4) {
         << tests[test].mFilename;
     EXPECT_TRUE(parser.FirstCompleteMediaSegment().IsEmpty())
         << tests[test].mFilename;
     EXPECT_EQ(tests[test].mHeader, !parser.FirstCompleteMediaHeader().IsEmpty())
         << tests[test].mFilename;
   }
 }
 
-TEST(MoofParser, test_case_sample_description_entries) {
+TEST(MoofParser, test_case_sample_description_entries)
+{
   const TestFileData* tests = testFiles;
   size_t length = ArrayLength(testFiles);
 
   for (size_t test = 0; test < length; ++test) {
     nsTArray<uint8_t> buffer = ReadTestFile(tests[test].mFilename);
     ASSERT_FALSE(buffer.IsEmpty());
     RefPtr<ByteStream> stream =
         new TestStream(buffer.Elements(), buffer.Length());
@@ -490,17 +495,18 @@ TEST(MoofParser, test_case_sample_descri
     }
   }
 }
 
 // We should gracefully handle track_id 0 since Bug 1519617. We'd previously
 // used id 0 to trigger special handling in the MoofParser to read multiple
 // track metadata, but since muxers use track id 0 in the wild, we want to
 // make sure they can't accidentally trigger such handling.
-TEST(MoofParser, test_case_track_id_0_does_not_read_multitracks) {
+TEST(MoofParser, test_case_track_id_0_does_not_read_multitracks)
+{
   const char* zeroTrackIdFileName =
       "test_case_1519617-video-has-track_id-0.mp4";
   nsTArray<uint8_t> buffer = ReadTestFile(zeroTrackIdFileName);
 
   ASSERT_FALSE(buffer.IsEmpty());
   RefPtr<ByteStream> stream =
       new TestStream(buffer.Elements(), buffer.Length());
 
@@ -545,17 +551,18 @@ TEST(MoofParser, test_case_track_id_0_do
 }
 
 // We should gracefully handle track_id 0 since Bug 1519617. This includes
 // handling crypto data from the sinf box in the MoofParser. Note, as of the
 // time of writing, MP4Metadata uses the presence of a pssh box to determine
 // if its crypto member is valid. However, even on files where the pssh isn't
 // in the init segment, the MoofParser should still read the sinf, as in this
 // testcase.
-TEST(MoofParser, test_case_track_id_0_reads_crypto_metadata) {
+TEST(MoofParser, test_case_track_id_0_reads_crypto_metadata)
+{
   const char* zeroTrackIdFileName =
       "test_case_1519617-cenc-init-with-track_id-0.mp4";
   nsTArray<uint8_t> buffer = ReadTestFile(zeroTrackIdFileName);
 
   ASSERT_FALSE(buffer.IsEmpty());
   RefPtr<ByteStream> stream =
       new TestStream(buffer.Elements(), buffer.Length());
 
@@ -602,17 +609,18 @@ TEST(MoofParser, test_case_track_id_0_re
 
 // The MoofParser may be asked to parse metadata for multiple tracks, but then
 // be presented with fragments/moofs that contain data for only a subset of
 // those tracks. I.e. metadata contains information for tracks with ids 1 and 2,
 // but then the moof parser only receives moofs with data for track id 1. We
 // should parse such fragmented media. In this test the metadata contains info
 // for track ids 1 and 2, but track 2's track fragment headers (traf) have been
 // over written with free space boxes (free).
-TEST(MoofParser, test_case_moofs_missing_trafs) {
+TEST(MoofParser, test_case_moofs_missing_trafs)
+{
   const char* noTrafsForTrack2MoofsFileName =
       "test_case_1519617-track2-trafs-removed.mp4";
   nsTArray<uint8_t> buffer = ReadTestFile(noTrafsForTrack2MoofsFileName);
 
   ASSERT_FALSE(buffer.IsEmpty());
   RefPtr<ByteStream> stream =
       new TestStream(buffer.Elements(), buffer.Length());
 
@@ -745,17 +753,18 @@ uint8_t media_gtest_video_init_mp4[] = {
     0x78, 0x00, 0x00, 0x00, 0x10, 0x6d, 0x65, 0x68, 0x64, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x05, 0x76, 0x18, 0x00, 0x00, 0x00, 0x20, 0x74, 0x72, 0x65,
     0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
     0x01, 0x00, 0x00, 0x03, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
     0x00};
 
 const uint32_t media_gtest_video_init_mp4_len = 745;
 
-TEST(MP4Metadata, EmptyCTTS) {
+TEST(MP4Metadata, EmptyCTTS)
+{
   RefPtr<MediaByteBuffer> buffer =
       new MediaByteBuffer(media_gtest_video_init_mp4_len);
   buffer->AppendElements(media_gtest_video_init_mp4,
                          media_gtest_video_init_mp4_len);
   RefPtr<BufferStream> stream = new BufferStream(buffer);
 
   MP4Metadata::ResultAndByteBuffer metadataBuffer =
       MP4Metadata::Metadata(stream);
@@ -840,17 +849,17 @@ TEST_F(MP4MetadataTelemetryFixture, Tele
 
         // Verify our multiple codecs count histogram.
         JS::RootedValue multipleCodecsHistogram(cx.GetJSContext());
         TelemetryTestHelpers::GetProperty(
             cx.GetJSContext(),
             "MEDIA_MP4_PARSE_SAMPLE_DESCRIPTION_ENTRIES_HAVE_MULTIPLE_CODECS",
             snapshot, &multipleCodecsHistogram);
         ASSERT_TRUE(multipleCodecsHistogram.isObject())
-            << "Multiple codecs histogram should exist!";
+        << "Multiple codecs histogram should exist!";
 
         TelemetryTestHelpers::GetProperty(cx.GetJSContext(), "values",
                                           multipleCodecsHistogram, &values);
         // False count.
         TelemetryTestHelpers::GetElement(cx.GetJSContext(), 0, values, &value);
         uint32_t uValue = 0;
         JS::ToUint32(cx.GetJSContext(), value, &uValue);
         EXPECT_EQ(Get<0>(aExpectedMultipleCodecCounts), uValue)
@@ -865,17 +874,17 @@ TEST_F(MP4MetadataTelemetryFixture, Tele
 
         // Verify our multiple crypto count histogram.
         JS::RootedValue multipleCryptoHistogram(cx.GetJSContext());
         TelemetryTestHelpers::GetProperty(
             cx.GetJSContext(),
             "MEDIA_MP4_PARSE_SAMPLE_DESCRIPTION_ENTRIES_HAVE_MULTIPLE_CRYPTO",
             snapshot, &multipleCryptoHistogram);
         ASSERT_TRUE(multipleCryptoHistogram.isObject())
-            << "Multiple crypto histogram should exist!";
+        << "Multiple crypto histogram should exist!";
 
         TelemetryTestHelpers::GetProperty(cx.GetJSContext(), "values",
                                           multipleCryptoHistogram, &values);
         // False count.
         TelemetryTestHelpers::GetElement(cx.GetJSContext(), 0, values, &value);
         JS::ToUint32(cx.GetJSContext(), value, &uValue);
         EXPECT_EQ(Get<0>(aExpectedMultipleCryptoCounts), uValue)
             << "Unexpected number of false multiple cryptos after parsing "
@@ -888,17 +897,17 @@ TEST_F(MP4MetadataTelemetryFixture, Tele
             << aFileName;
 
         // Verify our sample description entry count histogram.
         JS::RootedValue numSamplesHistogram(cx.GetJSContext());
         TelemetryTestHelpers::GetProperty(
             cx.GetJSContext(), "MEDIA_MP4_PARSE_NUM_SAMPLE_DESCRIPTION_ENTRIES",
             snapshot, &numSamplesHistogram);
         ASSERT_TRUE(numSamplesHistogram.isObject())
-            << "Num sample description entries histogram should exist!";
+        << "Num sample description entries histogram should exist!";
 
         TelemetryTestHelpers::GetProperty(cx.GetJSContext(), "values",
                                           numSamplesHistogram, &values);
 
         TelemetryTestHelpers::GetElement(cx.GetJSContext(), 0, values, &value);
         JS::ToUint32(cx.GetJSContext(), value, &uValue);
         EXPECT_EQ(Get<0>(aExpectedSampleDescriptionEntryCounts), uValue)
             << "Unexpected number of 0 sample entry descriptions after parsing "
--- a/dom/media/mediasource/gtest/TestContainerParser.cpp
+++ b/dom/media/mediasource/gtest/TestContainerParser.cpp
@@ -7,17 +7,18 @@
 #include <stdint.h>
 
 #include "ContainerParser.h"
 #include "mozilla/ArrayUtils.h"
 #include "nsAutoPtr.h"
 
 using namespace mozilla;
 
-TEST(ContainerParser, MIMETypes) {
+TEST(ContainerParser, MIMETypes)
+{
   const char* containerTypes[] = {"video/webm", "audio/webm", "video/mp4",
                                   "audio/mp4", "audio/aac"};
   nsAutoPtr<ContainerParser> parser;
   for (size_t i = 0; i < ArrayLength(containerTypes); ++i) {
     Maybe<MediaContainerType> containerType =
         MakeMediaContainerType(containerTypes[i]);
     ASSERT_TRUE(containerType.isSome());
     parser = ContainerParser::CreateForMIMEType(*containerType);
@@ -27,17 +28,18 @@ TEST(ContainerParser, MIMETypes) {
 
 already_AddRefed<MediaByteBuffer> make_adts_header() {
   const uint8_t test[] = {0xff, 0xf1, 0x50, 0x80, 0x03, 0x1f, 0xfc};
   RefPtr<MediaByteBuffer> buffer(new MediaByteBuffer);
   buffer->AppendElements(test, ArrayLength(test));
   return buffer.forget();
 }
 
-TEST(ContainerParser, ADTSHeader) {
+TEST(ContainerParser, ADTSHeader)
+{
   nsAutoPtr<ContainerParser> parser;
   parser = ContainerParser::CreateForMIMEType(
       MediaContainerType(MEDIAMIMETYPE("audio/aac")));
   ASSERT_NE(parser, nullptr);
 
   // Audio data should have no gaps.
   EXPECT_EQ(parser->GetRoundingError(), 0);
 
@@ -92,17 +94,18 @@ TEST(ContainerParser, ADTSHeader) {
 
   EXPECT_EQ(parser->InitSegmentRange(),
             MediaByteRange(0, int64_t(header->Length())));
   // Media segment range should be empty here.
   EXPECT_EQ(parser->MediaHeaderRange(), MediaByteRange());
   EXPECT_EQ(parser->MediaSegmentRange(), MediaByteRange());
 }
 
-TEST(ContainerParser, ADTSBlankMedia) {
+TEST(ContainerParser, ADTSBlankMedia)
+{
   nsAutoPtr<ContainerParser> parser;
   parser = ContainerParser::CreateForMIMEType(
       MediaContainerType(MEDIAMIMETYPE("audio/aac")));
   ASSERT_NE(parser, nullptr);
 
   // Audio data should have no gaps.
   EXPECT_EQ(parser->GetRoundingError(), 0);
 
--- a/dom/media/mediasource/gtest/TestExtractVPXCodecDetails.cpp
+++ b/dom/media/mediasource/gtest/TestExtractVPXCodecDetails.cpp
@@ -10,17 +10,18 @@
 
 using namespace mozilla;
 
 struct TestData {
   const char16_t* const mCodecParameterString;
   const bool mExpectedValue;
 };
 
-TEST(ExtractVPXCodecDetails, TestDataLength) {
+TEST(ExtractVPXCodecDetails, TestDataLength)
+{
   TestData tests[] = {
       {u"vp09.00.11.08", true},     // valid case
       {u"vp09.00.11.08.00", true},  // valid case, have extra optional field
       {u"vp09.02.10.10.01.09.16.09.01", true},  // maximum length valid case
       {u"vp09", false},                         // lack of mandatory fields
       {u"vp09.00", false},                      // lack of mandatory fields
       {u"vp09.00.11", false},                   // lack of mandatory fields
       {u"vp09.02.10.10.01.09.16.09.01.00",
@@ -33,17 +34,18 @@ TEST(ExtractVPXCodecDetails, TestDataLen
     uint8_t bitDepth = 0;
     bool result = ExtractVPXCodecDetails(nsString(data.mCodecParameterString),
                                          profile, level, bitDepth);
     EXPECT_EQ(result, data.mExpectedValue)
         << NS_ConvertUTF16toUTF8(data.mCodecParameterString).get();
   }
 }
 
-TEST(ExtractVPXCodecDetails, TestInputData) {
+TEST(ExtractVPXCodecDetails, TestInputData)
+{
   TestData tests[] = {
       {u"vp09.02..08", false},       // malformed
       {u"vp9.02.10.08", false},      // invalid 4CC
       {u"vp09.03.11.08", false},     // profile should < 3
       {u"vp09.00.63.08.00", false},  // invalid level
       {u"vp09.02.10.13", false},     // invalid bitDepth
       {u"vp09.02.10.10.04", false},  // invalid chromasubsampling, should < 4
       {u"vp09.02.10.10.01.00",
@@ -69,17 +71,18 @@ TEST(ExtractVPXCodecDetails, TestInputDa
     uint8_t bitDepth = 0;
     bool result = ExtractVPXCodecDetails(nsString(data.mCodecParameterString),
                                          profile, level, bitDepth);
     EXPECT_EQ(result, data.mExpectedValue)
         << NS_ConvertUTF16toUTF8(data.mCodecParameterString).get();
   }
 }
 
-TEST(ExtractVPXCodecDetails, TestParsingOutput) {
+TEST(ExtractVPXCodecDetails, TestParsingOutput)
+{
   uint8_t profile = 0;
   uint8_t level = 0;
   uint8_t bitDepth = 0;
   uint8_t chromaSubsampling = 0;
   VideoColorSpace colorSpace;
   auto data = u"vp09.01.11.08";
   bool result = ExtractVPXCodecDetails(nsString(data), profile, level, bitDepth,
                                        chromaSubsampling, colorSpace);
--- a/dom/prio/test/gtest/TestPrioEncoder.cpp
+++ b/dom/prio/test/gtest/TestPrioEncoder.cpp
@@ -9,17 +9,18 @@
 #include "jsapi.h"
 #include "PrioEncoder.h"
 
 #include "mozilla/Preferences.h"
 #include "mozilla/dom/ScriptSettings.h"
 
 #include "mprio.h"
 
-TEST(PrioEncoder, BadPublicKeys) {
+TEST(PrioEncoder, BadPublicKeys)
+{
   mozilla::dom::AutoJSAPI jsAPI;
   ASSERT_TRUE(jsAPI.Init(xpc::PrivilegedJunkScope()));
   JSContext* cx = jsAPI.cx();
 
   mozilla::Preferences::SetCString("prio.publicKeyA",
                                    nsCString(NS_LITERAL_CSTRING("badA")));
   mozilla::Preferences::SetCString("prio.publicKeyB",
                                    nsCString(NS_LITERAL_CSTRING("badB")));
@@ -41,17 +42,18 @@ TEST(PrioEncoder, BadPublicKeys) {
   mozilla::dom::PrioEncoder::Encode(global, batchID, prioParams,
                                     prioEncodedData, rv);
   ASSERT_TRUE(rv.Failed());
 
   // Reset error result so test runner does not fail.
   rv = mozilla::ErrorResult();
 }
 
-TEST(PrioEncoder, BooleanLimitExceeded) {
+TEST(PrioEncoder, BooleanLimitExceeded)
+{
   mozilla::dom::AutoJSAPI jsAPI;
   ASSERT_TRUE(jsAPI.Init(xpc::PrivilegedJunkScope()));
   JSContext* cx = jsAPI.cx();
 
   mozilla::dom::GlobalObject global(cx, xpc::PrivilegedJunkScope());
 
   nsCString batchID = NS_LITERAL_CSTRING("abc123");
 
@@ -76,17 +78,18 @@ TEST(PrioEncoder, BooleanLimitExceeded) 
   mozilla::dom::PrioEncoder::Encode(global, batchID, prioParams,
                                     prioEncodedData, rv);
   ASSERT_TRUE(rv.Failed());
 
   // Reset error result so test runner does not fail.
   rv = mozilla::ErrorResult();
 }
 
-TEST(PrioEncoder, VerifyFull) {
+TEST(PrioEncoder, VerifyFull)
+{
   SECStatus prioRv = SECSuccess;
 
   PublicKey pkA = nullptr;
   PublicKey pkB = nullptr;
   PrivateKey skA = nullptr;
   PrivateKey skB = nullptr;
 
   PrioConfig cfg = nullptr;
--- a/dom/quota/test/gtest/TestQuotaManager.cpp
+++ b/dom/quota/test/gtest/TestQuotaManager.cpp
@@ -22,17 +22,18 @@ void CheckOriginScopeMatchesOrigin(const
   bool result = aOriginScope.Matches(
       OriginScope::FromOrigin(nsDependentCString(aOrigin)));
 
   EXPECT_TRUE(result == aMatch);
 }
 
 }  // namespace
 
-TEST(QuotaManager, OriginScope) {
+TEST(QuotaManager, OriginScope)
+{
   OriginScope originScope;
 
   // Sanity checks.
 
   {
     NS_NAMED_LITERAL_CSTRING(origin, "http://www.mozilla.org");
     originScope.SetFromOrigin(origin);
     EXPECT_TRUE(originScope.IsOrigin());
--- a/dom/reporting/tests/gtest/TestReportToParser.cpp
+++ b/dom/reporting/tests/gtest/TestReportToParser.cpp
@@ -7,17 +7,18 @@
 #include "gtest/gtest.h"
 #include "mozilla/dom/ReportingHeader.h"
 #include "nsNetUtil.h"
 #include "nsIURI.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 
-TEST(ReportToParser, Basic) {
+TEST(ReportToParser, Basic)
+{
   nsCOMPtr<nsIURI> uri;
 
   nsresult rv = NS_NewURI(getter_AddRefs(uri), "https://example.com");
   ASSERT_EQ(NS_OK, rv);
 
   bool urlEqual = false;
 
   // Empty header.
--- a/dom/security/featurepolicy/test/gtest/TestFeaturePolicyParser.cpp
+++ b/dom/security/featurepolicy/test/gtest/TestFeaturePolicyParser.cpp
@@ -27,17 +27,18 @@ void CheckParser(const nsAString& aInput
   ASSERT_TRUE(FeaturePolicyParser::ParseString(aInput, nullptr, principal,
                                                principal, parsedFeatures) ==
               aExpectedResults);
   ASSERT_TRUE(parsedFeatures.Length() == aExpectedFeatures);
 
   parsedFeatures.SwapElements(aParsedFeatures);
 }
 
-TEST(FeaturePolicyParser, Basic) {
+TEST(FeaturePolicyParser, Basic)
+{
   nsCOMPtr<nsIPrincipal> selfPrincipal =
       mozilla::BasePrincipal::CreateCodebasePrincipal(URL_SELF);
   nsCOMPtr<nsIPrincipal> exampleComPrincipal =
       mozilla::BasePrincipal::CreateCodebasePrincipal(URL_EXAMPLE_COM);
   nsCOMPtr<nsIPrincipal> exampleNetPrincipal =
       mozilla::BasePrincipal::CreateCodebasePrincipal(URL_EXAMPLE_NET);
 
   nsTArray<Feature> parsedFeatures;
--- a/dom/security/test/gtest/TestCSPParser.cpp
+++ b/dom/security/test/gtest/TestCSPParser.cpp
@@ -171,17 +171,18 @@ nsresult runTestSuite(const PolicyTest* 
                        strictDynamicEnabledCache);
   }
 
   return NS_OK;
 }
 
 // ============================= TestDirectives ========================
 
-TEST(CSPParser, Directives) {
+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" },
@@ -223,17 +224,18 @@ TEST(CSPParser, Directives) {
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
 // ============================= TestKeywords ========================
 
-TEST(CSPParser, Keywords) {
+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'" },
@@ -247,17 +249,18 @@ TEST(CSPParser, Keywords) {
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
 // =================== TestIgnoreUpperLowerCasePolicies ==============
 
-TEST(CSPParser, IgnoreUpperLowerCasePolicies) {
+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'" },
@@ -289,17 +292,18 @@ TEST(CSPParser, IgnoreUpperLowerCasePoli
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
 // ========================= TestPaths ===============================
 
-TEST(CSPParser, Paths) {
+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" },
@@ -387,17 +391,18 @@ TEST(CSPParser, Paths) {
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
 // ======================== TestSimplePolicies =======================
 
-TEST(CSPParser, SimplePolicies) {
+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://*" },
@@ -463,17 +468,18 @@ TEST(CSPParser, SimplePolicies) {
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
 // =================== TestPoliciesWithInvalidSrc ====================
 
-TEST(CSPParser, PoliciesWithInvalidSrc) {
+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'" },
@@ -556,17 +562,18 @@ TEST(CSPParser, PoliciesWithInvalidSrc) 
 
   // 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 =======================
 
-TEST(CSPParser, BadPolicies) {
+TEST(CSPParser, BadPolicies)
+{
   static const PolicyTest policies[] = {
       // clang-format off
     { "script-sr 'self", "" },
     { "", "" },
     { "; ; ; ; ; ; ;", "" },
     { "defaut-src asdf", "" },
     { "default-src: aaa", "" },
     { "asdf http://test.com", ""},
@@ -578,17 +585,18 @@ TEST(CSPParser, BadPolicies) {
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 0)));
 }
 
 // ======================= TestGoodGeneratedPolicies =================
 
-TEST(CSPParser, GoodGeneratedPolicies) {
+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 *" },
@@ -806,17 +814,18 @@ TEST(CSPParser, GoodGeneratedPolicies) {
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
 // ==================== TestBadGeneratedPolicies ====================
 
-TEST(CSPParser, BadGeneratedPolicies) {
+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", ""},
@@ -832,17 +841,18 @@ TEST(CSPParser, BadGeneratedPolicies) {
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 0)));
 }
 
 // ============ TestGoodGeneratedPoliciesForPathHandling =============
 
-TEST(CSPParser, GoodGeneratedPoliciesForPathHandling) {
+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/",
@@ -955,17 +965,18 @@ TEST(CSPParser, GoodGeneratedPoliciesFor
   };
 
   uint32_t policyCount = sizeof(policies) / sizeof(PolicyTest);
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
 // ============== TestBadGeneratedPoliciesForPathHandling ============
 
-TEST(CSPParser, BadGeneratedPoliciesForPathHandling) {
+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'" },
@@ -984,17 +995,18 @@ TEST(CSPParser, BadGeneratedPoliciesForP
   ASSERT_TRUE(NS_SUCCEEDED(runTestSuite(policies, policyCount, 1)));
 }
 
 // ======================== TestFuzzyPolicies ========================
 
 // Use a policy, eliminate one character at a time,
 // and feed it as input to the parser.
 
-TEST(CSPParser, ShorteningPolicies) {
+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));
 
   PolicyTest testPol[1];
   memset(&testPol[0].policy, '\0', kMaxPolicyLength * sizeof(char));
 
@@ -1011,17 +1023,18 @@ TEST(CSPParser, ShorteningPolicies) {
 // 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
 
-TEST(CSPParser, FuzzyPolicies) {
+TEST(CSPParser, FuzzyPolicies)
+{
   // init srand with 0 so we get same results
   srand(0);
 
   PolicyTest testPol[1];
   memset(&testPol[0].policy, '\0', kMaxPolicyLength);
 
   for (uint32_t index = 0; index < kFuzzyRuns; index++) {
     // randomly select the length of the next policy
@@ -1043,17 +1056,18 @@ TEST(CSPParser, FuzzyPolicies) {
 // ======================= 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) {
+TEST(CSPParser, FuzzyPoliciesIncDir)
+{
   // init srand with 0 so we get same results
   srand(0);
 
   PolicyTest testPol[1];
   memset(&testPol[0].policy, '\0', kMaxPolicyLength);
 
   char defaultSrc[] = "default-src ";
   int defaultSrcLen = sizeof(defaultSrc) - 1;
@@ -1081,17 +1095,18 @@ TEST(CSPParser, FuzzyPoliciesIncDir) {
 
 // ====================== TestFuzzyPoliciesIncDirLimASCII ============
 
 // Same as TestFuzzyPoliciesIncDir() but using limited ASCII,
 // which represents more likely input.
 
 #if RUN_OFFLINE_TESTS
 
-TEST(CSPParser, FuzzyPoliciesIncDirLimASCII) {
+TEST(CSPParser, FuzzyPoliciesIncDirLimASCII)
+{
   char input[] =
       "1234567890"
       "abcdefghijklmnopqrstuvwxyz"
       "ABCDEFGHIJKLMNOPQRSTUVWZYZ"
       "!@#^&*()-+_=";
 
   // init srand with 0 so we get same results
   srand(0);
--- a/dom/security/test/gtest/TestSecureContext.cpp
+++ b/dom/security/test/gtest/TestSecureContext.cpp
@@ -21,17 +21,18 @@ static const uint32_t kURIMaxLength = 64
 
 struct TestExpectations {
   char uri[kURIMaxLength];
   bool expectedResult;
 };
 
 // ============================= TestDirectives ========================
 
-TEST(SecureContext, IsOriginPotentiallyTrustworthyWithCodeBasePrincipal) {
+TEST(SecureContext, IsOriginPotentiallyTrustworthyWithCodeBasePrincipal)
+{
   // boolean isOriginPotentiallyTrustworthy(in nsIPrincipal aPrincipal);
 
   static const TestExpectations uris[] = {
       {"http://example.com/", false},
       {"https://example.com/", true},
       {"ws://example.com/", false},
       {"wss://example.com/", true},
       {"file:///xyzzy", true},
@@ -63,33 +64,35 @@ TEST(SecureContext, IsOriginPotentiallyT
     bool isPotentiallyTrustworthy = false;
     rv = csManager->IsOriginPotentiallyTrustworthy(prin,
                                                    &isPotentiallyTrustworthy);
     ASSERT_EQ(NS_OK, rv);
     ASSERT_EQ(isPotentiallyTrustworthy, uris[i].expectedResult);
   }
 }
 
-TEST(SecureContext, IsOriginPotentiallyTrustworthyWithSystemPrincipal) {
+TEST(SecureContext, IsOriginPotentiallyTrustworthyWithSystemPrincipal)
+{
   RefPtr<nsScriptSecurityManager> ssManager =
       nsScriptSecurityManager::GetScriptSecurityManager();
   ASSERT_TRUE(!!ssManager);
   nsCOMPtr<nsIContentSecurityManager> csManager =
       do_GetService(NS_CONTENTSECURITYMANAGER_CONTRACTID);
   ASSERT_TRUE(!!csManager);
 
   nsCOMPtr<nsIPrincipal> sysPrin = nsContentUtils::GetSystemPrincipal();
   bool isPotentiallyTrustworthy;
   nsresult rv = csManager->IsOriginPotentiallyTrustworthy(
       sysPrin, &isPotentiallyTrustworthy);
   ASSERT_EQ(rv, NS_OK);
   ASSERT_TRUE(isPotentiallyTrustworthy);
 }
 
-TEST(SecureContext, IsOriginPotentiallyTrustworthyWithNullPrincipal) {
+TEST(SecureContext, IsOriginPotentiallyTrustworthyWithNullPrincipal)
+{
   RefPtr<nsScriptSecurityManager> ssManager =
       nsScriptSecurityManager::GetScriptSecurityManager();
   ASSERT_TRUE(!!ssManager);
   nsCOMPtr<nsIContentSecurityManager> csManager =
       do_GetService(NS_CONTENTSECURITYMANAGER_CONTRACTID);
   ASSERT_TRUE(!!csManager);
 
   RefPtr<NullPrincipal> nullPrin =
--- a/dom/serviceworkers/test/gtest/TestReadWrite.cpp
+++ b/dom/serviceworkers/test/gtest/TestReadWrite.cpp
@@ -76,19 +76,21 @@ bool CreateFile(const nsACString& aData)
 
   if (count != aData.Length()) {
     return false;
   }
 
   return true;
 }
 
-TEST(ServiceWorkerRegistrar, TestNoFile) {
+TEST(ServiceWorkerRegistrar, TestNoFile)
+{
   nsCOMPtr<nsIFile> file = GetFile();
-  ASSERT_TRUE(file) << "GetFile must return a nsIFIle";
+  ASSERT_TRUE(file)
+  << "GetFile must return a nsIFIle";
 
   bool exists;
   nsresult rv = file->Exists(&exists);
   ASSERT_EQ(NS_OK, rv) << "nsIFile::Exists cannot fail";
 
   if (exists) {
     rv = file->Remove(false);
     ASSERT_EQ(NS_OK, rv) << "nsIFile::Remove cannot fail";
@@ -99,62 +101,67 @@ TEST(ServiceWorkerRegistrar, TestNoFile)
   rv = swr->TestReadData();
   ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail";
 
   const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData();
   ASSERT_EQ((uint32_t)0, data.Length())
       << "No data should be found in an empty file";
 }
 
-TEST(ServiceWorkerRegistrar, TestEmptyFile) {
-  ASSERT_TRUE(CreateFile(EmptyCString())) << "CreateFile should not fail";
+TEST(ServiceWorkerRegistrar, TestEmptyFile)
+{
+  ASSERT_TRUE(CreateFile(EmptyCString()))
+  << "CreateFile should not fail";
 
   RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
   nsresult rv = swr->TestReadData();
   ASSERT_NE(NS_OK, rv) << "ReadData() should fail if the file is empty";
 
   const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData();
   ASSERT_EQ((uint32_t)0, data.Length())
       << "No data should be found in an empty file";
 }
 
-TEST(ServiceWorkerRegistrar, TestRightVersionFile) {
+TEST(ServiceWorkerRegistrar, TestRightVersionFile)
+{
   ASSERT_TRUE(
       CreateFile(NS_LITERAL_CSTRING(SERVICEWORKERREGISTRAR_VERSION "\n")))
-      << "CreateFile should not fail";
+  << "CreateFile should not fail";
 
   RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
   nsresult rv = swr->TestReadData();
   ASSERT_EQ(NS_OK, rv)
       << "ReadData() should not fail when the version is correct";
 
   const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData();
   ASSERT_EQ((uint32_t)0, data.Length())
       << "No data should be found in an empty file";
 }
 
-TEST(ServiceWorkerRegistrar, TestWrongVersionFile) {
+TEST(ServiceWorkerRegistrar, TestWrongVersionFile)
+{
   ASSERT_TRUE(
       CreateFile(NS_LITERAL_CSTRING(SERVICEWORKERREGISTRAR_VERSION "bla\n")))
-      << "CreateFile should not fail";
+  << "CreateFile should not fail";
 
   RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
   nsresult rv = swr->TestReadData();
   ASSERT_NE(NS_OK, rv)
       << "ReadData() should fail when the version is not correct";
 
   const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData();
   ASSERT_EQ((uint32_t)0, data.Length())
       << "No data should be found in an empty file";
 }
 
-TEST(ServiceWorkerRegistrar, TestReadData) {
+TEST(ServiceWorkerRegistrar, TestReadData)
+{
   nsAutoCString buffer(SERVICEWORKERREGISTRAR_VERSION "\n");
 
   buffer.AppendLiteral("^appId=123&inBrowser=1\n");
   buffer.AppendLiteral("https://scope_0.org\ncurrentWorkerURL 0\n");
   buffer.Append(SERVICEWORKERREGISTRAR_TRUE "\n");
   buffer.AppendLiteral("cacheName 0\n");
   buffer.AppendInt(nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS,
                    16);
@@ -177,17 +184,18 @@ TEST(ServiceWorkerRegistrar, TestReadDat
   buffer.AppendInt(ts);
   buffer.AppendLiteral("\n");
   buffer.AppendInt(ts);
   buffer.AppendLiteral("\n");
   buffer.AppendInt(ts);
   buffer.AppendLiteral("\n");
   buffer.Append(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
-  ASSERT_TRUE(CreateFile(buffer)) << "CreateFile should not fail";
+  ASSERT_TRUE(CreateFile(buffer))
+  << "CreateFile should not fail";
 
   RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
   nsresult rv = swr->TestReadData();
   ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail";
 
   const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData();
   ASSERT_EQ((uint32_t)2, data.Length()) << "2 entries should be found";
@@ -228,34 +236,37 @@ TEST(ServiceWorkerRegistrar, TestReadDat
   ASSERT_STREQ("cacheName 1", NS_ConvertUTF16toUTF8(data[1].cacheName()).get());
   ASSERT_EQ(nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_ALL,
             data[1].updateViaCache());
   ASSERT_EQ((int64_t)ts, data[1].currentWorkerInstalledTime());
   ASSERT_EQ((int64_t)ts, data[1].currentWorkerActivatedTime());
   ASSERT_EQ((int64_t)ts, data[1].lastUpdateTime());
 }
 
-TEST(ServiceWorkerRegistrar, TestDeleteData) {
+TEST(ServiceWorkerRegistrar, TestDeleteData)
+{
   ASSERT_TRUE(CreateFile(NS_LITERAL_CSTRING("Foobar")))
-      << "CreateFile should not fail";
+  << "CreateFile should not fail";
 
   RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
   swr->TestDeleteData();
 
   nsCOMPtr<nsIFile> file = GetFile();
 
   bool exists;
   nsresult rv = file->Exists(&exists);
   ASSERT_EQ(NS_OK, rv) << "nsIFile::Exists cannot fail";
 
-  ASSERT_FALSE(exists) << "The file should not exist after a DeleteData().";
+  ASSERT_FALSE(exists)
+  << "The file should not exist after a DeleteData().";
 }
 
-TEST(ServiceWorkerRegistrar, TestWriteData) {
+TEST(ServiceWorkerRegistrar, TestWriteData)
+{
   {
     RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
     for (int i = 0; i < 10; ++i) {
       ServiceWorkerRegistrationData reg;
 
       reg.scope() = nsPrintfCString("https://scope_write_%d.org", i);
       reg.currentWorkerURL() = nsPrintfCString("currentWorkerURL write %d", i);
@@ -327,34 +338,36 @@ TEST(ServiceWorkerRegistrar, TestWriteDa
               data[i].updateViaCache());
 
     ASSERT_NE((int64_t)0, data[i].currentWorkerInstalledTime());
     ASSERT_NE((int64_t)0, data[i].currentWorkerActivatedTime());
     ASSERT_NE((int64_t)0, data[i].lastUpdateTime());
   }
 }
 
-TEST(ServiceWorkerRegistrar, TestVersion2Migration) {
+TEST(ServiceWorkerRegistrar, TestVersion2Migration)
+{
   nsAutoCString buffer(
       "2"
       "\n");
 
   buffer.AppendLiteral("^appId=123&inBrowser=1\n");
   buffer.AppendLiteral(
       "spec 0\nhttps://scope_0.org\nscriptSpec 0\ncurrentWorkerURL "
       "0\nactiveCache 0\nwaitingCache 0\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
   buffer.AppendLiteral("\n");
   buffer.AppendLiteral(
       "spec 1\nhttps://scope_1.org\nscriptSpec 1\ncurrentWorkerURL "
       "1\nactiveCache 1\nwaitingCache 1\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
-  ASSERT_TRUE(CreateFile(buffer)) << "CreateFile should not fail";
+  ASSERT_TRUE(CreateFile(buffer))
+  << "CreateFile should not fail";
 
   RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
   nsresult rv = swr->TestReadData();
   ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail";
 
   const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData();
   ASSERT_EQ((uint32_t)2, data.Length()) << "2 entries should be found";
@@ -397,32 +410,34 @@ TEST(ServiceWorkerRegistrar, TestVersion
                NS_ConvertUTF16toUTF8(data[1].cacheName()).get());
   ASSERT_EQ(nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS,
             data[1].updateViaCache());
   ASSERT_EQ((int64_t)0, data[1].currentWorkerInstalledTime());
   ASSERT_EQ((int64_t)0, data[1].currentWorkerActivatedTime());
   ASSERT_EQ((int64_t)0, data[1].lastUpdateTime());
 }
 
-TEST(ServiceWorkerRegistrar, TestVersion3Migration) {
+TEST(ServiceWorkerRegistrar, TestVersion3Migration)
+{
   nsAutoCString buffer(
       "3"
       "\n");
 
   buffer.AppendLiteral("^appId=123&inBrowser=1\n");
   buffer.AppendLiteral(
       "spec 0\nhttps://scope_0.org\ncurrentWorkerURL 0\ncacheName 0\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
   buffer.AppendLiteral("\n");
   buffer.AppendLiteral(
       "spec 1\nhttps://scope_1.org\ncurrentWorkerURL 1\ncacheName 1\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
-  ASSERT_TRUE(CreateFile(buffer)) << "CreateFile should not fail";
+  ASSERT_TRUE(CreateFile(buffer))
+  << "CreateFile should not fail";
 
   RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
   nsresult rv = swr->TestReadData();
   ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail";
 
   const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData();
   ASSERT_EQ((uint32_t)2, data.Length()) << "2 entries should be found";
@@ -463,32 +478,34 @@ TEST(ServiceWorkerRegistrar, TestVersion
   ASSERT_STREQ("cacheName 1", NS_ConvertUTF16toUTF8(data[1].cacheName()).get());
   ASSERT_EQ(nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS,
             data[1].updateViaCache());
   ASSERT_EQ((int64_t)0, data[1].currentWorkerInstalledTime());
   ASSERT_EQ((int64_t)0, data[1].currentWorkerActivatedTime());
   ASSERT_EQ((int64_t)0, data[1].lastUpdateTime());
 }
 
-TEST(ServiceWorkerRegistrar, TestVersion4Migration) {
+TEST(ServiceWorkerRegistrar, TestVersion4Migration)
+{
   nsAutoCString buffer(
       "4"
       "\n");
 
   buffer.AppendLiteral("^appId=123&inBrowser=1\n");
   buffer.AppendLiteral(
       "https://scope_0.org\ncurrentWorkerURL 0\ncacheName 0\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
   buffer.AppendLiteral("\n");
   buffer.AppendLiteral(
       "https://scope_1.org\ncurrentWorkerURL 1\ncacheName 1\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
-  ASSERT_TRUE(CreateFile(buffer)) << "CreateFile should not fail";
+  ASSERT_TRUE(CreateFile(buffer))
+  << "CreateFile should not fail";
 
   RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
   nsresult rv = swr->TestReadData();
   ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail";
 
   const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData();
   ASSERT_EQ((uint32_t)2, data.Length()) << "2 entries should be found";
@@ -531,34 +548,36 @@ TEST(ServiceWorkerRegistrar, TestVersion
   ASSERT_STREQ("cacheName 1", NS_ConvertUTF16toUTF8(data[1].cacheName()).get());
   ASSERT_EQ(nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS,
             data[1].updateViaCache());
   ASSERT_EQ((int64_t)0, data[1].currentWorkerInstalledTime());
   ASSERT_EQ((int64_t)0, data[1].currentWorkerActivatedTime());
   ASSERT_EQ((int64_t)0, data[1].lastUpdateTime());
 }
 
-TEST(ServiceWorkerRegistrar, TestVersion5Migration) {
+TEST(ServiceWorkerRegistrar, TestVersion5Migration)
+{
   nsAutoCString buffer(
       "5"
       "\n");
 
   buffer.AppendLiteral("^appId=123&inBrowser=1\n");
   buffer.AppendLiteral("https://scope_0.org\ncurrentWorkerURL 0\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TRUE "\n");
   buffer.AppendLiteral("cacheName 0\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
   buffer.AppendLiteral("\n");
   buffer.AppendLiteral("https://scope_1.org\ncurrentWorkerURL 1\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_FALSE "\n");
   buffer.AppendLiteral("cacheName 1\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
-  ASSERT_TRUE(CreateFile(buffer)) << "CreateFile should not fail";
+  ASSERT_TRUE(CreateFile(buffer))
+  << "CreateFile should not fail";
 
   RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
   nsresult rv = swr->TestReadData();
   ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail";
 
   const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData();
   ASSERT_EQ((uint32_t)2, data.Length()) << "2 entries should be found";
@@ -599,17 +618,18 @@ TEST(ServiceWorkerRegistrar, TestVersion
   ASSERT_STREQ("cacheName 1", NS_ConvertUTF16toUTF8(data[1].cacheName()).get());
   ASSERT_EQ(nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS,
             data[1].updateViaCache());
   ASSERT_EQ((int64_t)0, data[1].currentWorkerInstalledTime());
   ASSERT_EQ((int64_t)0, data[1].currentWorkerActivatedTime());
   ASSERT_EQ((int64_t)0, data[1].lastUpdateTime());
 }
 
-TEST(ServiceWorkerRegistrar, TestVersion6Migration) {
+TEST(ServiceWorkerRegistrar, TestVersion6Migration)
+{
   nsAutoCString buffer(
       "6"
       "\n");
 
   buffer.AppendLiteral("^appId=123&inBrowser=1\n");
   buffer.AppendLiteral("https://scope_0.org\ncurrentWorkerURL 0\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TRUE "\n");
   buffer.AppendLiteral("cacheName 0\n");
@@ -620,17 +640,18 @@ TEST(ServiceWorkerRegistrar, TestVersion
   buffer.AppendLiteral("\n");
   buffer.AppendLiteral("https://scope_1.org\ncurrentWorkerURL 1\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_FALSE "\n");
   buffer.AppendLiteral("cacheName 1\n");
   buffer.AppendInt(nsIRequest::VALIDATE_ALWAYS, 16);
   buffer.AppendLiteral("\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
-  ASSERT_TRUE(CreateFile(buffer)) << "CreateFile should not fail";
+  ASSERT_TRUE(CreateFile(buffer))
+  << "CreateFile should not fail";
 
   RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
   nsresult rv = swr->TestReadData();
   ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail";
 
   const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData();
   ASSERT_EQ((uint32_t)2, data.Length()) << "2 entries should be found";
@@ -671,17 +692,18 @@ TEST(ServiceWorkerRegistrar, TestVersion
   ASSERT_STREQ("cacheName 1", NS_ConvertUTF16toUTF8(data[1].cacheName()).get());
   ASSERT_EQ(nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS,
             data[1].updateViaCache());
   ASSERT_EQ((int64_t)0, data[1].currentWorkerInstalledTime());
   ASSERT_EQ((int64_t)0, data[1].currentWorkerActivatedTime());
   ASSERT_EQ((int64_t)0, data[1].lastUpdateTime());
 }
 
-TEST(ServiceWorkerRegistrar, TestVersion7Migration) {
+TEST(ServiceWorkerRegistrar, TestVersion7Migration)
+{
   nsAutoCString buffer(
       "7"
       "\n");
 
   buffer.AppendLiteral("^appId=123&inBrowser=1\n");
   buffer.AppendLiteral("https://scope_0.org\ncurrentWorkerURL 0\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TRUE "\n");
   buffer.AppendLiteral("cacheName 0\n");
@@ -705,17 +727,18 @@ TEST(ServiceWorkerRegistrar, TestVersion
   buffer.AppendInt(ts);
   buffer.AppendLiteral("\n");
   buffer.AppendInt(ts);
   buffer.AppendLiteral("\n");
   buffer.AppendInt(ts);
   buffer.AppendLiteral("\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
-  ASSERT_TRUE(CreateFile(buffer)) << "CreateFile should not fail";
+  ASSERT_TRUE(CreateFile(buffer))
+  << "CreateFile should not fail";
 
   RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
   nsresult rv = swr->TestReadData();
   ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail";
 
   const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData();
   ASSERT_EQ((uint32_t)2, data.Length()) << "2 entries should be found";
@@ -756,17 +779,18 @@ TEST(ServiceWorkerRegistrar, TestVersion
   ASSERT_STREQ("cacheName 1", NS_ConvertUTF16toUTF8(data[1].cacheName()).get());
   ASSERT_EQ(nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS,
             data[1].updateViaCache());
   ASSERT_EQ((int64_t)ts, data[1].currentWorkerInstalledTime());
   ASSERT_EQ((int64_t)ts, data[1].currentWorkerActivatedTime());
   ASSERT_EQ((int64_t)ts, data[1].lastUpdateTime());
 }
 
-TEST(ServiceWorkerRegistrar, TestDedupeRead) {
+TEST(ServiceWorkerRegistrar, TestDedupeRead)
+{
   nsAutoCString buffer(
       "3"
       "\n");
 
   // unique entries
   buffer.AppendLiteral("^appId=123&inBrowser=1\n");
   buffer.AppendLiteral(
       "spec 0\nhttps://scope_0.org\ncurrentWorkerURL 0\ncacheName 0\n");
@@ -788,17 +812,18 @@ TEST(ServiceWorkerRegistrar, TestDedupeR
       "spec 2\nhttps://scope_0.org\ncurrentWorkerURL 0\ncacheName 0\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
   buffer.AppendLiteral("\n");
   buffer.AppendLiteral(
       "spec 3\nhttps://scope_1.org\ncurrentWorkerURL 1\ncacheName 1\n");
   buffer.AppendLiteral(SERVICEWORKERREGISTRAR_TERMINATOR "\n");
 
-  ASSERT_TRUE(CreateFile(buffer)) << "CreateFile should not fail";
+  ASSERT_TRUE(CreateFile(buffer))
+  << "CreateFile should not fail";
 
   RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
   nsresult rv = swr->TestReadData();
   ASSERT_EQ(NS_OK, rv) << "ReadData() should not fail";
 
   const nsTArray<ServiceWorkerRegistrationData>& data = swr->TestGetData();
   ASSERT_EQ((uint32_t)2, data.Length()) << "2 entries should be found";
@@ -839,17 +864,18 @@ TEST(ServiceWorkerRegistrar, TestDedupeR
   ASSERT_STREQ("cacheName 1", NS_ConvertUTF16toUTF8(data[1].cacheName()).get());
   ASSERT_EQ(nsIServiceWorkerRegistrationInfo::UPDATE_VIA_CACHE_IMPORTS,
             data[1].updateViaCache());
   ASSERT_EQ((int64_t)0, data[1].currentWorkerInstalledTime());
   ASSERT_EQ((int64_t)0, data[1].currentWorkerActivatedTime());
   ASSERT_EQ((int64_t)0, data[1].lastUpdateTime());
 }
 
-TEST(ServiceWorkerRegistrar, TestDedupeWrite) {
+TEST(ServiceWorkerRegistrar, TestDedupeWrite)
+{
   {
     RefPtr<ServiceWorkerRegistrarTest> swr = new ServiceWorkerRegistrarTest;
 
     for (int i = 0; i < 10; ++i) {
       ServiceWorkerRegistrationData reg;
 
       reg.scope() = NS_LITERAL_CSTRING("https://scope_write.dedupe");
       reg.currentWorkerURL() = nsPrintfCString("currentWorkerURL write %d", i);
--- a/editor/txmgr/tests/TestTXMgr.cpp
+++ b/editor/txmgr/tests/TestTXMgr.cpp
@@ -1174,17 +1174,18 @@ void quick_test(TestTransactionFactory *
   rv = mgr->GetNumberOfRedoItems(&numitems);
   EXPECT_TRUE(NS_SUCCEEDED(rv));
   EXPECT_EQ(numitems, 10);
 
   rv = mgr->Clear();
   EXPECT_TRUE(NS_SUCCEEDED(rv));
 }
 
-TEST(TestTXMgr, SimpleTest) {
+TEST(TestTXMgr, SimpleTest)
+{
   /*******************************************************************
    *
    * Initialize globals for test.
    *
    *******************************************************************/
   reset_globals();
   sDoOrderArr = sSimpleTestDoOrderArr;
   sUndoOrderArr = sSimpleTestUndoOrderArr;
@@ -1196,17 +1197,18 @@ TEST(TestTXMgr, SimpleTest) {
    *
    *******************************************************************/
 
   SimpleTransactionFactory factory;
 
   quick_test(&factory);
 }
 
-TEST(TestTXMgr, AggregationTest) {
+TEST(TestTXMgr, AggregationTest)
+{
   /*******************************************************************
    *
    * Initialize globals for test.
    *
    *******************************************************************/
 
   reset_globals();
   sDoOrderArr = sAggregateTestDoOrderArr;
@@ -1801,17 +1803,18 @@ void quick_batch_test(TestTransactionFac
   rv = mgr->GetNumberOfRedoItems(&numitems);
   EXPECT_TRUE(NS_SUCCEEDED(rv));
   EXPECT_EQ(numitems, 10);
 
   rv = mgr->Clear();
   EXPECT_TRUE(NS_SUCCEEDED(rv));
 }
 
-TEST(TestTXMgr, SimpleBatchTest) {
+TEST(TestTXMgr, SimpleBatchTest)
+{
   /*******************************************************************
    *
    * Initialize globals for test.
    *
    *******************************************************************/
   reset_globals();
   sDoOrderArr = sSimpleBatchTestDoOrderArr;
   sUndoOrderArr = sSimpleBatchTestUndoOrderArr;
@@ -1822,17 +1825,18 @@ TEST(TestTXMgr, SimpleBatchTest) {
    * Run the quick batch test.
    *
    *******************************************************************/
 
   SimpleTransactionFactory factory;
   quick_batch_test(&factory);
 }
 
-TEST(TestTXMgr, AggregationBatchTest) {
+TEST(TestTXMgr, AggregationBatchTest)
+{
   /*******************************************************************
    *
    * Initialize globals for test.
    *
    *******************************************************************/
 
   reset_globals();
   sDoOrderArr = sAggregateBatchTestDoOrderArr;
@@ -1914,17 +1918,18 @@ void stress_test(TestTransactionFactory 
       EXPECT_TRUE(NS_SUCCEEDED(rv));
     }
   }
 
   rv = mgr->Clear();
   EXPECT_TRUE(NS_SUCCEEDED(rv));
 }
 
-TEST(TestTXMgr, SimpleStressTest) {
+TEST(TestTXMgr, SimpleStressTest)
+{
   /*******************************************************************
    *
    * Initialize globals for test.
    *
    *******************************************************************/
 
   reset_globals();
 
@@ -1944,17 +1949,18 @@ TEST(TestTXMgr, SimpleStressTest) {
       // 1500 iterations sends 1,125,750 transactions through the system!!
       //
       1500
 #endif
       ;
   stress_test(&factory, iterations);
 }
 
-TEST(TestTXMgr, AggregationStressTest) {
+TEST(TestTXMgr, AggregationStressTest)
+{
   /*******************************************************************
    *
    * Initialize globals for test.
    *
    *******************************************************************/
 
   reset_globals();
 
@@ -1974,17 +1980,18 @@ TEST(TestTXMgr, AggregationStressTest) {
       // 500 iterations sends 2,630,250 transactions through the system!!
       //
       500
 #endif
       ;
   stress_test(&factory, iterations);
 }
 
-TEST(TestTXMgr, AggregationBatchStressTest) {
+TEST(TestTXMgr, AggregationBatchStressTest)
+{
   /*******************************************************************
    *
    * Initialize globals for test.
    *
    *******************************************************************/
 
   reset_globals();
 
--- a/gfx/2d/unittest/TestCairo.cpp
+++ b/gfx/2d/unittest/TestCairo.cpp
@@ -22,40 +22,43 @@ static void TryCircle(double centerX, do
   cairo_set_antialias(cairo, CAIRO_ANTIALIAS_NONE);
   cairo_arc(cairo, 0.0, centerY, radius, 0.0, 6.2831853071795862);
   cairo_fill_preserve(cairo);
 
   cairo_surface_destroy(surf);
   cairo_destroy(cairo);
 }
 
-TEST(Cairo, Simple) {
+TEST(Cairo, Simple)
+{
   TryCircle(0.0, 0.0, 14.0);
   TryCircle(0.0, 1.0, 22.4);
   TryCircle(1.0, 0.0, 1422.4);
   TryCircle(1.0, 1.0, 3422.4);
   TryCircle(-10.0, 1.0, -2);
 }
 
-TEST(Cairo, Bug825721) {
+TEST(Cairo, Bug825721)
+{
   // OK:
   TryCircle(0.0, 0.0, 8761126469220696064.0);
   TryCircle(0.0, 1.0, 8761126469220696064.0);
 
   // OK:
   TryCircle(1.0, 0.0, 5761126469220696064.0);
 
   // This was the crash in 825721.  Note that centerY has to be non-zero,
   // and radius has to be not only large, but in particular range.
   // 825721 has a band-aid fix, where the crash is inevitable, but does
   // not fix the cause.  The same code crashes in cairo standalone.
   TryCircle(0.0, 1.0, 5761126469220696064.0);
 }
 
-TEST(Cairo, Bug1063486) {
+TEST(Cairo, Bug1063486)
+{
   double x1, y1, x2, y2;
   const double epsilon = .01;
 
   cairo_surface_t *surf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1);
   ASSERT_TRUE(surf != nullptr);
 
   cairo_t *cairo = cairo_create(surf);
   ASSERT_TRUE(cairo != nullptr);
--- a/gfx/tests/gtest/PolygonTestUtils.cpp
+++ b/gfx/tests/gtest/PolygonTestUtils.cpp
@@ -79,17 +79,18 @@ bool operator==(const MozPolygon& lhs, c
   }
 
   return true;
 }
 
 }  // namespace gfx
 }  // namespace mozilla
 
-TEST(PolygonTestUtils, TestSanity) {
+TEST(PolygonTestUtils, TestSanity)
+{
   EXPECT_TRUE(FuzzyEquals(Point4D(0.0f, 0.0f, 0.0f, 1.0f),
                           Point4D(0.0f, 0.0f, 0.0f, 1.0f)));
 
   EXPECT_TRUE(FuzzyEquals(Point4D(0.0f, 0.0f, 0.0f, 1.0f),
                           Point4D(0.00001f, 0.00001f, 0.00001f, 1.0f)));
 
   EXPECT_TRUE(FuzzyEquals(Point4D(0.00001f, 0.00001f, 0.00001f, 1.0f),
                           Point4D(0.0f, 0.0f, 0.0f, 1.0f)));
--- a/gfx/tests/gtest/TestArena.cpp
+++ b/gfx/tests/gtest/TestArena.cpp
@@ -151,22 +151,24 @@ static void TestArenaLimit(IterableArena
   }
   ASSERT_EQ(reachedLimit, aShouldReachLimit);
 }
 
 }  // namespace test_arena
 
 using namespace test_arena;
 
-TEST(Moz2D, FixedArena) {
+TEST(Moz2D, FixedArena)
+{
   TestArenaAlloc(IterableArena::FIXED_SIZE);
   TestArenaLimit(IterableArena::FIXED_SIZE, true);
 }
 
-TEST(Moz2D, GrowableArena) {
+TEST(Moz2D, GrowableArena)
+{
   TestArenaAlloc(IterableArena::GROWABLE);
   TestArenaLimit(IterableArena::GROWABLE, false);
 
   IterableArena arena(IterableArena::GROWABLE, 16);
   // sizeof(BigStruct) is more than twice the initial capacity, make sure that
   // this doesn't blow everything up, since the arena doubles its storage size
   // each time it grows (until it finds a size that fits).
   auto a = arena.Alloc<BigStruct>(1);
--- a/gfx/tests/gtest/TestArrayView.cpp
+++ b/gfx/tests/gtest/TestArrayView.cpp
@@ -6,14 +6,15 @@
 #include <limits>
 
 #include "gtest/gtest.h"
 
 #include "mozilla/ArrayView.h"
 
 using namespace mozilla::gfx;
 
-TEST(Gfx, ArrayView) {
+TEST(Gfx, ArrayView)
+{
   nsTArray<int> p = {5, 6};
   ArrayView<int> pv(p);
   ASSERT_EQ(pv[1], 6);
   ASSERT_EQ(*pv.Data(), 5);
 }
--- a/gfx/tests/gtest/TestBSPTree.cpp
+++ b/gfx/tests/gtest/TestBSPTree.cpp
@@ -33,66 +33,71 @@ static void RunTest(std::deque<MozPolygo
 
   for (size_t i = 0; i < order.Length(); ++i) {
     EXPECT_TRUE(aExpected[i] == *order[i].geometry);
   }
 }
 
 }  // namespace
 
-TEST(BSPTree, SameNode) {
+TEST(BSPTree, SameNode)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{
           Point4D(0.0f, 0.0f, 0.0f, 1.0f), Point4D(1.0f, 0.0f, 0.0f, 1.0f),
           Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(0.0f, 1.0f, 0.0f, 1.0f)},
       MozPolygon{
           Point4D(0.0f, 0.0f, 0.0f, 1.0f), Point4D(1.0f, 0.0f, 0.0f, 1.0f),
           Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(0.0f, 1.0f, 0.0f, 1.0f)}};
 
   ::RunTest(polygons, polygons);
 }
 
-TEST(BSPTree, OneChild) {
+TEST(BSPTree, OneChild)
+{
   const MozPolygon p1{
       Point4D(0.0f, 0.0f, 0.0f, 1.0f), Point4D(1.0f, 0.0f, 0.0f, 1.0f),
       Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(0.0f, 1.0f, 0.0f, 1.0f)};
 
   const MozPolygon p2{
       Point4D(0.0f, 0.0f, 1.0f, 1.0f), Point4D(1.0f, 0.0f, 1.0f, 1.0f),
       Point4D(1.0f, 1.0f, 1.0f, 1.0f), Point4D(0.0f, 1.0f, 1.0f, 1.0f)};
 
   ::RunTest({p1, p2}, {p1, p2});
   ::RunTest({p2, p1}, {p1, p2});
 }
 
-TEST(BSPTree, SharedEdge1) {
+TEST(BSPTree, SharedEdge1)
+{
   MozPolygon p1{
       Point4D(1.0f, 0.0f, 1.0f, 1.0f), Point4D(0.0f, 0.0f, 1.0f, 1.0f),
       Point4D(0.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f)};
 
   MozPolygon p2{
       Point4D(1.0f, 0.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f),
       Point4D(2.0f, 2.0f, 1.0f, 1.0f), Point4D(2.0f, 0.0f, 1.0f, 1.0f)};
 
   ::RunTest({p1, p2}, {p1, p2});
 }
 
-TEST(BSPTree, SharedEdge2) {
+TEST(BSPTree, SharedEdge2)
+{
   MozPolygon p1{
       Point4D(1.0f, 0.0f, 1.0f, 1.0f), Point4D(0.0f, 0.0f, 1.0f, 1.0f),
       Point4D(0.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f)};
 
   MozPolygon p2{
       Point4D(1.0f, 0.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f),
       Point4D(2.0f, 2.0f, 0.0f, 1.0f), Point4D(2.0f, 0.0f, 0.0f, 1.0f)};
 
   ::RunTest({p1, p2}, {p2, p1});
 }
 
-TEST(BSPTree, SplitSharedEdge) {
+TEST(BSPTree, SplitSharedEdge)
+{
   MozPolygon p1{
       Point4D(1.0f, 0.0f, 1.0f, 1.0f), Point4D(0.0f, 0.0f, 1.0f, 1.0f),
       Point4D(0.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f)};
 
   MozPolygon p2{
       Point4D(1.0f, 0.0f, 2.0f, 1.0f), Point4D(1.0f, 1.0f, 2.0f, 1.0f),
       Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(1.0f, 0.0f, 0.0f, 1.0f)};
 
@@ -105,17 +110,18 @@ TEST(BSPTree, SplitSharedEdge) {
           Point4D(0.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f)},
       MozPolygon{
           Point4D(1.0f, 0.0f, 2.0f, 1.0f), Point4D(1.0f, 1.0f, 2.0f, 1.0f),
           Point4D(1.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 0.0f, 1.0f, 1.0f)}};
 
   ::RunTest({p1, p2}, expected);
 }
 
-TEST(BSPTree, SplitSimple1) {
+TEST(BSPTree, SplitSimple1)
+{
   MozPolygon p1{
       Point4D(0.0f, 0.0f, 1.0f, 1.0f), Point4D(1.0f, 0.0f, 1.0f, 1.0f),
       Point4D(1.0f, 1.0f, 1.0f, 1.0f), Point4D(0.0f, 1.0f, 1.0f, 1.0f)};
 
   MozPolygon p2{
       Point4D(0.0f, 0.0f, 2.0f, 1.0f), Point4D(1.0f, 0.0f, 2.0f, 1.0f),
       Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(0.0f, 1.0f, 0.0f, 1.0f)};
 
@@ -126,17 +132,18 @@ TEST(BSPTree, SplitSimple1) {
       p1,
       MozPolygon{
           Point4D(0.0f, 0.0f, 2.0f, 1.0f), Point4D(1.0f, 0.0f, 2.0f, 1.0f),
           Point4D(1.0f, 0.5f, 1.0f, 1.0f), Point4D(0.0f, 0.5f, 1.0f, 1.0f)}};
 
   ::RunTest({p1, p2}, expected);
 }
 
-TEST(BSPTree, SplitSimple2) {
+TEST(BSPTree, SplitSimple2)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-5.00000f, -5.00000f, 0.00000f, 1.0f),
                  Point4D(-5.00000f, 5.00000f, 0.00000f, 1.0f),
                  Point4D(5.00000f, 5.00000f, 0.00000f, 1.0f),
                  Point4D(5.00000f, -5.00000f, 0.00000f, 1.0f)},
       MozPolygon{Point4D(0.00000f, -5.00000f, -5.00000f, 1.0f),
                  Point4D(0.00000f, 5.00000f, -5.00000f, 1.0f),
                  Point4D(0.00000f, 5.00000f, 5.00000f, 1.0f),
@@ -153,17 +160,18 @@ TEST(BSPTree, SplitSimple2) {
                  Point4D(5.00000f, -5.00000f, 0.00000f, 1.0f)},
       MozPolygon{Point4D(0.00000f, 5.00000f, 0.00000f, 1.0f),
                  Point4D(0.00000f, 5.00000f, 5.00000f, 1.0f),
                  Point4D(0.00000f, -5.00000f, 5.00000f, 1.0f),
                  Point4D(0.00000f, -5.00000f, 0.00000f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, NoSplit1) {
+TEST(BSPTree, NoSplit1)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(0.00000f, 10.00000f, 0.00000f, 1.0f),
                  Point4D(0.00000f, 0.00000f, 0.00000f, 1.0f),
                  Point4D(10.00000f, 0.00000f, 0.00000f, 1.0f),
                  Point4D(10.00000f, 10.00000f, 0.00000f, 1.0f)},
       MozPolygon{Point4D(0.00000f, 10.00000f, -5.00000f, 1.0f),
                  Point4D(0.00000f, 0.00000f, -5.00000f, 1.0f),
                  Point4D(10.00000f, 0.00000f, -5.00000f, 1.0f),
@@ -184,17 +192,18 @@ TEST(BSPTree, NoSplit1) {
                  Point4D(10.00000f, 10.00000f, 0.00000f, 1.0f)},
       MozPolygon{Point4D(0.00000f, 10.00000f, 5.00000f, 1.0f),
                  Point4D(0.00000f, 0.00000f, 5.00000f, 1.0f),
                  Point4D(10.00000f, 0.00000f, 5.00000f, 1.0f),
                  Point4D(10.00000f, 10.00000f, 5.00000f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, NoSplit2) {
+TEST(BSPTree, NoSplit2)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-5.00000f, -5.00000f, 0.00000f, 1.0f),
                  Point4D(-5.00000f, 5.00000f, 0.00000f, 1.0f),
                  Point4D(5.00000f, 5.00000f, 0.00000f, 1.0f),
                  Point4D(5.00000f, -5.00000f, 0.00000f, 1.0f)},
       MozPolygon{Point4D(0.00000f, 5.00000f, -15.00000f, 1.0f),
                  Point4D(0.00000f, -5.00000f, -15.00000f, 1.0f),
                  Point4D(0.00000f, -5.00000f, -10.00000f, 1.0f),
@@ -207,17 +216,18 @@ TEST(BSPTree, NoSplit2) {
                  Point4D(0.00000f, 5.00000f, -10.00000f, 1.0f)},
       MozPolygon{Point4D(-5.00000f, -5.00000f, 0.00000f, 1.0f),
                  Point4D(-5.00000f, 5.00000f, 0.00000f, 1.0f),
                  Point4D(5.00000f, 5.00000f, 0.00000f, 1.0f),
                  Point4D(5.00000f, -5.00000f, 0.00000f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate0degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate0degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, 2.00000f, 2.00000f, 1.0f),
                  Point4D(-0.00000f, -2.00000f, 2.00000f, 1.0f),
                  Point4D(0.00010f, -2.00000f, -2.00000f, 1.0f),
                  Point4D(0.00010f, 2.00000f, -2.00000f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 0.00000f, 2.00000f, 1.0f),
                  Point4D(2.00000f, -0.00000f, -2.00000f, 1.0f),
                  Point4D(-2.00000f, 0.00000f, -2.00000f, 1.0f),
@@ -230,17 +240,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate0de
                  Point4D(-2.00000f, 0.00010f, 2.00000f, 1.0f)},
       MozPolygon{Point4D(-0.00000f, 2.00000f, 2.00000f, 1.0f),
                  Point4D(-0.00000f, -2.00000f, 2.00000f, 1.0f),
                  Point4D(0.00010f, -2.00000f, -2.00000f, 1.0f),
                  Point4D(0.00010f, 2.00000f, -2.00000f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate20degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate20degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, 1.19540f, 2.56350f, 1.0f),
                  Point4D(-0.00000f, -2.56340f, 1.19540f, 1.0f),
                  Point4D(0.00010f, -1.19530f, -2.56340f, 1.0f),
                  Point4D(0.00010f, 2.56350f, -1.19530f, 1.0f)},
       MozPolygon{Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f),
                  Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f),
                  Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f),
@@ -253,17 +264,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate20d
                  Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f)},
       MozPolygon{Point4D(-0.00000f, 1.19540f, 2.56350f, 1.0f),
                  Point4D(-0.00000f, -2.56340f, 1.19540f, 1.0f),
                  Point4D(0.00010f, -1.19530f, -2.56340f, 1.0f),
                  Point4D(0.00010f, 2.56350f, -1.19530f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate40degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate40degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, -0.73200f, 2.73210f, 1.0f),
                  Point4D(-0.00000f, -2.73200f, -0.73200f, 1.0f),
                  Point4D(0.00010f, 0.73210f, -2.73200f, 1.0f),
                  Point4D(0.00010f, 2.73210f, 0.73210f, 1.0f)},
       MozPolygon{Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f),
                  Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f),
                  Point4D(-2.00000f, 1.73210f, -0.99990f, 1.0f),
@@ -276,17 +288,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate40d
                  Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f)},
       MozPolygon{Point4D(-0.00000f, -0.73200f, 2.73210f, 1.0f),
                  Point4D(-0.00000f, -2.73200f, -0.73200f, 1.0f),
                  Point4D(0.00010f, 0.73210f, -2.73200f, 1.0f),
                  Point4D(0.00010f, 2.73210f, 0.73210f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate60degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate60degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, -2.73200f, 0.73210f, 1.0f),
                  Point4D(-0.00000f, -0.73200f, -2.73200f, 1.0f),
                  Point4D(0.00010f, 2.73210f, -0.73200f, 1.0f),
                  Point4D(0.00010f, 0.73210f, 2.73210f, 1.0f)},
       MozPolygon{Point4D(2.00000f, -1.73200f, -1.00000f, 1.0f),
                  Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f),
                  Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f),
@@ -303,17 +316,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate60d
                  Point4D(0.00010f, 0.73210f, 2.73210f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 1.26793f, 0.73210f, 1.0f),
                  Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f),
                  Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f),
                  Point4D(-2.00000f, 1.26793f, 0.73210f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate80degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate80degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, -1.19530f, -2.56340f, 1.0f),
                  Point4D(-0.00000f, 2.56350f, -1.19530f, 1.0f),
                  Point4D(0.00010f, 1.19540f, 2.56350f, 1.0f),
                  Point4D(0.00010f, -2.56340f, 1.19540f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f),
                  Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f),
                  Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f),
@@ -326,17 +340,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate80d
                  Point4D(0.00010f, -2.56340f, 1.19540f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f),
                  Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f),
                  Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f),
                  Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate100degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate100degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, 2.73210f, -0.73200f, 1.0f),
                  Point4D(-0.00000f, 0.73210f, 2.73210f, 1.0f),
                  Point4D(0.00010f, -2.73200f, 0.73210f, 1.0f),
                  Point4D(0.00010f, -0.73200f, -2.73200f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f),
                  Point4D(2.00000f, -1.73200f, -1.00000f, 1.0f),
                  Point4D(-2.00000f, -1.73200f, -1.00000f, 1.0f),
@@ -353,17 +368,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate100
                  Point4D(0.00010f, -0.73200f, -2.73200f, 1.0f)},
       MozPolygon{Point4D(-2.00000f, -1.26783f, -0.73200f, 1.0f),
                  Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f),
                  Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f),
                  Point4D(2.00000f, -1.26783f, -0.73200f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate120degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate120degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, -0.73200f, 2.73210f, 1.0f),
                  Point4D(-0.00000f, -2.73200f, -0.73200f, 1.0f),
                  Point4D(0.00010f, 0.73210f, -2.73200f, 1.0f),
                  Point4D(0.00010f, 2.73210f, 0.73210f, 1.0f)},
       MozPolygon{Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f),
                  Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f),
                  Point4D(-2.00000f, 1.73210f, -0.99990f, 1.0f),
@@ -376,17 +392,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate120
                  Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f)},
       MozPolygon{Point4D(-0.00000f, -0.73200f, 2.73210f, 1.0f),
                  Point4D(-0.00000f, -2.73200f, -0.73200f, 1.0f),
                  Point4D(0.00010f, 0.73210f, -2.73200f, 1.0f),
                  Point4D(0.00010f, 2.73210f, 0.73210f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate140degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate140degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, -1.19530f, -2.56340f, 1.0f),
                  Point4D(-0.00000f, 2.56350f, -1.19530f, 1.0f),
                  Point4D(0.00010f, 1.19540f, 2.56350f, 1.0f),
                  Point4D(0.00010f, -2.56340f, 1.19540f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f),
                  Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f),
                  Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f),
@@ -399,17 +416,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate140
                  Point4D(0.00010f, -2.56340f, 1.19540f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f),
                  Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f),
                  Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f),
                  Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate160degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate160degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, 2.00000f, 2.00000f, 1.0f),
                  Point4D(-0.00000f, -2.00000f, 2.00000f, 1.0f),
                  Point4D(0.00010f, -2.00000f, -2.00000f, 1.0f),
                  Point4D(0.00010f, 2.00000f, -2.00000f, 1.0f)},
       MozPolygon{Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f),
                  Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f),
                  Point4D(-2.00000f, 0.00010f, -2.00000f, 1.0f),
@@ -422,17 +440,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate160
                  Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f)},
       MozPolygon{Point4D(-0.00000f, 2.00000f, 2.00000f, 1.0f),
                  Point4D(-0.00000f, -2.00000f, 2.00000f, 1.0f),
                  Point4D(0.00010f, -2.00000f, -2.00000f, 1.0f),
                  Point4D(0.00010f, 2.00000f, -2.00000f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate180degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate180degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, -2.00000f, -2.00000f, 1.0f),
                  Point4D(-0.00000f, 2.00000f, -2.00000f, 1.0f),
                  Point4D(0.00010f, 2.00000f, 2.00000f, 1.0f),
                  Point4D(0.00010f, -2.00000f, 2.00000f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f),
                  Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f),
                  Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f),
@@ -445,17 +464,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate180
                  Point4D(0.00010f, -2.00000f, 2.00000f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f),
                  Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f),
                  Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f),
                  Point4D(-2.00000f, 0.00010f, -2.00000f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate200degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate200degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, 1.19540f, 2.56350f, 1.0f),
                  Point4D(-0.00000f, -2.56340f, 1.19540f, 1.0f),
                  Point4D(0.00010f, -1.19530f, -2.56340f, 1.0f),
                  Point4D(0.00010f, 2.56350f, -1.19530f, 1.0f)},
       MozPolygon{Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f),
                  Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f),
                  Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f),
@@ -468,17 +488,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate200
                  Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f)},
       MozPolygon{Point4D(-0.00000f, 1.19540f, 2.56350f, 1.0f),
                  Point4D(-0.00000f, -2.56340f, 1.19540f, 1.0f),
                  Point4D(0.00010f, -1.19530f, -2.56340f, 1.0f),
                  Point4D(0.00010f, 2.56350f, -1.19530f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate220degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate220degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, 0.73210f, -2.73200f, 1.0f),
                  Point4D(-0.00000f, 2.73210f, 0.73210f, 1.0f),
                  Point4D(0.00010f, -0.73200f, 2.73210f, 1.0f),
                  Point4D(0.00010f, -2.73200f, -0.73200f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f),
                  Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f),
                  Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f),
@@ -491,17 +512,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate220
                  Point4D(0.00010f, -2.73200f, -0.73200f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f),
                  Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f),
                  Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f),
                  Point4D(-2.00000f, 1.73210f, -0.99990f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate240degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate240degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, -2.73200f, 0.73210f, 1.0f),
                  Point4D(-0.00000f, -0.73200f, -2.73200f, 1.0f),
                  Point4D(0.00010f, 2.73210f, -0.73200f, 1.0f),
                  Point4D(0.00010f, 0.73210f, 2.73210f, 1.0f)},
       MozPolygon{Point4D(2.00000f, -1.73200f, -1.00000f, 1.0f),
                  Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f),
                  Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f),
@@ -518,17 +540,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate240
                  Point4D(0.00010f, 0.73210f, 2.73210f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 1.26793f, 0.73210f, 1.0f),
                  Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f),
                  Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f),
                  Point4D(-2.00000f, 1.26793f, 0.73210f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate260degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate260degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, 1.19540f, 2.56350f, 1.0f),
                  Point4D(-0.00000f, -2.56340f, 1.19540f, 1.0f),
                  Point4D(0.00010f, -1.19530f, -2.56340f, 1.0f),
                  Point4D(0.00010f, 2.56350f, -1.19530f, 1.0f)},
       MozPolygon{Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f),
                  Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f),
                  Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f),
@@ -541,17 +564,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate260
                  Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f)},
       MozPolygon{Point4D(-0.00000f, 1.19540f, 2.56350f, 1.0f),
                  Point4D(-0.00000f, -2.56340f, 1.19540f, 1.0f),
                  Point4D(0.00010f, -1.19530f, -2.56340f, 1.0f),
                  Point4D(0.00010f, 2.56350f, -1.19530f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate280degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate280degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, 2.73210f, -0.73200f, 1.0f),
                  Point4D(-0.00000f, 0.73210f, 2.73210f, 1.0f),
                  Point4D(0.00010f, -2.73200f, 0.73210f, 1.0f),
                  Point4D(0.00010f, -0.73200f, -2.73200f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f),
                  Point4D(2.00000f, -1.73200f, -1.00000f, 1.0f),
                  Point4D(-2.00000f, -1.73200f, -1.00000f, 1.0f),
@@ -568,17 +592,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate280
                  Point4D(0.00010f, -0.73200f, -2.73200f, 1.0f)},
       MozPolygon{Point4D(-2.00000f, -1.26783f, -0.73200f, 1.0f),
                  Point4D(-2.00000f, 1.73210f, 1.00010f, 1.0f),
                  Point4D(2.00000f, 1.73210f, 1.00010f, 1.0f),
                  Point4D(2.00000f, -1.26783f, -0.73200f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate300degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate300degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, 0.73210f, -2.73200f, 1.0f),
                  Point4D(-0.00000f, 2.73210f, 0.73210f, 1.0f),
                  Point4D(0.00010f, -0.73200f, 2.73210f, 1.0f),
                  Point4D(0.00010f, -2.73200f, -0.73200f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f),
                  Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f),
                  Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f),
@@ -591,17 +616,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate300
                  Point4D(0.00010f, -2.73200f, -0.73200f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 1.73210f, -0.99990f, 1.0f),
                  Point4D(2.00000f, -1.73200f, 1.00000f, 1.0f),
                  Point4D(-2.00000f, -1.73200f, 1.00000f, 1.0f),
                  Point4D(-2.00000f, 1.73210f, -0.99990f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate320degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate320degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, -1.19530f, -2.56340f, 1.0f),
                  Point4D(-0.00000f, 2.56350f, -1.19530f, 1.0f),
                  Point4D(0.00010f, 1.19540f, 2.56350f, 1.0f),
                  Point4D(0.00010f, -2.56340f, 1.19540f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f),
                  Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f),
                  Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f),
@@ -614,17 +640,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate320
                  Point4D(0.00010f, -2.56340f, 1.19540f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 0.68410f, -1.87930f, 1.0f),
                  Point4D(2.00000f, -0.68400f, 1.87940f, 1.0f),
                  Point4D(-2.00000f, -0.68400f, 1.87940f, 1.0f),
                  Point4D(-2.00000f, 0.68410f, -1.87930f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate340degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate340degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, -2.00000f, -2.00000f, 1.0f),
                  Point4D(-0.00000f, 2.00000f, -2.00000f, 1.0f),
                  Point4D(0.00010f, 2.00000f, 2.00000f, 1.0f),
                  Point4D(0.00010f, -2.00000f, 2.00000f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f),
                  Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f),
                  Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f),
@@ -637,17 +664,18 @@ TEST(BSPTree, TwoPlaneIntersectRotate340
                  Point4D(0.00010f, -2.00000f, 2.00000f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f),
                  Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f),
                  Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f),
                  Point4D(-2.00000f, 0.00010f, -2.00000f, 1.0f)}};
   ::RunTest(polygons, expected);
 }
 
-TEST(BSPTree, TwoPlaneIntersectRotate360degrees) {
+TEST(BSPTree, TwoPlaneIntersectRotate360degrees)
+{
   const std::deque<MozPolygon> polygons{
       MozPolygon{Point4D(-0.00000f, -2.00000f, -2.00000f, 1.0f),
                  Point4D(-0.00000f, 2.00000f, -2.00000f, 1.0f),
                  Point4D(0.00010f, 2.00000f, 2.00000f, 1.0f),
                  Point4D(0.00010f, -2.00000f, 2.00000f, 1.0f)},
       MozPolygon{Point4D(2.00000f, 0.00010f, -2.00000f, 1.0f),
                  Point4D(2.00000f, -0.00000f, 2.00000f, 1.0f),
                  Point4D(-2.00000f, -0.00000f, 2.00000f, 1.0f),
--- a/gfx/tests/gtest/TestBufferRotation.cpp
+++ b/gfx/tests/gtest/TestBufferRotation.cpp
@@ -38,17 +38,18 @@ static bool CheckBuffer(unsigned char* b
           return false;
         }
       }
     }
   }
   return true;
 }
 
-TEST(Gfx, BufferUnrotateHorizontal) {
+TEST(Gfx, BufferUnrotateHorizontal)
+{
   const int NUM_OF_TESTS = 8;
   int bytesPerPixelList[2] = {2, 4};
   int width[NUM_OF_TESTS] = {100, 100, 99, 99, 100, 100, 99, 99};
   int height[NUM_OF_TESTS] = {100, 99, 100, 99, 100, 99, 100, 99};
   int xBoundary[NUM_OF_TESTS] = {30, 30, 30, 30, 31, 31, 31, 31};
   int yBoundary[NUM_OF_TESTS] = {0, 0, 0, 0};
 
   for (int bytesPerId = 0; bytesPerId < 2; bytesPerId++) {
@@ -64,17 +65,18 @@ TEST(Gfx, BufferUnrotateHorizontal) {
 
       EXPECT_TRUE(CheckBuffer(buffer, bytesPerPixel, width[testId],
                               height[testId], stride));
       delete[] buffer;
     }
   }
 }
 
-TEST(Gfx, BufferUnrotateVertical) {
+TEST(Gfx, BufferUnrotateVertical)
+{
   const int NUM_OF_TESTS = 8;
   int bytesPerPixelList[2] = {2, 4};
   int width[NUM_OF_TESTS] = {100, 100, 99, 99, 100, 100, 99, 99};
   int height[NUM_OF_TESTS] = {100, 99, 100, 99, 100, 99, 100, 99};
   int xBoundary[NUM_OF_TESTS] = {0, 0, 0, 0};
   int yBoundary[NUM_OF_TESTS] = {30, 30, 30, 30, 31, 31, 31, 31};
 
   for (int bytesPerId = 0; bytesPerId < 2; bytesPerId++) {
@@ -90,17 +92,18 @@ TEST(Gfx, BufferUnrotateVertical) {
 
       EXPECT_TRUE(CheckBuffer(buffer, bytesPerPixel, width[testId],
                               height[testId], stride));
       delete[] buffer;
     }
   }
 }
 
-TEST(Gfx, BufferUnrotateBoth) {
+TEST(Gfx, BufferUnrotateBoth)
+{
   const int NUM_OF_TESTS = 16;
   int bytesPerPixelList[2] = {2, 4};
   int width[NUM_OF_TESTS] = {100, 100, 99, 99, 100, 100, 99, 99,
                              100, 100, 99, 99, 100, 100, 99, 99};
   int height[NUM_OF_TESTS] = {100, 99, 100, 99, 100, 99, 100, 99,
                               100, 99, 100, 99, 100, 99, 100, 99};
   int xBoundary[NUM_OF_TESTS] = {30, 30, 30, 30, 31, 31, 31, 31,
                                  30, 30, 30, 30, 31, 31, 31, 31};
@@ -120,17 +123,18 @@ TEST(Gfx, BufferUnrotateBoth) {
 
       EXPECT_TRUE(CheckBuffer(buffer, bytesPerPixel, width[testId],
                               height[testId], stride));
       delete[] buffer;
     }
   }
 }
 
-TEST(Gfx, BufferUnrotateUneven) {
+TEST(Gfx, BufferUnrotateUneven)
+{
   const int NUM_OF_TESTS = 16;
   int bytesPerPixelList[2] = {2, 4};
   int width[NUM_OF_TESTS] = {10,  100, 99, 39, 100, 40, 99, 39,
                              100, 50,  39, 99, 74,  60, 99, 39};
   int height[NUM_OF_TESTS] = {100, 39, 10,  99, 10, 99, 40, 99,
                               73,  39, 100, 39, 67, 99, 84, 99};
   int xBoundary[NUM_OF_TESTS] = {0,  0,  30, 30, 99, 31, 0,  31,
                                  30, 30, 30, 30, 31, 31, 31, 38};
--- a/gfx/tests/gtest/TestColorNames.cpp
+++ b/gfx/tests/gtest/TestColorNames.cpp
@@ -39,53 +39,53 @@ static void RunColorTests() {
   // work
 
   for (uint32_t index = 0; index < ArrayLength(kColorNames); index++) {
     // Lookup color by name and make sure it has the right id
     nsCString tagName(kColorNames[index]);
 
     // Check that color lookup by name gets the right rgb value
     ASSERT_TRUE(NS_ColorNameToRGB(NS_ConvertASCIItoUTF16(tagName), &rgb))
-        << "can't find '" << tagName.get() << "'";
+    << "can't find '" << tagName.get() << "'";
     ASSERT_TRUE((rgb == kColors[index]))
-        << "failed at index " << index << " out of "
-        << ArrayLength(kColorNames);
+    << "failed at index " << index << " out of " << ArrayLength(kColorNames);
 
     // fiddle with the case to make sure we can still find it
     tagName.SetCharAt(tagName.CharAt(0) - 32, 0);
     ASSERT_TRUE(NS_ColorNameToRGB(NS_ConvertASCIItoUTF16(tagName), &rgb))
-        << "can't find '" << tagName.get() << "'";
+    << "can't find '" << tagName.get() << "'";
     ASSERT_TRUE((rgb == kColors[index]))
-        << "failed at index " << index << " out of "
-        << ArrayLength(kColorNames);
+    << "failed at index " << index << " out of " << ArrayLength(kColorNames);
 
     // Check that parsing an RGB value in hex gets the right values
     uint8_t r = NS_GET_R(rgb);
     uint8_t g = NS_GET_G(rgb);
     uint8_t b = NS_GET_B(rgb);
     uint8_t a = NS_GET_A(rgb);
     char cbuf[50];
     if (a != UINT8_MAX) {
       SprintfLiteral(cbuf, "%02x%02x%02x%02x", r, g, b, a);
     } else {
       SprintfLiteral(cbuf, "%02x%02x%02x", r, g, b);
     }
     nscolor hexrgb;
     ASSERT_TRUE(NS_HexToRGBA(NS_ConvertASCIItoUTF16(cbuf),
                              nsHexColorType::AllowAlpha, &hexrgb))
-        << "hex conversion to color of '" << cbuf << "'";
+    << "hex conversion to color of '" << cbuf << "'";
     ASSERT_TRUE(hexrgb == rgb);
   }
 }
 
 static void RunJunkColorTests() {
   nscolor rgb;
   // Now make sure we don't find some garbage
   for (uint32_t i = 0; i < ArrayLength(kJunkNames); i++) {
     nsCString tag(kJunkNames[i]);
     ASSERT_FALSE(NS_ColorNameToRGB(NS_ConvertASCIItoUTF16(tag), &rgb))
-        << "Failed at junk color " << kJunkNames[i];
+    << "Failed at junk color " << kJunkNames[i];
   }
 }
 
-TEST(Gfx, ColorNames) { RunColorTests(); }
+TEST(Gfx, ColorNames)
+{ RunColorTests(); }
 
-TEST(Gfx, JunkColorNames) { RunJunkColorTests(); }
+TEST(Gfx, JunkColorNames)
+{ RunJunkColorTests(); }
--- a/gfx/tests/gtest/TestCompositor.cpp
+++ b/gfx/tests/gtest/TestCompositor.cpp
@@ -156,21 +156,21 @@ static bool CompositeAndCompare(RefPtr<L
         }
       }
     }
   }
 
   return true;
 }
 
-TEST(Gfx, CompositorConstruct) {
-  auto layerManagers = GetLayerManagers(GetPlatformBackends());
-}
+TEST(Gfx, CompositorConstruct)
+{ auto layerManagers = GetLayerManagers(GetPlatformBackends()); }
 
-TEST(Gfx, CompositorSimpleTree) {
+TEST(Gfx, CompositorSimpleTree)
+{
   auto layerManagers = GetLayerManagers(GetPlatformBackends());
   for (size_t i = 0; i < layerManagers.size(); i++) {
     RefPtr<LayerManagerComposite> layerManager = layerManagers[i].mLayerManager;
     RefPtr<LayerManager> lmBase = layerManager.get();
     nsTArray<RefPtr<Layer>> layers;
     nsIntRegion layerVisibleRegion[] = {
         nsIntRegion(IntRect(0, 0, gCompWidth, gCompHeight)),
         nsIntRegion(IntRect(0, 0, gCompWidth, gCompHeight)),
--- a/gfx/tests/gtest/TestGfxPrefs.cpp
+++ b/gfx/tests/gtest/TestGfxPrefs.cpp
@@ -11,53 +11,57 @@
 #  error "This is not supposed to be defined outside of gfxPrefs.h"
 #endif
 
 // If the default values for any of these preferences change,
 // just modify the test to match. We are only testing against
 // a particular value to make sure we receive the correct
 // result through this API.
 
-TEST(GfxPrefs, Singleton) {
+TEST(GfxPrefs, Singleton)
+{
   gfxPrefs::GetSingleton();
   ASSERT_TRUE(gfxPrefs::SingletonExists());
 }
 
-TEST(GfxPrefs, LiveValues) {
+TEST(GfxPrefs, LiveValues)
+{
   gfxPrefs::GetSingleton();
   ASSERT_TRUE(gfxPrefs::SingletonExists());
 
   // Live boolean, default false
   ASSERT_FALSE(gfxPrefs::LayersDumpTexture());
 
   // Live int32_t, default 23456
   ASSERT_TRUE(gfxPrefs::LayerScopePort() == 23456);
 
   // Live uint32_t, default 2
   ASSERT_TRUE(gfxPrefs::MSAALevel() == 2);
 }
 
-TEST(GfxPrefs, OnceValues) {
+TEST(GfxPrefs, OnceValues)
+{
   gfxPrefs::GetSingleton();
   ASSERT_TRUE(gfxPrefs::SingletonExists());
 
   // Once boolean, default true
   ASSERT_TRUE(gfxPrefs::WorkAroundDriverBugs());
 
   // Once boolean, default false
   ASSERT_FALSE(gfxPrefs::LayersDump());
 
   // Once uint32_t, default 5
   ASSERT_TRUE(gfxPrefs::APZMaxVelocityQueueSize() == 5);
 
   // Once float, default -1 (should be OK with ==)
   ASSERT_TRUE(gfxPrefs::APZMaxVelocity() == -1.0f);
 }
 
-TEST(GfxPrefs, Set) {
+TEST(GfxPrefs, Set)
+{
   gfxPrefs::GetSingleton();
   ASSERT_TRUE(gfxPrefs::SingletonExists());
 
   // Once boolean, default false
   ASSERT_FALSE(gfxPrefs::LayersDump());
   gfxPrefs::SetLayersDump(true);
   ASSERT_TRUE(gfxPrefs::LayersDump());
   gfxPrefs::SetLayersDump(false);
@@ -75,17 +79,18 @@ TEST(GfxPrefs, Set) {
   gfxPrefs::SetAPZMaxVelocity(1.75f);
   ASSERT_TRUE(gfxPrefs::APZMaxVelocity() == 1.75f);
   gfxPrefs::SetAPZMaxVelocity(-1.0f);
   ASSERT_TRUE(gfxPrefs::APZMaxVelocity() == -1.0f);
 }
 
 // Randomly test the function we use in nsExceptionHandler.cpp here:
 extern bool SimpleNoCLibDtoA(double aValue, char* aBuffer, int aBufferLength);
-TEST(GfxPrefs, StringUtility) {
+TEST(GfxPrefs, StringUtility)
+{
   char testBuffer[64];
   double testVal[] = {
       13.4,
       3324243.42,
       0.332424342,
       864.0,
       86400 * 100000000.0 * 10000000000.0 * 10000000000.0 * 100.0,
       86400.0 * 366.0 * 100.0 + 14243.44332};
--- a/gfx/tests/gtest/TestGfxWidgets.cpp
+++ b/gfx/tests/gtest/TestGfxWidgets.cpp
@@ -5,17 +5,18 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "gtest/gtest.h"
 #include "GfxDriverInfo.h"
 #include "nsVersionComparator.h"
 
 using namespace mozilla::widget;
 
-TEST(GfxWidgets, Split) {
+TEST(GfxWidgets, Split)
+{
   char aStr[8], bStr[8], cStr[8], dStr[8];
 
   ASSERT_TRUE(SplitDriverVersion("33.4.3.22", aStr, bStr, cStr, dStr));
   ASSERT_TRUE(atoi(aStr) == 33 && atoi(bStr) == 4 && atoi(cStr) == 3 &&
               atoi(dStr) == 22);
 
   ASSERT_TRUE(SplitDriverVersion("28.74.0.0", aStr, bStr, cStr, dStr));
   ASSERT_TRUE(atoi(aStr) == 28 && atoi(bStr) == 74 && atoi(cStr) == 0 &&
@@ -70,17 +71,18 @@ TEST(GfxWidgets, Split) {
   ASSERT_TRUE(atoi(aStr) == 4 && atoi(bStr) == 1 && atoi(cStr) == 8 &&
               atoi(dStr) == 13);
 
   ASSERT_TRUE(SplitDriverVersion("35..42.0", aStr, bStr, cStr, dStr));
   ASSERT_TRUE(atoi(aStr) == 35 && atoi(bStr) == 0 && atoi(cStr) == 42 &&
               atoi(dStr) == 0);
 }
 
-TEST(GfxWidgets, Versioning) {
+TEST(GfxWidgets, Versioning)
+{
   ASSERT_TRUE(mozilla::Version("0") < mozilla::Version("41.0a1"));
   ASSERT_TRUE(mozilla::Version("39.0.5b7") < mozilla::Version("41.0a1"));
   ASSERT_TRUE(mozilla::Version("18.0.5b7") < mozilla::Version("18.2"));
   ASSERT_TRUE(mozilla::Version("30.0.5b7") < mozilla::Version("41.0b9"));
   ASSERT_TRUE(mozilla::Version("100") > mozilla::Version("43.0a1"));
   ASSERT_FALSE(mozilla::Version("42.0") < mozilla::Version("42.0"));
   ASSERT_TRUE(mozilla::Version("42.0b2") < mozilla::Version("42.0"));
   ASSERT_TRUE(mozilla::Version("42.0b2") < mozilla::Version("42"));
--- a/gfx/tests/gtest/TestJobScheduler.cpp
+++ b/gfx/tests/gtest/TestJobScheduler.cpp
@@ -193,41 +193,44 @@ static void TestSchedulerChain(uint32_t 
   for (auto advancement : check.mAdvancements) {
     EXPECT_TRUE(advancement == numJobs);
   }
 }
 
 }  // namespace test_scheduler
 
 #if !defined(MOZ_CODE_COVERAGE) || !defined(XP_WIN)
-TEST(Moz2D, JobScheduler_Shutdown) {
+TEST(Moz2D, JobScheduler_Shutdown)
+{
   srand(time(nullptr));
   for (uint32_t threads = 1; threads < 16; ++threads) {
     for (uint32_t i = 1; i < 1000; ++i) {
       mozilla::gfx::JobScheduler::Init(threads, threads);
       mozilla::gfx::JobScheduler::ShutDown();
     }
   }
 }
 #endif
 
-TEST(Moz2D, JobScheduler_Join) {
+TEST(Moz2D, JobScheduler_Join)
+{
   srand(time(nullptr));
   for (uint32_t threads = 1; threads < 8; ++threads) {
     for (uint32_t queues = 1; queues < threads; ++queues) {
       for (uint32_t buffers = 1; buffers < 100; buffers += 3) {
         mozilla::gfx::JobScheduler::Init(threads, queues);
         test_scheduler::TestSchedulerJoin(threads, buffers);
         mozilla::gfx::JobScheduler::ShutDown();
       }
     }
   }
 }
 
-TEST(Moz2D, JobScheduler_Chain) {
+TEST(Moz2D, JobScheduler_Chain)
+{
   srand(time(nullptr));
   for (uint32_t threads = 1; threads < 8; ++threads) {
     for (uint32_t queues = 1; queues < threads; ++queues) {
       for (uint32_t buffers = 1; buffers < 100; buffers += 3) {
         mozilla::gfx::JobScheduler::Init(threads, queues);
         test_scheduler::TestSchedulerChain(threads, buffers);
         mozilla::gfx::JobScheduler::ShutDown();
       }
--- a/gfx/tests/gtest/TestLayers.cpp
+++ b/gfx/tests/gtest/TestLayers.cpp
@@ -80,47 +80,52 @@ class TestLayerManager : public LayerMan
 };
 
 class TestUserData : public LayerUserData {
  public:
   MOCK_METHOD0(Die, void());
   virtual ~TestUserData() { Die(); }
 };
 
-TEST(Layers, LayerConstructor) { TestContainerLayer layer(nullptr); }
+TEST(Layers, LayerConstructor)
+{ TestContainerLayer layer(nullptr); }
 
-TEST(Layers, Defaults) {
+TEST(Layers, Defaults)
+{
   TestContainerLayer layer(nullptr);
   ASSERT_EQ(1.0, layer.GetOpacity());
   ASSERT_EQ(1.0f, layer.GetPostXScale());
   ASSERT_EQ(1.0f, layer.GetPostYScale());
 
   ASSERT_EQ(nullptr, layer.GetNextSibling());
   ASSERT_EQ(nullptr, layer.GetPrevSibling());
   ASSERT_EQ(nullptr, layer.GetFirstChild());
   ASSERT_EQ(nullptr, layer.GetLastChild());
 }
 
-TEST(Layers, Transform) {
+TEST(Layers, Transform)
+{
   TestContainerLayer layer(nullptr);
 
   Matrix4x4 identity;
   ASSERT_EQ(true, identity.IsIdentity());
 
   ASSERT_EQ(identity, layer.GetTransform());
 }
 
-TEST(Layers, Type) {
+TEST(Layers, Type)
+{
   TestContainerLayer layer(nullptr);
   ASSERT_EQ(nullptr, layer.AsPaintedLayer());
   ASSERT_EQ(nullptr, layer.AsRefLayer());
   ASSERT_EQ(nullptr, layer.AsColorLayer());
 }
 
-TEST(Layers, UserData) {
+TEST(Layers, UserData)
+{
   UniquePtr<TestContainerLayer> layerPtr(new TestContainerLayer(nullptr));
   TestContainerLayer& layer = *layerPtr;
 
   void* key1 = (void*)1;
   void* key2 = (void*)2;
   void* key3 = (void*)3;
 
   ASSERT_EQ(nullptr, layer.GetUserData(key1));
@@ -230,17 +235,18 @@ already_AddRefed<Layer> CreateLayerTree(
     if (rootLayer->AsHostLayer()) {
       // Only perform this for LayerManagerComposite
       CompositorBridgeParent::SetShadowProperties(rootLayer);
     }
   }
   return rootLayer.forget();
 }
 
-TEST(Layers, LayerTree) {
+TEST(Layers, LayerTree)
+{
   const char* layerTreeSyntax = "c(c(tt))";
   nsIntRegion layerVisibleRegion[] = {
       nsIntRegion(IntRect(0, 0, 100, 100)),
       nsIntRegion(IntRect(0, 0, 100, 100)),
       nsIntRegion(IntRect(0, 0, 100, 100)),
       nsIntRegion(IntRect(10, 10, 20, 20)),
   };
   Matrix4x4 transforms[] = {
@@ -284,17 +290,18 @@ static void ValidateTreePointers(Layer* 
 }
 
 static void ValidateTreePointers(nsTArray<RefPtr<Layer> >& aLayers) {
   for (uint32_t i = 0; i < aLayers.Length(); i++) {
     ValidateTreePointers(aLayers[i]);
   }
 }
 
-TEST(Layers, RepositionChild) {
+TEST(Layers, RepositionChild)
+{
   const char* layerTreeSyntax = "c(ttt)";
 
   nsTArray<RefPtr<Layer> > layers;
   RefPtr<LayerManager> lm;
   RefPtr<Layer> root =
       CreateLayerTree(layerTreeSyntax, nullptr, nullptr, lm, layers);
   ContainerLayer* parent = root->AsContainerLayer();
   ValidateTreePointers(layers);
--- a/gfx/tests/gtest/TestMoz2D.cpp
+++ b/gfx/tests/gtest/TestMoz2D.cpp
@@ -5,34 +5,37 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "gtest/gtest.h"
 #include "TestBase.h"
 #include "TestPoint.h"
 #include "TestScaling.h"
 #include "TestBugs.h"
 
-TEST(Moz2D, Bugs) {
+TEST(Moz2D, Bugs)
+{
   TestBugs* test = new TestBugs();
   int failures = 0;
   test->RunTests(&failures);
   delete test;
 
   ASSERT_EQ(failures, 0);
 }
 
-TEST(Moz2D, Point) {
+TEST(Moz2D, Point)
+{
   TestBase* test = new TestPoint();
   int failures = 0;
   test->RunTests(&failures);
   delete test;
 
   ASSERT_EQ(failures, 0);
 }
 
-TEST(Moz2D, Scaling) {
+TEST(Moz2D, Scaling)
+{
   TestBase* test = new TestScaling();
   int failures = 0;
   test->RunTests(&failures);
   delete test;
 
   ASSERT_EQ(failures, 0);
 }
--- a/gfx/tests/gtest/TestPolygon.cpp
+++ b/gfx/tests/gtest/TestPolygon.cpp
@@ -11,30 +11,32 @@
 #include "nsTArray.h"
 #include "Point.h"
 #include "Polygon.h"
 #include "Triangle.h"
 
 using namespace mozilla::gfx;
 typedef mozilla::gfx::Polygon MozPolygon;
 
-TEST(MozPolygon, TriangulateRectangle) {
+TEST(MozPolygon, TriangulateRectangle)
+{
   const MozPolygon p{
       Point4D(0.0f, 0.0f, 1.0f, 1.0f), Point4D(0.0f, 1.0f, 1.0f, 1.0f),
       Point4D(1.0f, 1.0f, 1.0f, 1.0f), Point4D(1.0f, 0.0f, 1.0f, 1.0f)};
 
   const nsTArray<Triangle> triangles = p.ToTriangles();
   const nsTArray<Triangle> expected = {
       Triangle(Point(0.0f, 0.0f), Point(0.0f, 1.0f), Point(1.0f, 1.0f)),
       Triangle(Point(0.0f, 0.0f), Point(1.0f, 1.0f), Point(1.0f, 0.0f))};
 
   AssertArrayEQ(triangles, expected);
 }
 
-TEST(MozPolygon, TriangulatePentagon) {
+TEST(MozPolygon, TriangulatePentagon)
+{
   const MozPolygon p{
       Point4D(0.0f, 0.0f, 1.0f, 1.0f), Point4D(0.0f, 1.0f, 1.0f, 1.0f),
       Point4D(0.5f, 1.5f, 1.0f, 1.0f), Point4D(1.0f, 1.0f, 1.0f, 1.0f),
       Point4D(1.0f, 0.0f, 1.0f, 1.0f)};
 
   const nsTArray<Triangle> triangles = p.ToTriangles();
   const nsTArray<Triangle> expected = {
       Triangle(Point(0.0f, 0.0f), Point(0.0f, 1.0f), Point(0.5f, 1.5f)),
@@ -45,17 +47,18 @@ TEST(MozPolygon, TriangulatePentagon) {
 }
 
 static void TestClipRect(const MozPolygon& aPolygon,
                          const MozPolygon& aExpected, const Rect& aRect) {
   const MozPolygon res = aPolygon.ClipPolygon(MozPolygon::FromRect(aRect));
   EXPECT_TRUE(res == aExpected);
 }
 
-TEST(MozPolygon, ClipRectangle) {
+TEST(MozPolygon, ClipRectangle)
+{
   MozPolygon polygon{
       Point4D(0.0f, 0.0f, 0.0f, 1.0f), Point4D(0.0f, 1.0f, 0.0f, 1.0f),
       Point4D(1.0f, 1.0f, 0.0f, 1.0f), Point4D(1.0f, 0.0f, 0.0f, 1.0f)};
   TestClipRect(polygon, polygon, Rect(0.0f, 0.0f, 1.0f, 1.0f));
 
   MozPolygon expected = MozPolygon{
       Point4D(0.0f, 0.0f, 0.0f, 1.0f), Point4D(0.0f, 0.8f, 0.0f, 1.0f),
       Point4D(0.8f, 0.8f, 0.0f, 1.0f), Point4D(0.8f, 0.0f, 0.0f, 1.0f)};
@@ -67,17 +70,18 @@ TEST(MozPolygon, ClipRectangle) {
   TestClipRect(polygon, expected, Rect(0.2f, 0.2f, 0.8f, 0.8f));
 
   expected = MozPolygon{
       Point4D(0.2f, 0.2f, 0.0f, 1.0f), Point4D(0.2f, 0.8f, 0.0f, 1.0f),
       Point4D(0.8f, 0.8f, 0.0f, 1.0f), Point4D(0.8f, 0.2f, 0.0f, 1.0f)};
   TestClipRect(polygon, expected, Rect(0.2f, 0.2f, 0.6f, 0.6f));
 }
 
-TEST(MozPolygon, ClipTriangle) {
+TEST(MozPolygon, ClipTriangle)
+{
   MozPolygon clipped, expected;
   const MozPolygon polygon{Point4D(0.0f, 0.0f, 0.0f, 1.0f),
                            Point4D(0.0f, 1.0f, 0.0f, 1.0f),
                            Point4D(1.0f, 1.0f, 0.0f, 1.0f)};
 
   expected = MozPolygon{Point4D(0.0f, 0.0f, 0.0f, 1.0f),
                         Point4D(0.0f, 1.0f, 0.0f, 1.0f),
                         Point4D(1.0f, 1.0f, 0.0f, 1.0f)};
--- a/gfx/tests/gtest/TestQcms.cpp
+++ b/gfx/tests/gtest/TestQcms.cpp
@@ -24,17 +24,18 @@ static unsigned char* createAllGB() {
         pos++;
       }
     }
   }
 
   return buff;
 }
 
-TEST(GfxQcms, Identity) {
+TEST(GfxQcms, Identity)
+{
   // XXX: This means that we can't have qcms v2 unit test
   //      without changing the qcms API.
   qcms_enable_iccv4();
 
   qcms_profile* input_profile = qcms_profile_sRGB();
   qcms_profile* output_profile = qcms_profile_sRGB();
 
   EXPECT_FALSE(qcms_profile_is_bogus(input_profile));
@@ -55,17 +56,18 @@ TEST(GfxQcms, Identity) {
   qcms_profile_release(input_profile);
   qcms_profile_release(output_profile);
   qcms_transform_release(transform);
 
   free(data_in);
   free(data_out);
 }
 
-TEST(GfxQcms, LutInverseCrash) {
+TEST(GfxQcms, LutInverseCrash)
+{
   uint16_t lutTable1[] = {
       0x0000, 0x0000, 0x0000, 0x8000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
       0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
       0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
       0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
       0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
       0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
       0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
@@ -98,17 +100,18 @@ TEST(GfxQcms, LutInverseCrash) {
 
   // Crash/Assert test
   lut_inverse_interp16((uint16_t)5, lutTable1,
                        (int)mozilla::ArrayLength(lutTable1));
   lut_inverse_interp16((uint16_t)5, lutTable2,
                        (int)mozilla::ArrayLength(lutTable2));
 }
 
-TEST(GfxQcms, LutInverse) {
+TEST(GfxQcms, LutInverse)
+{
   // mimic sRGB_v4_ICC mBA Output
   //
   //       XXXX
   //      X
   //     X
   // XXXX
   uint16_t value;
   uint16_t lutTable[256];
@@ -139,17 +142,18 @@ TEST(GfxQcms, LutInverse) {
       lut_inverse_interp16(1, lutTable, (int)mozilla::ArrayLength(lutTable));
   EXPECT_GT(value, 20 * 256);
 
   value = lut_inverse_interp16(65535, lutTable,
                                (int)mozilla::ArrayLength(lutTable));
   EXPECT_LT(value, 201 * 256);
 }
 
-TEST(GfxQcms, LutInverseNonMonotonic) {
+TEST(GfxQcms, LutInverseNonMonotonic)
+{
   // Make sure we behave sanely for non monotic functions
   //   X  X  X
   //  X  X  X
   // X  X  X
   uint16_t lutTable[256];
 
   for (int i = 0; i < 100; i++) {
     lutTable[i] = (i - 0) * 0xFFFF / (100 - 0);
--- a/gfx/tests/gtest/TestRect.cpp
+++ b/gfx/tests/gtest/TestRect.cpp
@@ -547,52 +547,56 @@ static void TestIntersectionLogical(nsco
                                     nscoord yR, nscoord wR, nscoord hR,
                                     bool isNonEmpty) {
   TestIntersectionLogicalHelper(x1, y1, w1, h1, x2, y2, w2, h2, xR, yR, wR, hR,
                                 isNonEmpty);
   TestIntersectionLogicalHelper(x2, y2, w2, h2, x1, y1, w1, h1, xR, yR, wR, hR,
                                 isNonEmpty);
 }
 
-TEST(Gfx, Logical) {
+TEST(Gfx, Logical)
+{
   TestIntersectionLogical(578, 0, 2650, 1152, 1036, 0, 2312, 1, 1036, 0, 2192,
                           1, true);
   TestIntersectionLogical(0, 0, 1000, 1000, 500, 500, 1000, 1000, 500, 500, 500,
                           500, true);
   TestIntersectionLogical(100, 200, 300, 400, 50, 250, 100, 100, 100, 250, 50,
                           100, true);
   TestIntersectionLogical(0, 100, 200, 300, 300, 100, 100, 300, 300, 100, 0, 0,
                           false);
 }
 
-TEST(Gfx, nsRect) {
+TEST(Gfx, nsRect)
+{
   TestConstructors<nsRect>();
   TestEqualityOperator<nsRect>();
   TestContainment<nsRect>();
   TestIntersects<nsRect>();
   TestIntersection<nsRect>();
   TestUnion<nsRect>();
   TestBug1135677<nsRect>();
   TestSetWH<nsRect>();
   TestSwap<nsRect>();
 }
 
-TEST(Gfx, nsIntRect) {
+TEST(Gfx, nsIntRect)
+{
   TestConstructors<nsIntRect>();
   TestEqualityOperator<nsIntRect>();
   TestContainment<nsIntRect>();
   TestIntersects<nsIntRect>();
   TestIntersection<nsIntRect>();
   TestUnion<nsIntRect>();
   TestBug1135677<nsIntRect>();
   TestSetWH<nsIntRect>();
   TestSwap<nsIntRect>();
 }
 
-TEST(Gfx, gfxRect) {
+TEST(Gfx, gfxRect)
+{
   TestConstructors<gfxRect>();
   // Skip TestEqualityOperator<gfxRect>(); as gfxRect::operator== is private
   TestContainment<gfxRect>();
   TestIntersects<gfxRect>();
   TestIntersection<gfxRect>();
   TestUnion<gfxRect>();
   TestBug1135677<gfxRect>();
   TestFiniteGfx();
@@ -615,17 +619,18 @@ static void TestMoveInsideAndClamp(IntRe
   IntRectAbsolute absExpected = IntRectAbsolute::FromRect(aExpected);
 
   IntRectAbsolute absResult = absSrc.MoveInsideAndClamp(absTarget);
   EXPECT_TRUE(absResult.IsEqualEdges(absExpected))
       << "AbsSource " << absSrc << " AbsTarget " << absTarget << " AbsExpected "
       << absExpected << " AbsActual " << absResult;
 }
 
-TEST(Gfx, MoveInsideAndClamp) {
+TEST(Gfx, MoveInsideAndClamp)
+{
   TestMoveInsideAndClamp(IntRect(0, 0, 10, 10), IntRect(1, -1, 10, 10),
                          IntRect(1, -1, 10, 10));
   TestMoveInsideAndClamp(IntRect(0, 0, 10, 10), IntRect(-1, -1, 12, 5),
                          IntRect(0, -1, 10, 5));
   TestMoveInsideAndClamp(IntRect(0, 0, 10, 10), IntRect(10, 11, 10, 0),
                          IntRect(10, 11, 10, 0));
   TestMoveInsideAndClamp(IntRect(0, 0, 10, 10), IntRect(-10, -1, 10, 0),
                          IntRect(-10, -1, 10, 0));
--- a/gfx/tests/gtest/TestRegion.cpp
+++ b/gfx/tests/gtest/TestRegion.cpp
@@ -109,37 +109,39 @@ class TestLargestRegion {
     nsRegion r(nsRect(0, 0, 100, 100));
     r.Or(r, nsRect(0, 300, 50, 50));
     EXPECT_TRUE(r.GetLargestRectangle(nsRect(0, 290, 10, 20))
                     .IsEqualInterior(nsRect(0, 300, 50, 50)))
         << "Chose wrong rectangle";
   }
 };
 
-TEST(Gfx, RegionSingleRect) {
+TEST(Gfx, RegionSingleRect)
+{
   TestLargestRegion::TestSingleRect(nsRect(0, 52, 720, 480));
   TestLargestRegion::TestSingleRect(nsRect(-20, 40, 50, 20));
   TestLargestRegion::TestSingleRect(nsRect(-20, 40, 10, 8));
   TestLargestRegion::TestSingleRect(nsRect(-20, -40, 10, 8));
   TestLargestRegion::TestSingleRect(nsRect(-10, -10, 20, 20));
 }
 
-TEST(Gfx, RegionNonRectangular) { TestLargestRegion::TestNonRectangular(); }
+TEST(Gfx, RegionNonRectangular)
+{ TestLargestRegion::TestNonRectangular(); }
 
-TEST(Gfx, RegionTwoRectTest) { TestLargestRegion::TwoRectTest(); }
+TEST(Gfx, RegionTwoRectTest)
+{ TestLargestRegion::TwoRectTest(); }
 
-TEST(Gfx, RegionContainsSpecifiedRect) {
-  TestLargestRegion::TestContainsSpecifiedRect();
-}
+TEST(Gfx, RegionContainsSpecifiedRect)
+{ TestLargestRegion::TestContainsSpecifiedRect(); }
 
-TEST(Gfx, RegionTestContainsSpecifiedOverflowingRect) {
-  TestLargestRegion::TestContainsSpecifiedOverflowingRect();
-}
+TEST(Gfx, RegionTestContainsSpecifiedOverflowingRect)
+{ TestLargestRegion::TestContainsSpecifiedOverflowingRect(); }
 
-TEST(Gfx, RegionScaleToInside) {
+TEST(Gfx, RegionScaleToInside)
+{
   {  // no rectangles
     nsRegion r;
 
     nsIntRegion scaled = r.ScaleToInsidePixels(1, 1, 60);
     nsIntRegion result;
 
     EXPECT_TRUE(result.IsEqual(scaled)) << "scaled result incorrect";
   }
@@ -171,17 +173,18 @@ TEST(Gfx, RegionScaleToInside) {
     nsIntRegion scaled = r.ScaleToInsidePixels(1, 1, 60);
     nsIntRegion result(mozilla::gfx::IntRect(0, 746, 322, 4));
     result.Or(result, mozilla::gfx::IntRect(0, 750, 318, 18));
 
     EXPECT_TRUE(result.IsEqual(scaled)) << "scaled result incorrect";
   }
 }