Bug 1289438: [ogg] P3 Fix code style. r=gerald
authorJean-Yves Avenard <jyavenard@mozilla.com>
Wed, 27 Jul 2016 17:01:27 +1000
changeset 347448 0f13ecf177c65ee9438b3c32d3a064cde5b29f1e
parent 347447 2f6157213da23a19e508bbe2da299e540cb3e54d
child 347449 9852c16d65e4b9ee4027745babac8ff15be79d6c
push id6389
push userraliiev@mozilla.com
push dateMon, 19 Sep 2016 13:38:22 +0000
treeherdermozilla-beta@01d67bfe6c81 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersgerald
bugs1289438
milestone50.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 1289438: [ogg] P3 Fix code style. r=gerald MozReview-Commit-ID: K6qpPVgsIi7
dom/media/ogg/OggCodecState.cpp
dom/media/ogg/OggCodecState.h
--- a/dom/media/ogg/OggCodecState.cpp
+++ b/dom/media/ogg/OggCodecState.cpp
@@ -50,75 +50,83 @@ OggCodecState::Create(ogg_page* aPage)
   } else if (aPage->body_len > 8 && memcmp(aPage->body, "fishead\0", 8) == 0) {
     codecState = new SkeletonState(aPage);
   } else {
     codecState = new OggCodecState(aPage, false);
   }
   return codecState->OggCodecState::Init() ? codecState.forget() : nullptr;
 }
 
-OggCodecState::OggCodecState(ogg_page* aBosPage, bool aActive) :
-  mPacketCount(0),
-  mSerial(ogg_page_serialno(aBosPage)),
-  mActive(aActive),
-  mDoneReadingHeaders(!aActive)
+OggCodecState::OggCodecState(ogg_page* aBosPage, bool aActive)
+  : mPacketCount(0)
+  , mSerial(ogg_page_serialno(aBosPage))
+  , mActive(aActive)
+  , mDoneReadingHeaders(!aActive)
 {
   MOZ_COUNT_CTOR(OggCodecState);
   memset(&mState, 0, sizeof(ogg_stream_state));
 }
 
