--- a/dom/media/MediaCache.cpp
+++ b/dom/media/MediaCache.cpp
@@ -692,17 +692,17 @@ static int32_t GetMaxBlocks()
   int32_t cacheSize = Preferences::GetInt("media.cache_size", 500*1024);
   int64_t maxBlocks = static_cast<int64_t>(cacheSize)*1024/MediaCache::BLOCK_SIZE;
   maxBlocks = std::max<int64_t>(maxBlocks, 1);
   return int32_t(std::min<int64_t>(maxBlocks, INT32_MAX));
 }
 
 int32_t
 MediaCache::FindBlockForIncomingData(TimeStamp aNow,
-                                       MediaCacheStream* aStream)
+                                     MediaCacheStream* aStream)
 {
   mReentrantMonitor.AssertCurrentThreadIn();
 
   int32_t blockIndex = FindReusableBlock(aNow, aStream,
       aStream->mChannelOffset/BLOCK_SIZE, INT32_MAX);
 
   if (blockIndex < 0 || !IsBlockFree(blockIndex)) {
     // The block returned is already allocated.
@@ -1311,17 +1311,17 @@ MediaCache::Update()
 
   // First, update the mCacheSuspended/mCacheEnded flags so that they're all correct
   // when we fire our CacheClient commands below. Those commands can rely on these flags
   // being set correctly for all streams.
   for (uint32_t i = 0; i < mStreams.Length(); ++i) {
     MediaCacheStream* stream = mStreams[i];
     switch (actions[i]) {
     case SEEK:
-	case SEEK_AND_RESUME:
+    case SEEK_AND_RESUME:
       stream->mCacheSuspended = false;
       stream->mChannelEnded = false;
       break;
     case RESUME:
       stream->mCacheSuspended = false;
       break;
     case SUSPEND:
       stream->mCacheSuspended = true;
@@ -1332,17 +1332,17 @@ MediaCache::Update()
     stream->mHasHadUpdate = true;
   }
 
   for (uint32_t i = 0; i < mStreams.Length(); ++i) {
     MediaCacheStream* stream = mStreams[i];
     nsresult rv;
     switch (actions[i]) {
     case SEEK:
-	case SEEK_AND_RESUME:
+    case SEEK_AND_RESUME:
       CACHE_LOG(LogLevel::Debug, ("Stream %p CacheSeek to %lld (resume=%d)", stream,
                 (long long)stream->mChannelOffset, actions[i] == SEEK_AND_RESUME));
       rv = stream->mClient->CacheClientSeek(stream->mChannelOffset,
                                             actions[i] == SEEK_AND_RESUME);
       break;
     case RESUME:
       CACHE_LOG(LogLevel::Debug, ("Stream %p Resumed", stream));
       rv = stream->mClient->CacheClientResume();
@@ -1475,17 +1475,17 @@ MediaCache::InsertReadaheadBlock(BlockOw
   }
 
   stream->mReadaheadBlocks.AddFirstBlock(aBlockIndex);
   Verify();
 }
 
 void
 MediaCache::AllocateAndWriteBlock(MediaCacheStream* aStream, const void* aData,
-                                    MediaCacheStream::ReadMode aMode)
+                                  MediaCacheStream::ReadMode aMode)
 {
   mReentrantMonitor.AssertCurrentThreadIn();
 
   int32_t streamBlockIndex = aStream->mChannelOffset/BLOCK_SIZE;
 
   // Remove all cached copies of this block
   ResourceStreamIterator iter(aStream->mResourceID);
   while (MediaCacheStream* stream = iter.Next()) {

--- a/dom/media/ogg/OggReader.cpp
+++ b/dom/media/ogg/OggReader.cpp
@@ -1052,18 +1052,18 @@ int64_t OggReader::RangeEndTime(int64_t 
   int64_t position = mResource.Tell();
   int64_t endTime = RangeEndTime(0, aEndOffset, false);
   nsresult res = mResource.Seek(nsISeekableStream::NS_SEEK_SET, position);
   NS_ENSURE_SUCCESS(res, -1);
   return endTime;
 }
 
 int64_t OggReader::RangeEndTime(int64_t aStartOffset,
-                                  int64_t aEndOffset,
-                                  bool aCachedDataOnly)
+                                int64_t aEndOffset,
+                                bool aCachedDataOnly)
 {
   nsAutoOggSyncState sync;
 
   // We need to find the last page which ends before aEndOffset that
   // has a granulepos that we can convert to a timestamp. We do this by
   // backing off from aEndOffset until we encounter a page on which we can
   // interpret the granulepos. If while backing off we encounter a page which
   // we've previously encountered before, we'll either backoff again if we