--- a/dom/media/mediasource/ContainerParser.cpp
+++ b/dom/media/mediasource/ContainerParser.cpp
@@ -110,23 +110,25 @@ ContainerParser::MediaHeaderRange()
 }
 
 MediaByteRange
 ContainerParser::MediaSegmentRange()
 {
   return mCompleteMediaSegmentRange;
 }
 
-class WebMContainerParser : public ContainerParser {
+class WebMContainerParser : public ContainerParser
+{
 public:
   explicit WebMContainerParser(const MediaContainerType& aType)
     : ContainerParser(aType)
     , mParser(0)
     , mOffset(0)
-  {}
+  {
+  }
 
   static const unsigned NS_PER_USEC = 1000;
   static const unsigned USEC_PER_SEC = 1000000;
 
   MediaResult IsInitSegmentPresent(MediaByteBuffer* aData) override
   {
     ContainerParser::IsInitSegmentPresent(aData);
     // XXX: This is overly primitive, needs to collect data as it's appended
@@ -193,17 +195,18 @@ public:
         (initSegment || NS_SUCCEEDED(IsMediaSegmentPresent(aData)))) {
       // The last data contained a complete cluster but we can only detect it
       // now that a new one is starting.
       // We use mOffset as end position to ensure that any blocks not reported
       // by WebMBufferParser are properly skipped.
       mCompleteMediaSegmentRange = MediaByteRange(mLastMapping.ref().mSyncOffset,
                                                   mOffset);
       mLastMapping.reset();
-      MSE_DEBUG(WebMContainerParser, "New cluster found at start, ending previous one");
+      MSE_DEBUG(WebMContainerParser,
+                "New cluster found at start, ending previous one");
       return NS_ERROR_NOT_AVAILABLE;
     }
 
     if (initSegment) {
       mOffset = 0;
       mParser = WebMBufferedParser(0);
       mOverlappedMapping.Clear();
       mInitData = new MediaByteBuffer();
@@ -288,18 +291,19 @@ public:
       if (mapping[endIdx+1].mInitOffset > mapping[endIdx].mInitOffset) {
         // We have a new init segment before this cluster.
         endOffset = mapping[endIdx+1].mInitOffset;
       }
       mCompleteMediaSegmentRange = MediaByteRange(mapping[endIdx].mSyncOffset,
                                                   endOffset);
     } else if (mapping[endIdx].mClusterEndOffset >= 0 &&
                mOffset >= mapping[endIdx].mClusterEndOffset) {
-      mCompleteMediaSegmentRange = MediaByteRange(mapping[endIdx].mSyncOffset,
-                                                  mParser.EndSegmentOffset(mapping[endIdx].mClusterEndOffset));
+      mCompleteMediaSegmentRange = MediaByteRange(
+        mapping[endIdx].mSyncOffset,
+        mParser.EndSegmentOffset(mapping[endIdx].mClusterEndOffset));
     }
 
     Maybe<WebMTimeDataOffset> previousMapping;
     if (completeIdx) {
       previousMapping = Some(mapping[completeIdx - 1]);
     } else {
       previousMapping = mLastMapping;
     }
@@ -314,20 +318,25 @@ public:
 
     uint64_t frameDuration =
       (completeIdx + 1u < mapping.Length())
       ? mapping[completeIdx + 1].mTimecode - mapping[completeIdx].mTimecode
       : mapping[completeIdx].mTimecode - previousMapping.ref().mTimecode;
     aStart = mapping[0].mTimecode / NS_PER_USEC;
     aEnd = (mapping[completeIdx].mTimecode + frameDuration) / NS_PER_USEC;
 
-    MSE_DEBUG(WebMContainerParser, "[%" PRId64 ", %" PRId64 "] [fso=%" PRId64
-              ", leo=%" PRId64 ", l=%" PRIuSIZE " processedIdx=%u fs=%" PRId64 "]",
-              aStart, aEnd, mapping[0].mSyncOffset,
-              mapping[completeIdx].mEndOffset, mapping.Length(), completeIdx,
+    MSE_DEBUG(WebMContainerParser,
+              "[%" PRId64 ", %" PRId64 "] [fso=%" PRId64 ", leo=%" PRId64
+              ", l=%" PRIuSIZE " processedIdx=%u fs=%" PRId64 "]",
+              aStart,
+              aEnd,
+              mapping[0].mSyncOffset,
+              mapping[completeIdx].mEndOffset,
+              mapping.Length(),
+              completeIdx,
               mCompleteMediaSegmentRange.mEnd);
 
     return NS_OK;
   }
 
   int64_t GetRoundingError() override
   {
     int64_t error = mParser.GetTimecodeScale() / NS_PER_USEC;
@@ -337,21 +346,23 @@ public:
 private:
   WebMBufferedParser mParser;
   nsTArray<WebMTimeDataOffset> mOverlappedMapping;
   int64_t mOffset;
   Maybe<WebMTimeDataOffset> mLastMapping;
 };
 
 #ifdef MOZ_FMP4
-class MP4ContainerParser : public ContainerParser {
+class MP4ContainerParser : public ContainerParser
+{
 public:
   explicit MP4ContainerParser(const MediaContainerType& aType)
     : ContainerParser(aType)
-  {}
+  {
+  }
 
   MediaResult IsInitSegmentPresent(MediaByteBuffer* aData) override
   {
     ContainerParser::IsInitSegmentPresent(aData);
     // Each MP4 atom has a chunk size and chunk type. The root chunk in an MP4
     // file is the 'ftyp' atom followed by a file type. We just check for a
     // vaguely valid 'ftyp' atom.
     if (aData->Length() < 8) {
@@ -532,37 +543,40 @@ public:
     }
     aStart = compositionRange.start;
     aEnd = compositionRange.end;
     MSE_DEBUG(MP4ContainerParser, "[%" PRId64 ", %" PRId64 "]",
               aStart, aEnd);
     return NS_OK;
   }
 
-  // Gaps of up to 35ms (marginally longer than a single frame at 30fps) are considered
-  // to be sequential frames.
+  // Gaps of up to 35ms (marginally longer than a single frame at 30fps) are
+  // considered to be sequential frames.
   int64_t GetRoundingError() override
   {
     return 35000;
   }
 
 private:
   RefPtr<MP4Stream> mStream;
   nsAutoPtr<mp4_demuxer::MoofParser> mParser;
 };
 #endif // MOZ_FMP4
 
 #ifdef MOZ_FMP4
-class ADTSContainerParser : public ContainerParser {
+class ADTSContainerParser : public ContainerParser
+{
 public:
   explicit ADTSContainerParser(const MediaContainerType& aType)
     : ContainerParser(aType)
-  {}
+  {
+  }
 
-  typedef struct {
+  typedef struct
+  {
     size_t header_length; // Length of just the initialization data.
     size_t frame_length;  // Includes header_length;
     uint8_t aac_frames;   // Number of AAC frames in the ADTS frame.
     bool have_crc;
   } Header;
 
   /// Helper to parse the ADTS header, returning data we care about.
   /// Returns true if the header is parsed successfully.
@@ -656,17 +670,18 @@ public:
                                          int64_t& aEnd) override
   {
     // ADTS header.
     Header header;
     if (!Parse(aData, header)) {
       return NS_ERROR_NOT_AVAILABLE;
     }
     mHasInitData = true;
-    mCompleteInitSegmentRange = MediaByteRange(0, int64_t(header.header_length));
+    mCompleteInitSegmentRange =
+      MediaByteRange(0, int64_t(header.header_length));
 
     // Cache raw header in case the caller wants a copy.
     mInitData = new MediaByteBuffer(header.header_length);
     mInitData->AppendElements(aData->Elements(), header.header_length);
 
     // Check that we have enough data for the frame body.
     if (aData->Length() < header.frame_length) {
       MSE_DEBUGV(ADTSContainerParser, "Not enough data for %llu byte frame"
@@ -695,24 +710,24 @@ public:
     return 0;
   }
 };
 #endif // MOZ_FMP4
 
 /*static*/ ContainerParser*
 ContainerParser::CreateForMIMEType(const MediaContainerType& aType)
 {
-  if (aType.Type() == MEDIAMIMETYPE("video/webm")
-      || aType.Type() == MEDIAMIMETYPE("audio/webm")) {
+  if (aType.Type() == MEDIAMIMETYPE("video/webm") ||
+      aType.Type() == MEDIAMIMETYPE("audio/webm")) {
     return new WebMContainerParser(aType);
   }
 
 #ifdef MOZ_FMP4
-  if (aType.Type() == MEDIAMIMETYPE("video/mp4")
-      || aType.Type() == MEDIAMIMETYPE("audio/mp4")) {
+  if (aType.Type() == MEDIAMIMETYPE("video/mp4") ||
+      aType.Type() == MEDIAMIMETYPE("audio/mp4")) {
     return new MP4ContainerParser(aType);
   }
   if (aType.Type() == MEDIAMIMETYPE("audio/aac")) {
     return new ADTSContainerParser(aType);
   }
 #endif
 
   return new ContainerParser(aType);

--- a/dom/media/mediasource/ContainerParser.h
+++ b/dom/media/mediasource/ContainerParser.h
@@ -12,17 +12,18 @@
 #include "MediaResource.h"
 #include "MediaResult.h"
 
 namespace mozilla {
 
 class MediaByteBuffer;
 class SourceBufferResource;
 
-class ContainerParser {
+class ContainerParser
+{
 public:
   explicit ContainerParser(const MediaContainerType& aType);
   virtual ~ContainerParser();
 
   // Return true if aData starts with an initialization segment.
   // The base implementation exists only for debug logging and is expected
   // to be called first from the overriding implementation.
   // Return NS_OK if segment is present, NS_ERROR_NOT_AVAILABLE if no sufficient