-OggCodecState::~OggCodecState() {
+OggCodecState::~OggCodecState()
+{
   MOZ_COUNT_DTOR(OggCodecState);
   Reset();
 #ifdef DEBUG
   int ret =
 #endif
   ogg_stream_clear(&mState);
   NS_ASSERTION(ret == 0, "ogg_stream_clear failed");
 }
 
-nsresult OggCodecState::Reset() {
+nsresult
+OggCodecState::Reset()
+{
   if (ogg_stream_reset(&mState) != 0) {
     return NS_ERROR_FAILURE;
   }
   mPackets.Erase();
   ClearUnstamped();
   return NS_OK;
 }
 
-void OggCodecState::ClearUnstamped()
+void
+OggCodecState::ClearUnstamped()
 {
   for (uint32_t i = 0; i < mUnstamped.Length(); ++i) {
     OggCodecState::ReleasePacket(mUnstamped[i]);
   }
   mUnstamped.Clear();
 }
 
-bool OggCodecState::Init() {
+bool
+OggCodecState::Init()
+{
   int ret = ogg_stream_init(&mState, mSerial);
   return ret == 0;
 }
 
-bool OggCodecState::IsValidVorbisTagName(nsCString& aName)
+bool
+OggCodecState::IsValidVorbisTagName(nsCString& aName)
 {
   // Tag names must consist of ASCII 0x20 through 0x7D,
   // excluding 0x3D '=' which is the separator.
   uint32_t length = aName.Length();
   const char* data = aName.Data();
   for (uint32_t i = 0; i < length; i++) {
     if (data[i] < 0x20 || data[i] > 0x7D || data[i] == '=') {
       return false;
     }
   }
   return true;
 }
 
-bool OggCodecState::AddVorbisComment(MetadataTags* aTags,
-                                       const char* aComment,
-                                       uint32_t aLength)
+bool
+OggCodecState::AddVorbisComment(MetadataTags* aTags,
+                                const char* aComment,
+                                uint32_t aLength)
 {
   const char* div = (const char*)memchr(aComment, '=', aLength);
   if (!div) {
     LOG(LogLevel::Debug, ("Skipping comment: no separator"));
     return false;
   }
   nsCString key = nsCString(aComment, div-aComment);
   if (!IsValidVorbisTagName(key)) {
@@ -130,87 +138,101 @@ bool OggCodecState::AddVorbisComment(Met
   if (!IsUTF8(value)) {
     LOG(LogLevel::Debug, ("Skipping comment: invalid UTF-8 in value"));
     return false;
   }
   aTags->Put(key, value);
   return true;
 }
 
-void VorbisState::RecordVorbisPacketSamples(ogg_packet* aPacket,
-                                              long aSamples)
+void
+VorbisState::RecordVorbisPacketSamples(ogg_packet* aPacket, long aSamples)
 {
 #ifdef VALIDATE_VORBIS_SAMPLE_CALCULATION
   mVorbisPacketSamples[aPacket] = aSamples;
 #endif
 }
 
-void VorbisState::ValidateVorbisPacketSamples(ogg_packet* aPacket,
-                                                long aSamples)
+void
+VorbisState::ValidateVorbisPacketSamples(ogg_packet* aPacket, long aSamples)
 {
 #ifdef VALIDATE_VORBIS_SAMPLE_CALCULATION
   NS_ASSERTION(mVorbisPacketSamples[aPacket] == aSamples,
     "Decoded samples for Vorbis packet don't match expected!");
   mVorbisPacketSamples.erase(aPacket);
 #endif
 }
 
-void VorbisState::AssertHasRecordedPacketSamples(ogg_packet* aPacket)
+void
+VorbisState::AssertHasRecordedPacketSamples(ogg_packet* aPacket)
 {
 #ifdef VALIDATE_VORBIS_SAMPLE_CALCULATION
   NS_ASSERTION(mVorbisPacketSamples.count(aPacket) == 1,
     "Must have recorded packet samples");
 #endif
 }
 
-static ogg_packet* Clone(ogg_packet* aPacket) {
+static ogg_packet*
+Clone(ogg_packet* aPacket)
+{
   ogg_packet* p = new ogg_packet();
   memcpy(p, aPacket, sizeof(ogg_packet));
   p->packet = new unsigned char[p->bytes];
   memcpy(p->packet, aPacket->packet, p->bytes);
   return p;
 }
 
-void OggCodecState::ReleasePacket(ogg_packet* aPacket) {
+void
+OggCodecState::ReleasePacket(ogg_packet* aPacket)
+{
   if (aPacket)
     delete [] aPacket->packet;
   delete aPacket;
 }
 
-void OggPacketQueue::Append(ogg_packet* aPacket) {
+void
+OggPacketQueue::Append(ogg_packet* aPacket)
+{
   nsDeque::Push(aPacket);
 }
 
-bool OggCodecState::IsPacketReady()
+bool
+OggCodecState::IsPacketReady()
 {
   return !mPackets.IsEmpty();
 }
 
-ogg_packet* OggCodecState::PacketOut() {
+ogg_packet*
+OggCodecState::PacketOut()
+{
   if (mPackets.IsEmpty()) {
     return nullptr;
   }
   return mPackets.PopFront();
 }
 
-ogg_packet* OggCodecState::PacketPeek() {
+ogg_packet*
+OggCodecState::PacketPeek()
+{
   if (mPackets.IsEmpty()) {
     return nullptr;
   }
   return mPackets.PeekFront();
 }
 
-void OggCodecState::PushFront(OggPacketQueue &&aOther)
+void
+OggCodecState::PushFront(OggPacketQueue &&aOther)
 {
   while (!aOther.IsEmpty()) {
     mPackets.PushFront(aOther.Pop());
   }
 }
 
-RefPtr<MediaRawData> OggCodecState::PacketOutAsMediaRawData()
+RefPtr<MediaRawData>
+OggCodecState::PacketOutAsMediaRawData()
 {
   ogg_packet* packet = PacketOut();
   if (!packet) {
     return nullptr;
   }
 
   NS_ASSERTION(!IsHeader(packet), "PacketOutAsMediaRawData can only be called on non-header packets");
   RefPtr<MediaRawData> sample = new MediaRawData(packet->packet, packet->bytes);
@@ -226,39 +248,45 @@ RefPtr<MediaRawData> OggCodecState::Pack
   sample->mDuration = duration;
   sample->mKeyframe = IsKeyframe(packet);
 
   ReleasePacket(packet);
 
   return sample;
 }
 
-nsresult OggCodecState::PageIn(ogg_page* aPage) {
-  if (!mActive)
+nsresult
+OggCodecState::PageIn(ogg_page* aPage)
+{
+  if (!mActive) {
     return NS_OK;
+  }
   NS_ASSERTION(static_cast<uint32_t>(ogg_page_serialno(aPage)) == mSerial,
                "Page must be for this stream!");
-  if (ogg_stream_pagein(&mState, aPage) == -1)
+  if (ogg_stream_pagein(&mState, aPage) == -1) {
     return NS_ERROR_FAILURE;
+  }
   int r;
   do {
     ogg_packet packet;
     r = ogg_stream_packetout(&mState, &packet);
     if (r == 1) {
       mPackets.Append(Clone(&packet));
     }
   } while (r != 0);
   if (ogg_stream_check(&mState)) {
     NS_WARNING("Unrecoverable error in ogg_stream_packetout");
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 
-nsresult OggCodecState::PacketOutUntilGranulepos(bool& aFoundGranulepos) {
+nsresult
+OggCodecState::PacketOutUntilGranulepos(bool& aFoundGranulepos)
+{
   int r;
   aFoundGranulepos = false;
   // Extract packets from the sync state until either no more packets
   // come out, or we get a data packet with non -1 granulepos.
   do {
     ogg_packet packet;
     r = ogg_stream_packetout(&mState, &packet);
     if (r == 1) {
@@ -277,55 +305,59 @@ nsresult OggCodecState::PacketOutUntilGr
   } while (r != 0 && !aFoundGranulepos);
   if (ogg_stream_check(&mState)) {
     NS_WARNING("Unrecoverable error in ogg_stream_packetout");
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 
-TheoraState::TheoraState(ogg_page* aBosPage) :
-  OggCodecState(aBosPage, true),
-  mSetup(0),
-  mCtx(0),
-  mPixelAspectRatio(0)
+TheoraState::TheoraState(ogg_page* aBosPage)
+  : OggCodecState(aBosPage, true)
+  , mSetup(0)
+  , mCtx(0)
+  , mPixelAspectRatio(0)
 {
   MOZ_COUNT_CTOR(TheoraState);
   th_info_init(&mInfo);
   th_comment_init(&mComment);
 }
 
-TheoraState::~TheoraState() {
+TheoraState::~TheoraState()
+{
   MOZ_COUNT_DTOR(TheoraState);
   th_setup_free(mSetup);
   th_decode_free(mCtx);
   th_comment_clear(&mComment);
   th_info_clear(&mInfo);
 }
 
-bool TheoraState::Init() {
-  if (!mActive)
+bool
+TheoraState::Init()
+{
+  if (!mActive) {
     return false;
+  }
 
   int64_t n = mInfo.aspect_numerator;
   int64_t d = mInfo.aspect_denominator;
 
-  mPixelAspectRatio = (n == 0 || d == 0) ?
-    1.0f : static_cast<float>(n) / static_cast<float>(d);
+  mPixelAspectRatio = (n == 0 || d == 0)
+    ? 1.0f : static_cast<float>(n) / static_cast<float>(d);
 
   // Ensure the frame and picture regions aren't larger than our prescribed
   // maximum, or zero sized.
   nsIntSize frame(mInfo.frame_width, mInfo.frame_height);
   nsIntRect picture(mInfo.pic_x, mInfo.pic_y, mInfo.pic_width, mInfo.pic_height);
   if (!IsValidVideoRegion(frame, picture, frame)) {
     return mActive = false;
   }
 
   mCtx = th_decode_alloc(&mInfo, mSetup);
-  if (mCtx == nullptr) {
+  if (!mCtx) {
     return mActive = false;
   }
 
   return true;
 }
 
 bool
 TheoraState::DecodeHeader(ogg_packet* aPacket)
@@ -360,62 +392,73 @@ TheoraState::DecodeHeader(ogg_packet* aP
   } else if (ret > 0 && isSetupHeader && mPacketCount == 3) {
     // Successfully read the three header packets.
     mDoneReadingHeaders = true;
   }
   return true;
 }
 
 int64_t
-TheoraState::Time(int64_t granulepos) {
+TheoraState::Time(int64_t granulepos)
+{
   if (!mActive) {
     return -1;
   }
   return TheoraState::Time(&mInfo, granulepos);
 }
 
 bool
-TheoraState::IsHeader(ogg_packet* aPacket) {
+TheoraState::IsHeader(ogg_packet* aPacket)
+{
   return th_packet_isheader(aPacket);
 }
 
 # define TH_VERSION_CHECK(_info,_maj,_min,_sub) \
  (((_info)->version_major>(_maj)||(_info)->version_major==(_maj))&& \
  (((_info)->version_minor>(_min)||(_info)->version_minor==(_min))&& \
  (_info)->version_subminor>=(_sub)))
 
-int64_t TheoraState::Time(th_info* aInfo, int64_t aGranulepos)
+int64_t
+TheoraState::Time(th_info* aInfo, int64_t aGranulepos)
 {
   if (aGranulepos < 0 || aInfo->fps_numerator == 0) {
     return -1;
   }
   // Implementation of th_granule_frame inlined here to operate
   // on the th_info structure instead of the theora_state.
   int shift = aInfo->keyframe_granule_shift;
   ogg_int64_t iframe = aGranulepos >> shift;
   ogg_int64_t pframe = aGranulepos - (iframe << shift);
   int64_t frameno = iframe + pframe - TH_VERSION_CHECK(aInfo, 3, 2, 1);
-  CheckedInt64 t = ((CheckedInt64(frameno) + 1) * USECS_PER_S) * aInfo->fps_denominator;
-  if (!t.isValid())
+  CheckedInt64 t =
+    ((CheckedInt64(frameno) + 1) * USECS_PER_S) * aInfo->fps_denominator;
+  if (!t.isValid()) {
     return -1;
+  }
   t /= aInfo->fps_numerator;
   return t.isValid() ? t.value() : -1;
 }
 
-int64_t TheoraState::StartTime(int64_t granulepos) {
+int64_t TheoraState::StartTime(int64_t granulepos)
+{
   if (granulepos < 0 || !mActive || mInfo.fps_numerator == 0) {
     return -1;
   }
-  CheckedInt64 t = (CheckedInt64(th_granule_frame(mCtx, granulepos)) * USECS_PER_S) * mInfo.fps_denominator;
-  if (!t.isValid())
+  CheckedInt64 t =
+    (CheckedInt64(th_granule_frame(mCtx, granulepos)) * USECS_PER_S)
+    * mInfo.fps_denominator;
+  if (!t.isValid()) {
     return -1;
+  }
   return t.value() / mInfo.fps_numerator;
 }
 
-int64_t TheoraState::PacketDuration(ogg_packet* aPacket) {
+int64_t
+TheoraState::PacketDuration(ogg_packet* aPacket)
+{
   if (!mActive || mInfo.fps_numerator == 0) {
     return -1;
   }
   CheckedInt64 t = CheckedInt64(mInfo.fps_denominator) * USECS_PER_S;
   if (!t.isValid()) {
     return -1;
   }
   return t.value() / mInfo.fps_numerator;
@@ -489,17 +532,18 @@ TheoraVersion(th_info* info,
 {
   ogg_uint32_t ver = (maj << 16) + (min << 8) + sub;
   ogg_uint32_t th_ver = (info->version_major << 16) +
                         (info->version_minor << 8) +
                         info->version_subminor;
   return (th_ver >= ver) ? 1 : 0;
 }
 
-void TheoraState::ReconstructTheoraGranulepos()
+void
+TheoraState::ReconstructTheoraGranulepos()
 {
   if (mUnstamped.Length() == 0) {
     return;
   }
   ogg_int64_t lastGranulepos = mUnstamped[mUnstamped.Length() - 1]->granulepos;
   NS_ASSERTION(lastGranulepos != -1, "Must know last granulepos");
 
   // Reconstruct the granulepos (and thus timestamps) of the decoded
@@ -568,54 +612,58 @@ void TheoraState::ReconstructTheoraGranu
   // the last frame's (the known granule number). If not our granulepos
   // recovery missed a beat.
   NS_ASSERTION(mUnstamped.Length() < 2 ||
     th_granule_frame(mCtx, mUnstamped[mUnstamped.Length()-2]->granulepos) + 1 ==
     th_granule_frame(mCtx, lastGranulepos),
     "Granulepos recovery should catch up with packet->granulepos!");
 }
 
-nsresult VorbisState::Reset()
+nsresult
+VorbisState::Reset()
 {
   nsresult res = NS_OK;
   if (mActive && vorbis_synthesis_restart(&mDsp) != 0) {
     res = NS_ERROR_FAILURE;
   }
   if (NS_FAILED(OggCodecState::Reset())) {
     return NS_ERROR_FAILURE;
   }
 
   mGranulepos = 0;
   mPrevVorbisBlockSize = 0;
 
   return res;
 }
 
-VorbisState::VorbisState(ogg_page* aBosPage) :
-  OggCodecState(aBosPage, true),
-  mPrevVorbisBlockSize(0),
-  mGranulepos(0)
+VorbisState::VorbisState(ogg_page* aBosPage)
+  : OggCodecState(aBosPage, true)
+  , mPrevVorbisBlockSize(0)
+  , mGranulepos(0)
 {
   MOZ_COUNT_CTOR(VorbisState);
   vorbis_info_init(&mInfo);
   vorbis_comment_init(&mComment);
   memset(&mDsp, 0, sizeof(vorbis_dsp_state));
   memset(&mBlock, 0, sizeof(vorbis_block));
 }
 
-VorbisState::~VorbisState() {
+VorbisState::~VorbisState()
+{
   MOZ_COUNT_DTOR(VorbisState);
   Reset();
   vorbis_block_clear(&mBlock);
   vorbis_dsp_clear(&mDsp);
   vorbis_info_clear(&mInfo);
   vorbis_comment_clear(&mComment);
 }
 
-bool VorbisState::DecodeHeader(ogg_packet* aPacket) {
+bool
+VorbisState::DecodeHeader(ogg_packet* aPacket)
+{
   nsAutoRef<ogg_packet> autoRelease(aPacket);
   mPacketCount++;
   int ret = vorbis_synthesis_headerin(&mInfo,
                                       &mComment,
                                       aPacket);
   // We must determine when we've read the last header packet.
   // vorbis_synthesis_headerin() does not tell us when it's read the last
   // header, so we must keep track of the headers externally.
@@ -642,20 +690,22 @@ bool VorbisState::DecodeHeader(ogg_packe
   } else if (ret == 0 && isSetupHeader && mPacketCount == 3) {
     // Successfully read the three header packets.
     // The bitstream remains active.
     mDoneReadingHeaders = true;
   }
   return true;
 }
 
-bool VorbisState::Init()
+bool
+VorbisState::Init()
 {
-  if (!mActive)
+  if (!mActive) {
     return false;
+  }
 
   int ret = vorbis_synthesis_init(&mDsp, &mInfo);
   if (ret != 0) {
     NS_WARNING("vorbis_synthesis_init() failed initializing vorbis bitstream");
     return mActive = false;
   }
   ret = vorbis_block_init(&mDsp, &mBlock);
   if (ret != 0) {
@@ -663,37 +713,41 @@ bool VorbisState::Init()
     if (mActive) {
       vorbis_dsp_clear(&mDsp);
     }
     return mActive = false;
   }
   return true;
 }
 
-int64_t VorbisState::Time(int64_t granulepos)
+int64_t
+VorbisState::Time(int64_t granulepos)
 {
   if (!mActive) {
     return -1;
   }
 
   return VorbisState::Time(&mInfo, granulepos);
 }
 
-int64_t VorbisState::Time(vorbis_info* aInfo, int64_t aGranulepos)
+int64_t
+VorbisState::Time(vorbis_info* aInfo, int64_t aGranulepos)
 {
   if (aGranulepos == -1 || aInfo->rate == 0) {
     return -1;
   }
   CheckedInt64 t = CheckedInt64(aGranulepos) * USECS_PER_S;
-  if (!t.isValid())
+  if (!t.isValid()) {
     t = 0;
+  }
   return t.value() / aInfo->rate;
 }
 
-int64_t VorbisState::PacketDuration(ogg_packet* aPacket)
+int64_t
+VorbisState::PacketDuration(ogg_packet* aPacket)
 {
   if (!mActive) {
     return -1;
   }
   if (aPacket->granulepos == -1) {
     return -1;
   }
   // @FIXME store these in a more stable place
@@ -729,43 +783,46 @@ VorbisState::GetTags()
                      mComment.comment_lengths[i]);
   }
   return tags;
 }
 
 nsresult
 VorbisState::PageIn(ogg_page* aPage)
 {
-  if (!mActive)
+  if (!mActive) {
     return NS_OK;
+  }
   NS_ASSERTION(static_cast<uint32_t>(ogg_page_serialno(aPage)) == mSerial,
                "Page must be for this stream!");
   if (ogg_stream_pagein(&mState, aPage) == -1)
     return NS_ERROR_FAILURE;
   bool foundGp;
   nsresult res = PacketOutUntilGranulepos(foundGp);
-  if (NS_FAILED(res))
+  if (NS_FAILED(res)) {
     return res;
+  }
   if (foundGp && mDoneReadingHeaders) {
     // We've found a packet with a granulepos, and we've loaded our metadata
     // and initialized our decoder. Determine granulepos of buffered packets.
     ReconstructVorbisGranulepos();
     for (uint32_t i = 0; i < mUnstamped.Length(); ++i) {
       ogg_packet* packet = mUnstamped[i];
       AssertHasRecordedPacketSamples(packet);
       NS_ASSERTION(!IsHeader(packet), "Don't try to recover header packet gp");
       NS_ASSERTION(packet->granulepos != -1, "Packet must have gp by now");
       mPackets.Append(packet);
     }
     mUnstamped.Clear();
   }
   return NS_OK;
 }
 
-nsresult VorbisState::ReconstructVorbisGranulepos()
+nsresult
+VorbisState::ReconstructVorbisGranulepos()
 {
   // The number of samples in a Vorbis packet is:
   // window_blocksize(previous_packet)/4+window_blocksize(current_packet)/4
   // See: http://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-230001.3.2
   // So we maintain mPrevVorbisBlockSize, the block size of the last packet
   // encountered. We also maintain mGranulepos, which is the granulepos of
   // the last encountered packet. This enables us to give granulepos to
   // packets when the last packet in mUnstamped doesn't have a granulepos
@@ -866,43 +923,46 @@ nsresult VorbisState::ReconstructVorbisG
 
   mPrevVorbisBlockSize = vorbis_packet_blocksize(&mInfo, last);
   mPrevVorbisBlockSize = std::max(static_cast<long>(0), mPrevVorbisBlockSize);
   mGranulepos = last->granulepos;
 
   return NS_OK;
 }
 
-OpusState::OpusState(ogg_page* aBosPage) :
-  OggCodecState(aBosPage, true),
-  mParser(nullptr),
-  mDecoder(nullptr),
-  mSkip(0),
-  mPrevPacketGranulepos(0),
-  mPrevPageGranulepos(0)
+OpusState::OpusState(ogg_page* aBosPage)
+  : OggCodecState(aBosPage, true)
+  , mParser(nullptr)
+  , mDecoder(nullptr)
+  , mSkip(0)
+  , mPrevPacketGranulepos(0)
+  , mPrevPageGranulepos(0)
 {
   MOZ_COUNT_CTOR(OpusState);
 }
 
-OpusState::~OpusState() {
+OpusState::~OpusState()
+{
   MOZ_COUNT_DTOR(OpusState);
   Reset();
 
   if (mDecoder) {
     opus_multistream_decoder_destroy(mDecoder);
     mDecoder = nullptr;
   }
 }
 
-nsresult OpusState::Reset()
+nsresult
+OpusState::Reset()
 {
   return Reset(false);
 }
 
-nsresult OpusState::Reset(bool aStart)
+nsresult
+OpusState::Reset(bool aStart)
 {
   nsresult res = NS_OK;
 
   if (mActive && mDecoder) {
     // Reset the decoder.
     opus_multistream_decoder_ctl(mDecoder, OPUS_RESET_STATE);
     // Let the seek logic handle pre-roll if we're not seeking to the start.
     mSkip = aStart ? mParser->mPreSkip : 0;
@@ -917,20 +977,22 @@ nsresult OpusState::Reset(bool aStart)
     return NS_ERROR_FAILURE;
   }
 
   LOG(LogLevel::Debug, ("Opus decoder reset, to skip %d", mSkip));
 
   return res;
 }
 
-bool OpusState::Init(void)
+bool
+OpusState::Init(void)
 {
-  if (!mActive)
+  if (!mActive) {
     return false;
+  }
 
   int error;
 
   NS_ASSERTION(mDecoder == nullptr, "leaking OpusDecoder");
 
   mDecoder = opus_multistream_decoder_create(mParser->mRate,
                                              mParser->mChannels,
                                              mParser->mStreams,
@@ -940,144 +1002,155 @@ bool OpusState::Init(void)
 
   mSkip = mParser->mPreSkip;
 
   LOG(LogLevel::Debug, ("Opus decoder init, to skip %d", mSkip));
 
   return error == OPUS_OK;
 }
 
-bool OpusState::DecodeHeader(ogg_packet* aPacket)
+bool
+OpusState::DecodeHeader(ogg_packet* aPacket)
 {
   nsAutoRef<ogg_packet> autoRelease(aPacket);
   switch(mPacketCount++) {
     // Parse the id header.
-    case 0: {
-        mParser = new OpusParser;
-        if(!mParser->DecodeHeader(aPacket->packet, aPacket->bytes)) {
-          return false;
-        }
-        mRate = mParser->mRate;
-        mChannels = mParser->mChannels;
-        mPreSkip = mParser->mPreSkip;
+    case 0:
+      mParser = new OpusParser;
+      if (!mParser->DecodeHeader(aPacket->packet, aPacket->bytes)) {
+        return false;
+      }
+      mRate = mParser->mRate;
+      mChannels = mParser->mChannels;
+      mPreSkip = mParser->mPreSkip;
 #ifdef MOZ_SAMPLE_TYPE_FLOAT32
-        mGain = mParser->mGain;
+      mGain = mParser->mGain;
 #else
-        mGain_Q16 = mParser->mGain_Q16;
+      mGain_Q16 = mParser->mGain_Q16;
 #endif
-    }
-    break;
+      break;
 
     // Parse the metadata header.
-    case 1: {
-        if(!mParser->DecodeTags(aPacket->packet, aPacket->bytes)) {
-          return false;
-        }
-    }
-    break;
+    case 1:
+      if (!mParser->DecodeTags(aPacket->packet, aPacket->bytes)) {
+        return false;
+      }
+      break;
 
     // We made it to the first data packet (which includes reconstructing
     // timestamps for it in PageIn). Success!
-    default: {
+    default:
       mDoneReadingHeaders = true;
       // Put it back on the queue so we can decode it.
       mPackets.PushFront(autoRelease.disown());
-    }
-    break;
+      break;
   }
   return true;
 }
 
 /* Construct and return a tags hashmap from our internal array */
-MetadataTags* OpusState::GetTags()
+MetadataTags*
+OpusState::GetTags()
 {
   MetadataTags* tags;
 
   tags = new MetadataTags;
   for (uint32_t i = 0; i < mParser->mTags.Length(); i++) {
     AddVorbisComment(tags, mParser->mTags[i].Data(), mParser->mTags[i].Length());
   }
 
   return tags;
 }
 
 /* Return the timestamp (in microseconds) equivalent to a granulepos. */
-int64_t OpusState::Time(int64_t aGranulepos)
+int64_t
+OpusState::Time(int64_t aGranulepos)
 {
-  if (!mActive)
+  if (!mActive) {
     return -1;
+  }
 
   return Time(mParser->mPreSkip, aGranulepos);
 }
 
-int64_t OpusState::Time(int aPreSkip, int64_t aGranulepos)
+int64_t
+OpusState::Time(int aPreSkip, int64_t aGranulepos)
 {
-  if (aGranulepos < 0)
+  if (aGranulepos < 0) {
     return -1;
+  }
 
   // Ogg Opus always runs at a granule rate of 48 kHz.
   CheckedInt64 t = (CheckedInt64(aGranulepos) - aPreSkip) * USECS_PER_S;
   return t.isValid() ? t.value() / 48000 : -1;
 }
 
-bool OpusState::IsHeader(ogg_packet* aPacket)
+bool
+OpusState::IsHeader(ogg_packet* aPacket)
 {
   return aPacket->bytes >= 16 &&
          (!memcmp(aPacket->packet, "OpusHead", 8) ||
           !memcmp(aPacket->packet, "OpusTags", 8));
 }
 
-nsresult OpusState::PageIn(ogg_page* aPage)
+nsresult
+OpusState::PageIn(ogg_page* aPage)
 {
-  if (!mActive)
+  if (!mActive) {
     return NS_OK;
+  }
   NS_ASSERTION(static_cast<uint32_t>(ogg_page_serialno(aPage)) == mSerial,
                "Page must be for this stream!");
   if (ogg_stream_pagein(&mState, aPage) == -1)
     return NS_ERROR_FAILURE;
 
   bool haveGranulepos;
   nsresult rv = PacketOutUntilGranulepos(haveGranulepos);
-  if (NS_FAILED(rv) || !haveGranulepos || mPacketCount < 2)
+  if (NS_FAILED(rv) || !haveGranulepos || mPacketCount < 2) {
     return rv;
-  if(!ReconstructOpusGranulepos())
+  }
+  if (!ReconstructOpusGranulepos()) {
     return NS_ERROR_FAILURE;
+  }
   for (uint32_t i = 0; i < mUnstamped.Length(); i++) {
     ogg_packet* packet = mUnstamped[i];
     NS_ASSERTION(!IsHeader(packet), "Don't try to play a header packet");
     NS_ASSERTION(packet->granulepos != -1, "Packet should have a granulepos");
     mPackets.Append(packet);
   }
   mUnstamped.Clear();
   return NS_OK;
 }
 
 // Helper method to return the change in granule position due to an Opus packet
 // (as distinct from the number of samples in the packet, which depends on the
 // decoder rate). It should work with a multistream Opus file, and continue to
 // work should we ever allow the decoder to decode at a rate other than 48 kHz.
 // It even works before we've created the actual Opus decoder.
-static int GetOpusDeltaGP(ogg_packet* packet)
+static int
+GetOpusDeltaGP(ogg_packet* packet)
 {
   int nframes;
   nframes = opus_packet_get_nb_frames(packet->packet, packet->bytes);
   if (nframes > 0) {
     return nframes*opus_packet_get_samples_per_frame(packet->packet, 48000);
   }
   NS_WARNING("Invalid Opus packet.");
   return nframes;
 }
 
-int64_t OpusState::PacketDuration(ogg_packet* aPacket)
+int64_t
+OpusState::PacketDuration(ogg_packet* aPacket)
 {
   CheckedInt64 t = CheckedInt64(GetOpusDeltaGP(aPacket)) * USECS_PER_S;
   return t.isValid() ? t.value() / 48000 : -1;
 }
 
-bool OpusState::ReconstructOpusGranulepos(void)
+bool
+OpusState::ReconstructOpusGranulepos(void)
 {
   NS_ASSERTION(mUnstamped.Length() > 0, "Must have unstamped packets");
   ogg_packet* last = mUnstamped[mUnstamped.Length()-1];
   NS_ASSERTION(last->e_o_s || last->granulepos > 0,
       "Must know last granulepos!");
   int64_t gp;
   // If this is the last page, and we've seen at least one previous page (or
   // this is the first page)...
@@ -1149,27 +1222,28 @@ bool OpusState::ReconstructOpusGranulepo
     }
     mUnstamped[i - 1]->granulepos = gp;
   }
 
   // Check to make sure the first granule position is at least as large as the
   // total number of samples decodable from the first page with completed
   // packets. This requires looking at the duration of the first packet, too.
   // We MUST reject such streams.
-  if (!mDoneReadingHeaders && GetOpusDeltaGP(mUnstamped[0]) > gp)
+  if (!mDoneReadingHeaders && GetOpusDeltaGP(mUnstamped[0]) > gp) {
     return false;
+  }
   mPrevPageGranulepos = last->granulepos;
   return true;
 }
 
-SkeletonState::SkeletonState(ogg_page* aBosPage) :
-  OggCodecState(aBosPage, true),
-  mVersion(0),
-  mPresentationTime(0),
-  mLength(0)
+SkeletonState::SkeletonState(ogg_page* aBosPage)
+  : OggCodecState(aBosPage, true)
+  , mVersion(0)
+  , mPresentationTime(0)
+  , mLength(0)
 {
   MOZ_COUNT_CTOR(SkeletonState);
 }
 
 SkeletonState::~SkeletonState()
 {
   MOZ_COUNT_DTOR(SkeletonState);
 }
@@ -1209,62 +1283,67 @@ static const size_t INDEX_TIME_DENOM_OFF
 static const size_t INDEX_FIRST_NUMER_OFFSET = 26;
 static const size_t INDEX_LAST_NUMER_OFFSET = 34;
 static const size_t INDEX_KEYPOINT_OFFSET = 42;
 
 // Byte-offsets of the fields in the Skeleton Fisbone packet.
 static const size_t FISBONE_MSG_FIELDS_OFFSET = 8;
 static const size_t FISBONE_SERIALNO_OFFSET = 12;
 
-static bool IsSkeletonBOS(ogg_packet* aPacket)
+static bool
+IsSkeletonBOS(ogg_packet* aPacket)
 {
   static_assert(SKELETON_MIN_HEADER_LEN >= 8,
                 "Minimum length of skeleton BOS header incorrect");
   return aPacket->bytes >= SKELETON_MIN_HEADER_LEN &&
          memcmp(reinterpret_cast<char*>(aPacket->packet), "fishead", 8) == 0;
 }
 
-static bool IsSkeletonIndex(ogg_packet* aPacket)
+static bool
+IsSkeletonIndex(ogg_packet* aPacket)
 {
   static_assert(SKELETON_4_0_MIN_INDEX_LEN >= 5,
                 "Minimum length of skeleton index header incorrect");
   return aPacket->bytes >= SKELETON_4_0_MIN_INDEX_LEN &&
          memcmp(reinterpret_cast<char*>(aPacket->packet), "index", 5) == 0;
 }
 
-static bool IsSkeletonFisbone(ogg_packet* aPacket)
+static bool
+IsSkeletonFisbone(ogg_packet* aPacket)
 {
   static_assert(SKELETON_MIN_FISBONE_LEN >= 8,
                 "Minimum length of skeleton fisbone header incorrect");
   return aPacket->bytes >= SKELETON_MIN_FISBONE_LEN &&
          memcmp(reinterpret_cast<char*>(aPacket->packet), "fisbone", 8) == 0;
 }
 
 // Reads a variable length encoded integer at p. Will not read
 // past aLimit. Returns pointer to character after end of integer.
-static const unsigned char* ReadVariableLengthInt(const unsigned char* p,
-                                                  const unsigned char* aLimit,
-                                                  int64_t& n)
+static const unsigned char*
+ReadVariableLengthInt(const unsigned char* p,
+                      const unsigned char* aLimit,
+                      int64_t& n)
 {
   int shift = 0;
   int64_t byte = 0;
   n = 0;
   while (p < aLimit &&
          (byte & 0x80) != 0x80 &&
          shift < 57)
   {
     byte = static_cast<int64_t>(*p);
     n |= ((byte & 0x7f) << shift);
     shift += 7;
     p++;
   }
   return p;
 }
 
-bool SkeletonState::DecodeIndex(ogg_packet* aPacket)
+bool
+SkeletonState::DecodeIndex(ogg_packet* aPacket)
 {
   NS_ASSERTION(aPacket->bytes >= SKELETON_4_0_MIN_INDEX_LEN,
                "Index must be at least minimum size");
   if (!mActive) {
     return false;
   }
 
   uint32_t serialno = LittleEndian::readUint32(aPacket->packet + INDEX_SERIALNO_OFFSET);
@@ -1295,28 +1374,28 @@ bool SkeletonState::DecodeIndex(ogg_pack
   if (!t.isValid()) {
     return (mActive = false);
   } else {
     endTime = t.value() / timeDenom;
   }
 
   // Check the numKeyPoints value read, ensure we're not going to run out of
   // memory while trying to decode the index packet.
-  CheckedInt64 minPacketSize = (CheckedInt64(numKeyPoints) * MIN_KEY_POINT_SIZE) + INDEX_KEYPOINT_OFFSET;
+  CheckedInt64 minPacketSize =
+    (CheckedInt64(numKeyPoints) * MIN_KEY_POINT_SIZE) + INDEX_KEYPOINT_OFFSET;
   if (!minPacketSize.isValid())
   {
     return (mActive = false);
   }
 
   int64_t sizeofIndex = aPacket->bytes - INDEX_KEYPOINT_OFFSET;
   int64_t maxNumKeyPoints = sizeofIndex / MIN_KEY_POINT_SIZE;
   if (aPacket->bytes < minPacketSize.value() ||
       numKeyPoints > maxNumKeyPoints ||
-      numKeyPoints < 0)
-  {
+      numKeyPoints < 0) {
     // Packet size is less than the theoretical minimum size, or the packet is
     // claiming to store more keypoints than it's capable of storing. This means
     // that the numKeyPoints field is too large or small for the packet to
     // possibly contain as many packets as it claims to, so the numKeyPoints
     // field is possibly malicious. Don't try decoding this index, we may run
     // out of memory.
     LOG(LogLevel::Debug, ("Possibly malicious number of key points reported "
                        "(%lld) in index packet for stream %u.",
@@ -1327,67 +1406,62 @@ bool SkeletonState::DecodeIndex(ogg_pack
 
   nsAutoPtr<nsKeyFrameIndex> keyPoints(new nsKeyFrameIndex(startTime, endTime));
 
   p = aPacket->packet + INDEX_KEYPOINT_OFFSET;
   const unsigned char* limit = aPacket->packet + aPacket->bytes;
   int64_t numKeyPointsRead = 0;
   CheckedInt64 offset = 0;
   CheckedInt64 time = 0;
-  while (p < limit &&
-         numKeyPointsRead < numKeyPoints)
-  {
+  while (p < limit && numKeyPointsRead < numKeyPoints) {
     int64_t delta = 0;
     p = ReadVariableLengthInt(p, limit, delta);
     offset += delta;
     if (p == limit ||
         !offset.isValid() ||
         offset.value() > mLength ||
-        offset.value() < 0)
-    {
+        offset.value() < 0) {
       return (mActive = false);
     }
     p = ReadVariableLengthInt(p, limit, delta);
     time += delta;
     if (!time.isValid() ||
         time.value() > endTime ||
-        time.value() < startTime)
-    {
+        time.value() < startTime) {
       return (mActive = false);
     }
     CheckedInt64 timeUsecs = time * USECS_PER_S;
-    if (!timeUsecs.isValid())
+    if (!timeUsecs.isValid()) {
       return mActive = false;
+    }
     timeUsecs /= timeDenom;
     keyPoints->Add(offset.value(), timeUsecs.value());
     numKeyPointsRead++;
   }
 
   int32_t keyPointsRead = keyPoints->Length();
   if (keyPointsRead > 0) {
     mIndex.Put(serialno, keyPoints.forget());
   }
 
   LOG(LogLevel::Debug, ("Loaded %d keypoints for Skeleton on stream %u",
                      keyPointsRead, serialno));
   return true;
 }
 
-nsresult SkeletonState::IndexedSeekTargetForTrack(uint32_t aSerialno,
-                                                    int64_t aTarget,
-                                                    nsKeyPoint& aResult)
+nsresult
+SkeletonState::IndexedSeekTargetForTrack(uint32_t aSerialno,
+                                         int64_t aTarget,
+                                         nsKeyPoint& aResult)
 {
   nsKeyFrameIndex* index = nullptr;
   mIndex.Get(aSerialno, &index);
 
-  if (!index ||
-      index->Length() == 0 ||
-      aTarget < index->mStartTime ||
-      aTarget > index->mEndTime)
-  {
+  if (!index || index->Length() == 0 ||
+      aTarget < index->mStartTime || aTarget > index->mEndTime) {
     return NS_ERROR_FAILURE;
   }
 
   // Binary search to find the last key point with time less than target.
   int start = 0;
   int end = index->Length() - 1;
   while (end > start) {
     int mid = start + ((end - start + 1) >> 1);
@@ -1401,54 +1475,54 @@ nsresult SkeletonState::IndexedSeekTarge
     }
   }
 
   aResult = index->Get(start);
   NS_ASSERTION(aResult.mTime <= aTarget, "Result should have time <= target");
   return NS_OK;
 }
 
-nsresult SkeletonState::IndexedSeekTarget(int64_t aTarget,
-                                            nsTArray<uint32_t>& aTracks,
-                                            nsSeekTarget& aResult)
+nsresult
+SkeletonState::IndexedSeekTarget(int64_t aTarget,
+                                 nsTArray<uint32_t>& aTracks,
+                                 nsSeekTarget& aResult)
 {
   if (!mActive || mVersion < SKELETON_VERSION(4,0)) {
     return NS_ERROR_FAILURE;
   }
   // Loop over all requested tracks' indexes, and get the keypoint for that
   // seek target. Record the keypoint with the lowest offset, this will be
   // our seek result. User must seek to the one with lowest offset to ensure we
   // pass "keyframes" on all tracks when we decode forwards to the seek target.
   nsSeekTarget r;
   for (uint32_t i=0; i<aTracks.Length(); i++) {
     nsKeyPoint k;
     if (NS_SUCCEEDED(IndexedSeekTargetForTrack(aTracks[i], aTarget, k)) &&
-        k.mOffset < r.mKeyPoint.mOffset)
-    {
+        k.mOffset < r.mKeyPoint.mOffset) {
       r.mKeyPoint = k;
       r.mSerial = aTracks[i];
     }
   }
   if (r.IsNull()) {
     return NS_ERROR_FAILURE;
   }
   LOG(LogLevel::Debug, ("Indexed seek target for time %lld is offset %lld",
                      aTarget, r.mKeyPoint.mOffset));
   aResult = r;
   return NS_OK;
 }
 
-nsresult SkeletonState::GetDuration(const nsTArray<uint32_t>& aTracks,
-                                      int64_t& aDuration)
+nsresult
+SkeletonState::GetDuration(const nsTArray<uint32_t>& aTracks,
+                           int64_t& aDuration)
 {
   if (!mActive ||
       mVersion < SKELETON_VERSION(4,0) ||
       !HasIndex() ||
-      aTracks.Length() == 0)
-  {
+      aTracks.Length() == 0) {
     return NS_ERROR_FAILURE;
   }
   int64_t endTime = INT64_MIN;
   int64_t startTime = INT64_MAX;
   for (uint32_t i=0; i<aTracks.Length(); i++) {
     nsKeyFrameIndex* index = nullptr;
     mIndex.Get(aTracks[i], &index);
     if (!index) {
@@ -1463,29 +1537,33 @@ nsresult SkeletonState::GetDuration(cons
     }
   }
   NS_ASSERTION(endTime > startTime, "Duration must be positive");
   CheckedInt64 duration = CheckedInt64(endTime) - startTime;
   aDuration = duration.isValid() ? duration.value() : 0;
   return duration.isValid() ? NS_OK : NS_ERROR_FAILURE;
 }
 
-bool SkeletonState::DecodeFisbone(ogg_packet* aPacket)
+bool
+SkeletonState::DecodeFisbone(ogg_packet* aPacket)
 {
   if (aPacket->bytes < static_cast<long>(FISBONE_MSG_FIELDS_OFFSET + 4)) {
     return false;
   }
-  uint32_t offsetMsgField = LittleEndian::readUint32(aPacket->packet + FISBONE_MSG_FIELDS_OFFSET);
+  uint32_t offsetMsgField =
+    LittleEndian::readUint32(aPacket->packet + FISBONE_MSG_FIELDS_OFFSET);
 
   if (aPacket->bytes < static_cast<long>(FISBONE_SERIALNO_OFFSET + 4)) {
       return false;
   }
-  uint32_t serialno = LittleEndian::readUint32(aPacket->packet + FISBONE_SERIALNO_OFFSET);
+  uint32_t serialno =
+    LittleEndian::readUint32(aPacket->packet + FISBONE_SERIALNO_OFFSET);
 
-  CheckedUint32 checked_fields_pos = CheckedUint32(FISBONE_MSG_FIELDS_OFFSET) + offsetMsgField;
+  CheckedUint32 checked_fields_pos =
+    CheckedUint32(FISBONE_MSG_FIELDS_OFFSET) + offsetMsgField;
   if (!checked_fields_pos.isValid() ||
       aPacket->bytes < static_cast<int64_t>(checked_fields_pos.value())) {
     return false;
   }
   int64_t msgLength = aPacket->bytes - checked_fields_pos.value();
   char* msgProbe = (char*)aPacket->packet + checked_fields_pos.value();
   char* msgHead = msgProbe;
   nsAutoPtr<MessageField> field(new MessageField());
@@ -1542,38 +1620,46 @@ bool SkeletonState::DecodeFisbone(ogg_pa
     mMsgFieldStore.Put(serialno, field.forget());
   } else {
     return false;
   }
 
   return true;
 }
 
-bool SkeletonState::DecodeHeader(ogg_packet* aPacket)
+bool
+SkeletonState::DecodeHeader(ogg_packet* aPacket)
 {
   nsAutoRef<ogg_packet> autoRelease(aPacket);
   if (IsSkeletonBOS(aPacket)) {
-    uint16_t verMajor = LittleEndian::readUint16(aPacket->packet + SKELETON_VERSION_MAJOR_OFFSET);
-    uint16_t verMinor = LittleEndian::readUint16(aPacket->packet + SKELETON_VERSION_MINOR_OFFSET);
+    uint16_t verMajor =
+      LittleEndian::readUint16(aPacket->packet + SKELETON_VERSION_MAJOR_OFFSET);
+    uint16_t verMinor =
+      LittleEndian::readUint16(aPacket->packet + SKELETON_VERSION_MINOR_OFFSET);
 
     // Read the presentation time. We read this before the version check as the
     // presentation time exists in all versions.
-    int64_t n = LittleEndian::readInt64(aPacket->packet + SKELETON_PRESENTATION_TIME_NUMERATOR_OFFSET);
-    int64_t d = LittleEndian::readInt64(aPacket->packet + SKELETON_PRESENTATION_TIME_DENOMINATOR_OFFSET);
-    mPresentationTime = d == 0 ? 0 : (static_cast<float>(n) / static_cast<float>(d)) * USECS_PER_S;
+    int64_t n =
+      LittleEndian::readInt64(aPacket->packet + SKELETON_PRESENTATION_TIME_NUMERATOR_OFFSET);
+    int64_t d =
+      LittleEndian::readInt64(aPacket->packet + SKELETON_PRESENTATION_TIME_DENOMINATOR_OFFSET);
+    mPresentationTime =
+      d == 0 ? 0 : (static_cast<float>(n) / static_cast<float>(d)) * USECS_PER_S;
 
     mVersion = SKELETON_VERSION(verMajor, verMinor);
     // We can only care to parse Skeleton version 4.0+.
     if (mVersion < SKELETON_VERSION(4,0) ||
         mVersion >= SKELETON_VERSION(5,0) ||
-        aPacket->bytes < SKELETON_4_0_MIN_HEADER_LEN)
+        aPacket->bytes < SKELETON_4_0_MIN_HEADER_LEN) {
       return false;
+    }
 
     // Extract the segment length.
-    mLength = LittleEndian::readInt64(aPacket->packet + SKELETON_FILE_LENGTH_OFFSET);
+    mLength =
+      LittleEndian::readInt64(aPacket->packet + SKELETON_FILE_LENGTH_OFFSET);
 
     LOG(LogLevel::Debug, ("Skeleton segment length: %lld", mLength));
 
     // Initialize the serialno-to-index map.
     return true;
   } else if (IsSkeletonIndex(aPacket) && mVersion >= SKELETON_VERSION(4,0)) {
     return DecodeIndex(aPacket);
   } else if (IsSkeletonFisbone(aPacket)) {
--- a/dom/media/ogg/OggCodecState.h
+++ b/dom/media/ogg/OggCodecState.h
@@ -35,18 +35,20 @@
 #include <map>
 #endif
 
 #include "OpusParser.h"
 
 namespace mozilla {
 
 // Deallocates a packet, used in OggPacketQueue below.
-class OggPacketDeallocator : public nsDequeFunctor {
-  virtual void* operator() (void* aPacket) {
+class OggPacketDeallocator : public nsDequeFunctor
+{
+  virtual void* operator() (void* aPacket)
+  {
     ogg_packet* p = static_cast<ogg_packet*>(aPacket);
     delete [] p->packet;
     delete p;
     return nullptr;
   }
 };
 
 // A queue of ogg_packets. When we read a page, we extract the page's packets
@@ -54,36 +56,39 @@ class OggPacketDeallocator : public nsDe
 // if we're skipping up to the next keyframe in very large frame sized videos,
 // there may be several megabytes of data between keyframes, and the
 // ogg_stream_state would end up resizing its buffer every time we added a
 // new 4KB page to the bitstream, which kills performance on Windows. This
 // also gives us the option to timestamp packets rather than decoded
 // frames/samples, reducing the amount of frames/samples we must decode to
 // determine start-time at a particular offset, and gives us finer control
 // over memory usage.
-class OggPacketQueue : private nsDeque {
+class OggPacketQueue : private nsDeque
+{
 public:
   OggPacketQueue() : nsDeque(new OggPacketDeallocator()) {}
   ~OggPacketQueue() { Erase(); }
   bool IsEmpty() { return nsDeque::GetSize() == 0; }
   void Append(ogg_packet* aPacket);
   ogg_packet* PopFront() { return static_cast<ogg_packet*>(nsDeque::PopFront()); }
   ogg_packet* PeekFront() { return static_cast<ogg_packet*>(nsDeque::PeekFront()); }
   ogg_packet* Pop() { return static_cast<ogg_packet*>(nsDeque::Pop()); }
   void PushFront(ogg_packet* aPacket) { nsDeque::PushFront(aPacket); }
   void Erase() { nsDeque::Erase(); }
 };
 
 // Encapsulates the data required for decoding an ogg bitstream and for
 // converting granulepos to timestamps.
-class OggCodecState {
+class OggCodecState
+{
 public:
   typedef mozilla::MetadataTags MetadataTags;
   // Ogg types we know about
-  enum CodecType {
+  enum CodecType
+  {
     TYPE_VORBIS=0,
     TYPE_THEORA=1,
     TYPE_OPUS=2,
     TYPE_SKELETON=3,
     TYPE_UNKNOWN=4
   };
 
   virtual ~OggCodecState();
@@ -94,36 +99,39 @@ public:
   
   virtual CodecType GetType() { return TYPE_UNKNOWN; }
 
   // Reads a header packet. Returns false if an error was encountered
   // while reading header packets. Callers should check DoneReadingHeaders()
   // to determine if the last header has been read.
   // This function takes ownership of the packet and is responsible for
   // releasing it or queuing it for later processing.
-  virtual bool DecodeHeader(ogg_packet* aPacket) {
+  virtual bool DecodeHeader(ogg_packet* aPacket)
+  {
     return (mDoneReadingHeaders = true);
   }
 
   // Build a hash table with tag metadata parsed from the stream.
-  virtual MetadataTags* GetTags() {
+  virtual MetadataTags* GetTags()
+  {
     return nullptr;
   }
 
   // Returns the end time that a granulepos represents.
   virtual int64_t Time(int64_t granulepos) { return -1; }
 
   // Returns the start time that a granulepos represents.
   virtual int64_t StartTime(int64_t granulepos) { return -1; }
 
   // Returns the duration of the given packet, if it can be determined.
   virtual int64_t PacketDuration(ogg_packet* aPacket) { return -1; }
 
   // Returns the start time of the given packet, if it can be determined.
-  virtual int64_t PacketStartTime(ogg_packet* aPacket) {
+  virtual int64_t PacketStartTime(ogg_packet* aPacket)
+  {
     if (aPacket->granulepos < 0) {
       return -1;
     }
     int64_t endTime = Time(aPacket->granulepos);
     int64_t duration = PacketDuration(aPacket);
     if (duration > endTime) {
       // Audio preskip may eat a whole packet or more.
       return 0;
@@ -136,17 +144,18 @@ public:
   virtual bool Init();
 
   // Returns true when this bitstream has finished reading all its
   // header packets.
   bool DoneReadingHeaders() { return mDoneReadingHeaders; }
 
   // Deactivates the bitstream. Only the primary video and audio bitstreams
   // should be active.
-  void Deactivate() {
+  void Deactivate()
+  {
     mActive = false;
     mDoneReadingHeaders = true;
     Reset();
   }
 
   // Resets decoding state.
   virtual nsresult Reset();
 
@@ -245,17 +254,18 @@ protected:
   // Utility method to parse and add a vorbis-style comment
   // to a metadata hash table. Most Ogg-encapsulated codecs
   // use the vorbis comment format for metadata.
   static bool AddVorbisComment(MetadataTags* aTags,
                         const char* aComment,
                         uint32_t aLength);
 };
 
-class VorbisState : public OggCodecState {
+class VorbisState : public OggCodecState
+{
 public:
   explicit VorbisState(ogg_page* aBosPage);
   virtual ~VorbisState();
 
   CodecType GetType() override { return TYPE_VORBIS; }
   bool DecodeHeader(ogg_packet* aPacket) override;
   int64_t Time(int64_t granulepos) override;
   int64_t PacketDuration(ogg_packet* aPacket) override;
@@ -319,17 +329,18 @@ public:
 
 // Returns 1 if the Theora info struct is decoding a media of Theora
 // version (maj,min,sub) or later, otherwise returns 0.
 int TheoraVersion(th_info* info,
                   unsigned char maj,
                   unsigned char min,
                   unsigned char sub);
 
-class TheoraState : public OggCodecState {
+class TheoraState : public OggCodecState
+{
 public:
   explicit TheoraState(ogg_page* aBosPage);
   virtual ~TheoraState();
 
   CodecType GetType() override { return TYPE_THEORA; }
   bool DecodeHeader(ogg_packet* aPacket) override;
   int64_t Time(int64_t granulepos) override;
   int64_t StartTime(int64_t granulepos) override;
@@ -359,17 +370,18 @@ private:
   // mUnstamped array. mUnstamped must be filled with consecutive packets from
   // the stream, with the last packet having a known granulepos. Using this
   // known granulepos, and the known frame numbers, we recover the granulepos
   // of all frames in the array. This enables us to determine their timestamps.
   void ReconstructTheoraGranulepos();
 
 };
 
-class OpusState : public OggCodecState {
+class OpusState : public OggCodecState
+{
 public:
   explicit OpusState(ogg_page* aBosPage);
   virtual ~OpusState();
 
   CodecType GetType() override { return TYPE_OPUS; }
   bool DecodeHeader(ogg_packet* aPacket) override;
   int64_t Time(int64_t aGranulepos) override;
   int64_t PacketDuration(ogg_packet* aPacket) override;
@@ -430,27 +442,30 @@ enum EMsgHeaderType {
   eLanguage,
   eTitle,
   eDisplayHint,
   eAltitude,
   eTrackOrder,
   eTrackDependencies
 };
 
-typedef struct {
+typedef struct
+{
   const char* mPatternToRecognize;
   EMsgHeaderType mMsgHeaderType;
 } FieldPatternType;
 
 // Stores the message information for different logical bitstream.
-typedef struct {
+typedef struct
+{
   nsClassHashtable<nsUint32HashKey, nsCString> mValuesStore;
 } MessageField;
 
-class SkeletonState : public OggCodecState {
+class SkeletonState : public OggCodecState
+{
 public:
   explicit SkeletonState(ogg_page* aBosPage);
   ~SkeletonState();
 
   nsClassHashtable<nsUint32HashKey, MessageField> mMsgFieldStore;
 
   CodecType GetType() override { return TYPE_SKELETON; }
   bool DecodeHeader(ogg_packet* aPacket) override;
@@ -459,59 +474,62 @@ public:
   bool IsHeader(ogg_packet* aPacket) override { return true; }
 
   // Return true if the given time (in milliseconds) is within
   // the presentation time defined in the skeleton track.
   bool IsPresentable(int64_t aTime) { return aTime >= mPresentationTime; }
 
   // Stores the offset of the page on which a keyframe starts,
   // and its presentation time.
-  class nsKeyPoint {
+  class nsKeyPoint
+  {
   public:
     nsKeyPoint()
-      : mOffset(INT64_MAX),
-        mTime(INT64_MAX) {}
+      : mOffset(INT64_MAX)
+      , mTime(INT64_MAX) {}
 
     nsKeyPoint(int64_t aOffset, int64_t aTime)
-      : mOffset(aOffset),
-        mTime(aTime) {}
+      : mOffset(aOffset)
+      ,mTime(aTime) {}
 
     // Offset from start of segment/link-in-the-chain in bytes.
     int64_t mOffset;
 
     // Presentation time in usecs.
     int64_t mTime;
 
-    bool IsNull() {
-      return mOffset == INT64_MAX &&
-             mTime == INT64_MAX;
+    bool IsNull()
+    {
+      return mOffset == INT64_MAX && mTime == INT64_MAX;
     }
   };
 
   // Stores a keyframe's byte-offset, presentation time and the serialno
   // of the stream it belongs to.
-  class nsSeekTarget {
+  class nsSeekTarget
+  {
   public:
     nsSeekTarget() : mSerial(0) {}
     nsKeyPoint mKeyPoint;
     uint32_t mSerial;
-    bool IsNull() {
-      return mKeyPoint.IsNull() &&
-             mSerial == 0;
+    bool IsNull()
+    {
+      return mKeyPoint.IsNull() && mSerial == 0;
     }
   };
 
   // Determines from the seek index the keyframe which you must seek back to
   // in order to get all keyframes required to render all streams with
   // serialnos in aTracks, at time aTarget.
   nsresult IndexedSeekTarget(int64_t aTarget,
                              nsTArray<uint32_t>& aTracks,
                              nsSeekTarget& aResult);
 
-  bool HasIndex() const {
+  bool HasIndex() const
+  {
     return mIndex.Count() > 0;
   }
 
   // Returns the duration of the active tracks in the media, if we have
   // an index. aTracks must be filled with the serialnos of the active tracks.
   // The duration is calculated as the greatest end time of all active tracks,
   // minus the smalled start time of all the active tracks.
   nsresult GetDuration(const nsTArray<uint32_t>& aTracks, int64_t& aDuration);
@@ -535,39 +553,44 @@ private:
   // Presentation time of the resource in milliseconds
   int64_t mPresentationTime;
 
   // Length of the resource in bytes.
   int64_t mLength;
 
   // Stores the keyframe index and duration information for a particular
   // stream.
-  class nsKeyFrameIndex {
+  class nsKeyFrameIndex
+  {
   public:
 
     nsKeyFrameIndex(int64_t aStartTime, int64_t aEndTime) 
-      : mStartTime(aStartTime),
-        mEndTime(aEndTime)
+      : mStartTime(aStartTime)
+      , mEndTime(aEndTime)
     {
       MOZ_COUNT_CTOR(nsKeyFrameIndex);
     }
 
-    ~nsKeyFrameIndex() {
+    ~nsKeyFrameIndex()
+    {
       MOZ_COUNT_DTOR(nsKeyFrameIndex);
     }
 
-    void Add(int64_t aOffset, int64_t aTimeMs) {
+    void Add(int64_t aOffset, int64_t aTimeMs)
+    {
       mKeyPoints.AppendElement(nsKeyPoint(aOffset, aTimeMs));
     }
 
-    const nsKeyPoint& Get(uint32_t aIndex) const {
+    const nsKeyPoint& Get(uint32_t aIndex) const
+    {
       return mKeyPoints[aIndex];
     }
 
-    uint32_t Length() const {
+    uint32_t Length() const
+    {
       return mKeyPoints.Length();
     }
 
     // Presentation time of the first sample in this stream in usecs.
     const int64_t mStartTime;
 
     // End time of the last sample in this stream in usecs.
     const int64_t mEndTime;
@@ -583,15 +606,16 @@ private:
 } // namespace mozilla
 
 // This allows the use of nsAutoRefs for an ogg_packet that properly free the
 // contents of the packet.
 template <>
 class nsAutoRefTraits<ogg_packet> : public nsPointerRefTraits<ogg_packet>
 {
 public:
-  static void Release(ogg_packet* aPacket) {
+  static void Release(ogg_packet* aPacket)
+  {
     mozilla::OggCodecState::ReleasePacket(aPacket);
   }
 };
 
 
 #endif