Bug 995730 - Change xpcom/base/ to use 2 space indentation
authorBirunthan Mohanathas <birunthan@mohanathas.com>
Mon, 05 May 2014 20:30:39 +0300
changeset 181564 4e27f466ebbb6578ab008f231f12a00917c2c718
parent 181562 0f9fb2d2f4acf83b64f3921d18c0be23e471e71b
child 181565 7db230827e21908f2911fd02f894a2f3508c0a10
push id26724
push userkwierso@gmail.com
push dateTue, 06 May 2014 03:51:22 +0000
treeherdermozilla-central@6d991528460d [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs995730
milestone32.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 995730 - Change xpcom/base/ to use 2 space indentation This also removes trailing whitespace in reindented files.
xpcom/base/AvailableMemoryTracker.cpp
xpcom/base/CycleCollectedJSRuntime.cpp
xpcom/base/CycleCollectedJSRuntime.h
xpcom/base/StaticPtr.h
xpcom/base/SystemMemoryReporter.cpp
xpcom/base/SystemMemoryReporter.h
xpcom/base/VisualEventTracer.cpp
xpcom/base/VisualEventTracer.h
xpcom/base/nsAgg.h
xpcom/base/nsAutoPtr.h
xpcom/base/nsAutoRef.h
xpcom/base/nsConsoleMessage.cpp
xpcom/base/nsConsoleMessage.h
xpcom/base/nsConsoleService.cpp
xpcom/base/nsConsoleService.h
xpcom/base/nsCrashOnException.cpp
xpcom/base/nsCrashOnException.h
xpcom/base/nsCycleCollector.cpp
xpcom/base/nsDebugImpl.cpp
xpcom/base/nsDebugImpl.h
xpcom/base/nsDumpUtils.cpp
xpcom/base/nsDumpUtils.h
xpcom/base/nsError.h
xpcom/base/nsErrorService.cpp
xpcom/base/nsErrorService.h
xpcom/base/nsISupportsObsolete.h
xpcom/base/nsMacUtilsImpl.cpp
xpcom/base/nsMemoryImpl.cpp
xpcom/base/nsMemoryImpl.h
xpcom/base/nsMemoryInfoDumper.cpp
xpcom/base/nsMemoryReporterManager.cpp
xpcom/base/nsObjCExceptions.h
xpcom/base/nsSecurityConsoleMessage.h
xpcom/base/nsStackWalk.cpp
xpcom/base/nsStackWalk.h
xpcom/base/nsStatusReporterManager.cpp
xpcom/base/nsSystemInfo.cpp
xpcom/base/nsSystemInfo.h
xpcom/base/nsTraceRefcnt.cpp
xpcom/base/nsTraceRefcnt.h
xpcom/base/nsUUIDGenerator.cpp
xpcom/base/nsUUIDGenerator.h
xpcom/base/nsVersionComparatorImpl.cpp
xpcom/base/nsWindowsHelpers.h
xpcom/base/nscore.h
--- a/xpcom/base/AvailableMemoryTracker.cpp
+++ b/xpcom/base/AvailableMemoryTracker.cpp
@@ -485,25 +485,25 @@ void Activate()
 
   // On 64-bit systems, hardcode sLowVirtualMemoryThreshold to 0 -- we assume
   // we're not going to run out of virtual memory!
   if (sizeof(void*) > 4) {
     sLowVirtualMemoryThreshold = 0;
   }
   else {
     Preferences::AddUintVarCache(&sLowVirtualMemoryThreshold,
-        "memory.low_virtual_mem_threshold_mb", 128);
+                                 "memory.low_virtual_mem_threshold_mb", 128);
   }
 
   Preferences::AddUintVarCache(&sLowPhysicalMemoryThreshold,
-      "memory.low_physical_memory_threshold_mb", 0);
+                               "memory.low_physical_memory_threshold_mb", 0);
   Preferences::AddUintVarCache(&sLowCommitSpaceThreshold,
-      "memory.low_commit_space_threshold_mb", 128);
+                               "memory.low_commit_space_threshold_mb", 128);
   Preferences::AddUintVarCache(&sLowMemoryNotificationIntervalMS,
-      "memory.low_memory_notification_interval_ms", 10000);
+                               "memory.low_memory_notification_interval_ms", 10000);
 
   RegisterStrongMemoryReporter(new LowEventsReporter());
   RegisterLowMemoryEventsVirtualDistinguishedAmount(LowMemoryEventsVirtualDistinguishedAmount);
   RegisterLowMemoryEventsPhysicalDistinguishedAmount(LowMemoryEventsPhysicalDistinguishedAmount);
   sHooksActive = true;
 #endif
 
   // This object is held alive by the observer service.
@@ -525,26 +525,26 @@ void Init()
 #if defined(_M_IX86) && defined(XP_WIN)
   // Don't register the hooks if we're a build instrumented for PGO: If we're
   // an instrumented build, the compiler adds function calls all over the place
   // which may call VirtualAlloc; this makes it hard to prevent
   // VirtualAllocHook from reentering itself.
   if (!PR_GetEnv("MOZ_PGO_INSTRUMENTED")) {
     sKernel32Intercept.Init("Kernel32.dll");
     sKernel32Intercept.AddHook("VirtualAlloc",
-      reinterpret_cast<intptr_t>(VirtualAllocHook),
-      (void**) &sVirtualAllocOrig);
+                               reinterpret_cast<intptr_t>(VirtualAllocHook),
+                               (void**) &sVirtualAllocOrig);
     sKernel32Intercept.AddHook("MapViewOfFile",
-      reinterpret_cast<intptr_t>(MapViewOfFileHook),
-      (void**) &sMapViewOfFileOrig);
+                               reinterpret_cast<intptr_t>(MapViewOfFileHook),
+                               (void**) &sMapViewOfFileOrig);
 
     sGdi32Intercept.Init("Gdi32.dll");
     sGdi32Intercept.AddHook("CreateDIBSection",
-      reinterpret_cast<intptr_t>(CreateDIBSectionHook),
-      (void**) &sCreateDIBSectionOrig);
+                            reinterpret_cast<intptr_t>(CreateDIBSectionHook),
+                            (void**) &sCreateDIBSectionOrig);
   }
 
   sInitialized = true;
 #endif
 }
 
 } // namespace AvailableMemoryTracker
 } // namespace mozilla
--- a/xpcom/base/CycleCollectedJSRuntime.cpp
+++ b/xpcom/base/CycleCollectedJSRuntime.cpp
@@ -118,17 +118,17 @@ AddToCCKind(JSGCTraceKind kind)
 }
 
 static void
 TraceWeakMappingChild(JSTracer* trc, void** thingp, JSGCTraceKind kind);
 
 struct NoteWeakMapChildrenTracer : public JSTracer
 {
   NoteWeakMapChildrenTracer(JSRuntime *rt, nsCycleCollectionNoteRootCallback& cb)
-  : JSTracer(rt, TraceWeakMappingChild), mCb(cb)
+    : JSTracer(rt, TraceWeakMappingChild), mCb(cb)
   {
   }
   nsCycleCollectionNoteRootCallback& mCb;
   bool mTracedAny;
   JSObject* mMap;
   void* mKey;
   void* mKeyDelegate;
 };
@@ -156,27 +156,27 @@ TraceWeakMappingChild(JSTracer* trc, voi
     JS_TraceChildren(trc, thing, kind);
   }
 }
 
 struct NoteWeakMapsTracer : public js::WeakMapTracer
 {
   NoteWeakMapsTracer(JSRuntime* rt, js::WeakMapTraceCallback cb,
                      nsCycleCollectionNoteRootCallback& cccb)
-  : js::WeakMapTracer(rt, cb), mCb(cccb), mChildTracer(rt, cccb)
+    : js::WeakMapTracer(rt, cb), mCb(cccb), mChildTracer(rt, cccb)
   {
   }
   nsCycleCollectionNoteRootCallback& mCb;
   NoteWeakMapChildrenTracer mChildTracer;
 };
 
 static void
 TraceWeakMapping(js::WeakMapTracer* trc, JSObject* m,
-               void* k, JSGCTraceKind kkind,
-               void* v, JSGCTraceKind vkind)
+                 void* k, JSGCTraceKind kkind,
+                 void* v, JSGCTraceKind vkind)
 {
   MOZ_ASSERT(trc->callback == TraceWeakMapping);
   NoteWeakMapsTracer* tracer = static_cast<NoteWeakMapsTracer* >(trc);
 
   // If nothing that could be held alive by this entry is marked gray, return.
   if ((!k || !xpc_IsGrayGCThing(k)) && MOZ_LIKELY(!tracer->mCb.WantAllTraces())) {
     if (!v || !xpc_IsGrayGCThing(v) || vkind == JSTRACE_STRING) {
       return;
@@ -686,17 +686,17 @@ CycleCollectedJSRuntime::TraverseZone(JS
   TraverseObjectShimClosure closure = { aCb, this };
   js::IterateGrayObjects(aZone, TraverseObjectShim, &closure);
 }
 
 /* static */ void
 CycleCollectedJSRuntime::TraverseObjectShim(void* aData, void* aThing)
 {
   TraverseObjectShimClosure* closure =
-      static_cast<TraverseObjectShimClosure*>(aData);
+    static_cast<TraverseObjectShimClosure*>(aData);
 
   MOZ_ASSERT(js::GCThingTraceKind(aThing) == JSTRACE_OBJECT);
   closure->self->TraverseGCThing(CycleCollectedJSRuntime::TRAVERSE_CPP, aThing,
                                  JSTRACE_OBJECT, closure->cb);
 }
 
 void
 CycleCollectedJSRuntime::TraverseNativeRoots(nsCycleCollectionNoteRootCallback& aCb)
@@ -882,23 +882,23 @@ void
 CycleCollectedJSRuntime::SetPendingException(nsIException* aException)
 {
   mPendingException = aException;
 }
 
 nsCycleCollectionParticipant*
 CycleCollectedJSRuntime::GCThingParticipant()
 {
-    return &mGCThingCycleCollectorGlobal;
+  return &mGCThingCycleCollectorGlobal;
 }
 
 nsCycleCollectionParticipant*
 CycleCollectedJSRuntime::ZoneParticipant()
 {
-    return &mJSZoneCycleCollectorGlobal;
+  return &mJSZoneCycleCollectorGlobal;
 }
 
 nsresult
 CycleCollectedJSRuntime::TraverseRoots(nsCycleCollectionNoteRootCallback &aCb)
 {
   TraverseNativeRoots(aCb);
 
   NoteWeakMapsTracer trc(mJSRuntime, TraceWeakMapping, aCb);
--- a/xpcom/base/CycleCollectedJSRuntime.h
+++ b/xpcom/base/CycleCollectedJSRuntime.h
@@ -141,18 +141,18 @@ private:
   virtual bool
   NoteCustomGCThingXPCOMChildren(const js::Class* aClasp, JSObject* aObj,
                                  nsCycleCollectionTraversalCallback& aCb) const
   {
     return false; // We did nothing.
   }
 
   enum TraverseSelect {
-      TRAVERSE_CPP,
-      TRAVERSE_FULL
+    TRAVERSE_CPP,
+    TRAVERSE_FULL
   };
 
   void
   TraverseGCThing(TraverseSelect aTs, void* aThing,
                   JSGCTraceKind aTraceKind,
                   nsCycleCollectionTraversalCallback& aCb);
 
   void
--- a/xpcom/base/StaticPtr.h
+++ b/xpcom/base/StaticPtr.h
@@ -1,10 +1,10 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set sw=2 ts=8 et ft=cpp : */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 #ifndef mozilla_StaticPtr_h
 #define mozilla_StaticPtr_h
 
 #include "mozilla/Assertions.h"
@@ -32,72 +32,72 @@ namespace mozilla {
  *
  * Static{Auto,Ref}Ptr have a limited interface as compared to ns{Auto,Ref}Ptr;
  * this is intentional, since their range of acceptable uses is smaller.
  */
 
 template<class T>
 class StaticAutoPtr
 {
-  public:
-    // In debug builds, check that mRawPtr is initialized for us as we expect
-    // by the compiler.  In non-debug builds, don't declare a constructor
-    // so that the compiler can see that the constructor is trivial.
+public:
+  // In debug builds, check that mRawPtr is initialized for us as we expect
+  // by the compiler.  In non-debug builds, don't declare a constructor
+  // so that the compiler can see that the constructor is trivial.
 #ifdef DEBUG
-    StaticAutoPtr()
-    {
-      MOZ_ASSERT(!mRawPtr);
-    }
+  StaticAutoPtr()
+  {
+    MOZ_ASSERT(!mRawPtr);
+  }
 #endif
 
-    StaticAutoPtr<T>& operator=(T* rhs)
-    {
-      Assign(rhs);
-      return *this;
-    }
+  StaticAutoPtr<T>& operator=(T* rhs)
+  {
+    Assign(rhs);
+    return *this;
+  }
 
-    T* get() const
-    {
-      return mRawPtr;
-    }
+  T* get() const
+  {
+    return mRawPtr;
+  }
 
-    operator T*() const
-    {
-      return get();
-    }
+  operator T*() const
+  {
+    return get();
+  }
 
-    T* operator->() const
-    {
-      MOZ_ASSERT(mRawPtr);
-      return get();
-    }
+  T* operator->() const
+  {
+    MOZ_ASSERT(mRawPtr);
+    return get();
+  }
 
-    T& operator*() const
-    {
-      return *get();
-    }
+  T& operator*() const
+  {
+    return *get();
+  }
 
-  private:
-    // Disallow copy constructor, but only in debug mode.  We only define
-    // a default constructor in debug mode (see above); if we declared
-    // this constructor always, the compiler wouldn't generate a trivial
-    // default constructor for us in non-debug mode.
+private:
+  // Disallow copy constructor, but only in debug mode.  We only define
+  // a default constructor in debug mode (see above); if we declared
+  // this constructor always, the compiler wouldn't generate a trivial
+  // default constructor for us in non-debug mode.
 #ifdef DEBUG
-    StaticAutoPtr(StaticAutoPtr<T> &other);
+  StaticAutoPtr(StaticAutoPtr<T> &other);
 #endif
 
-    void Assign(T* newPtr)
-    {
-      MOZ_ASSERT(!newPtr || mRawPtr != newPtr);
-      T* oldPtr = mRawPtr;
-      mRawPtr = newPtr;
-      delete oldPtr;
-    }
+  void Assign(T* newPtr)
+  {
+    MOZ_ASSERT(!newPtr || mRawPtr != newPtr);
+    T* oldPtr = mRawPtr;
+    mRawPtr = newPtr;
+    delete oldPtr;
+  }
 
-    T* mRawPtr;
+  T* mRawPtr;
 };
 
 template<class T>
 class StaticRefPtr
 {
 public:
   // In debug builds, check that mRawPtr is initialized for us as we expect
   // by the compiler.  In non-debug builds, don't declare a constructor
--- a/xpcom/base/SystemMemoryReporter.cpp
+++ b/xpcom/base/SystemMemoryReporter.cpp
@@ -125,17 +125,17 @@ public:
       if (NS_WARN_IF(NS_FAILED(rv))) {                                        \
         _cleanup;                                                             \
         return rv;                                                            \
       }                                                                       \
     }                                                                         \
   } while (0)
 
 #define REPORT(_path, _amount, _desc) \
-    REPORT_WITH_CLEANUP(_path, UNITS_BYTES, _amount, _desc, (void)0)
+  REPORT_WITH_CLEANUP(_path, UNITS_BYTES, _amount, _desc, (void)0)
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData)
   {
     if (!Preferences::GetBool("memory.system_memory_reporter")) {
       return NS_OK;
     }
 
@@ -621,26 +621,26 @@ private:
     }
     closedir(d);
     return NS_OK;
   }
 
   uint64_t
   ReadSizeFromFile(const char* aFilename)
   {
-      FILE* sizeFile = fopen(aFilename, "r");
-      if (NS_WARN_IF(!sizeFile)) {
-        return 0;
-      }
+    FILE* sizeFile = fopen(aFilename, "r");
+    if (NS_WARN_IF(!sizeFile)) {
+      return 0;
+    }
 
-      uint64_t size = 0;
-      fscanf(sizeFile, "%" SCNu64, &size);
-      fclose(sizeFile);
+    uint64_t size = 0;
+    fscanf(sizeFile, "%" SCNu64, &size);
+    fclose(sizeFile);
 
-      return size;
+    return size;
   }
 
   nsresult
   CollectZramReports(nsIHandleReportCallback* aHandleReport,
                      nsISupports* aData)
   {
     // zram usage stats files can be found under:
     //  /sys/block/zram<id>
@@ -676,57 +676,57 @@ private:
       nsPrintfCString origSizeFile("/sys/block/%s/orig_data_size", name);
 
       uint64_t diskSize = ReadSizeFromFile(diskSizeFile.get());
       uint64_t origSize = ReadSizeFromFile(origSizeFile.get());
       uint64_t unusedSize = diskSize - origSize;
 
       nsPrintfCString diskUsedPath("zram-disksize/%s/used", name);
       nsPrintfCString diskUsedDesc(
-                           "The uncompressed size of data stored in \"%s.\" "
-                           "This excludes zero-filled pages since "
-                           "no memory is allocated for them.", name);
+        "The uncompressed size of data stored in \"%s.\" "
+        "This excludes zero-filled pages since "
+        "no memory is allocated for them.", name);
       REPORT_WITH_CLEANUP(diskUsedPath, UNITS_BYTES, origSize,
                           diskUsedDesc, closedir(d));
 
       nsPrintfCString diskUnusedPath("zram-disksize/%s/unused", name);
       nsPrintfCString diskUnusedDesc(
-                           "The amount of uncompressed data that can still be "
-                           "be stored in \"%s\"", name);
+        "The amount of uncompressed data that can still be "
+        "be stored in \"%s\"", name);
       REPORT_WITH_CLEANUP(diskUnusedPath, UNITS_BYTES, unusedSize,
                           diskUnusedDesc, closedir(d));
 
       // Report disk accesses.
       nsPrintfCString readsFile("/sys/block/%s/num_reads", name);
       nsPrintfCString writesFile("/sys/block/%s/num_writes", name);
 
       uint64_t reads = ReadSizeFromFile(readsFile.get());
       uint64_t writes = ReadSizeFromFile(writesFile.get());
 
       nsPrintfCString readsDesc(
-                           "The number of reads (failed or successful) done on "
-                           "\"%s\"", name);
+        "The number of reads (failed or successful) done on "
+        "\"%s\"", name);
       nsPrintfCString readsPath("zram-accesses/%s/reads", name);
       REPORT_WITH_CLEANUP(readsPath, UNITS_COUNT_CUMULATIVE, reads,
                           readsDesc, closedir(d));
 
       nsPrintfCString writesDesc(
-                           "The number of writes (failed or successful) done "
-                           "on \"%s\"", name);
+        "The number of writes (failed or successful) done "
+        "on \"%s\"", name);
       nsPrintfCString writesPath("zram-accesses/%s/writes", name);
       REPORT_WITH_CLEANUP(writesPath, UNITS_COUNT_CUMULATIVE, writes,
                           writesDesc, closedir(d));
 
       // Report compressed data size.
       nsPrintfCString comprSizeFile("/sys/block/%s/compr_data_size", name);
       uint64_t comprSize = ReadSizeFromFile(comprSizeFile.get());
 
       nsPrintfCString comprSizeDesc(
-                           "The compressed size of data stored in \"%s\"",
-                            name);
+        "The compressed size of data stored in \"%s\"",
+        name);
       nsPrintfCString comprSizePath("zram-compr-data-size/%s", name);
       REPORT_WITH_CLEANUP(comprSizePath, UNITS_BYTES, comprSize,
                           comprSizeDesc, closedir(d));
     }
 
     closedir(d);
     return NS_OK;
   }
@@ -811,25 +811,25 @@ private:
 
 #undef REPORT
 };
 
 NS_IMPL_ISUPPORTS(SystemReporter, nsIMemoryReporter)
 
 // Keep this in sync with SystemReporter::ProcessSizeKind!
 const char* SystemReporter::kindPathSuffixes[] = {
-    "anonymous/outside-brk",
-    "anonymous/brk-heap",
-    "shared-libraries/read-executable",
-    "shared-libraries/read-write",
-    "shared-libraries/read-only",
-    "shared-libraries/other",
-    "other-files",
-    "main-thread-stack",
-    "vdso"
+  "anonymous/outside-brk",
+  "anonymous/brk-heap",
+  "shared-libraries/read-executable",
+  "shared-libraries/read-write",
+  "shared-libraries/read-only",
+  "shared-libraries/other",
+  "other-files",
+  "main-thread-stack",
+  "vdso"
 };
 
 void Init()
 {
   RegisterStrongMemoryReporter(new SystemReporter());
 }
 
 } // namespace SystemMemoryReporter
--- a/xpcom/base/SystemMemoryReporter.h
+++ b/xpcom/base/SystemMemoryReporter.h
@@ -1,25 +1,25 @@
-/* -*- Mode: C++; tab-width: 50; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim:set ts=2 sw=2 sts=2 ci et: */
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 #ifndef mozilla_SystemMemoryReporter_h_
 #define mozilla_SystemMemoryReporter_h_
 
 namespace mozilla {
 namespace SystemMemoryReporter {
 
 // This only works on Linux, but to make callers' lives easier, we stub out
 // empty functions on other platforms.
 
 #if defined(XP_LINUX)
-  void Init();
+void Init();
 #else
-  void Init() {}
+void Init() {}
 #endif
 
 } // namespace SystemMemoryReporter
 } // namespace mozilla
 
 #endif
--- a/xpcom/base/VisualEventTracer.cpp
+++ b/xpcom/base/VisualEventTracer.cpp
@@ -38,39 +38,39 @@ mozilla::TimeStamp * gProfilerStart;
 
 // Duration of the log to keep up to
 mozilla::TimeDuration * gMaxBacklogTime;
 
 
 // Record of a single event
 class Record {
 public:
-  Record() 
+  Record()
     : mType(::mozilla::eventtracer::eNone)
     , mItem(nullptr)
     , mText(nullptr)
-    , mText2(nullptr) 
+    , mText2(nullptr)
   {
     MOZ_COUNT_CTOR(Record);
-  } 
+  }
 
   Record& operator=(const Record & aOther)
   {
     mType = aOther.mType;
     mTime = aOther.mTime;
     mItem = aOther.mItem;
     mText = PL_strdup(aOther.mText);
     mText2 = aOther.mText2 ? PL_strdup(aOther.mText2) : nullptr;
     return *this;
   }
 
-  ~Record() 
+  ~Record()
   {
     PL_strfree(mText2);
-    PL_strfree(mText); 
+    PL_strfree(mText);
     MOZ_COUNT_DTOR(Record);
   }
 
   uint32_t mType;
   TimeStamp mTime;
   void * mItem;
   char * mText;
   char * mText2;
@@ -349,17 +349,17 @@ EventFilter::Build(const char * filterVa
   // Reads a comma serpatated list of events.
 
   // Copied from nspr logging code (read of NSPR_LOG_MODULES)
   char eventName[64];
   int pos = 0, count, delta = 0;
 
   // Read up to a comma or EOF -> get name of an event first in the list
   count = sscanf(filterVar, "%63[^,]%n", eventName, &delta);
-  if (count == 0) 
+  if (count == 0)
     return nullptr;
 
   pos = delta;
 
   // Skip a comma, if present, accept spaces around it
   count = sscanf(filterVar + pos, " , %n", &delta);
   if (count != EOF)
     pos += delta;
@@ -377,17 +377,17 @@ EventFilter::EventPasses(const char * ev
     return true;
 
   if (mNext)
     return mNext->EventPasses(eventName);
 
   return false;
 }
 
-// State and control variables, initialized in Init() method, after it 
+// State and control variables, initialized in Init() method, after it
 // immutable and read concurently.
 EventFilter * gEventFilter = nullptr;
 unsigned gThreadPrivateIndex;
 
 // static
 bool CheckEventFilters(uint32_t aType, void * aItem, const char * aText)
 {
   if (!gEventFilter)
@@ -398,17 +398,17 @@ bool CheckEventFilters(uint32_t aType, v
 
   return gEventFilter->EventPasses(aText);
 }
 
 } // anon namespace
 
 #endif //MOZ_VISUAL_EVENT_TRACER
 
-// static 
+// static
 void Init()
 {
 #ifdef MOZ_VISUAL_EVENT_TRACER
   const char * logEvents = PR_GetEnv("MOZ_PROFILING_EVENTS");
   if (logEvents && *logEvents)
     gEventFilter = EventFilter::Build(logEvents);
 
   PRStatus status = PR_NewThreadPrivateIndex(&gThreadPrivateIndex, &RecordBatch::Close);
@@ -421,17 +421,17 @@ void Init()
 
   gProfilerStart = new mozilla::TimeStamp();
   gMaxBacklogTime = new mozilla::TimeDuration();
 
   gInitialized = true;
 #endif
 }
 
-// static 
+// static
 void Shutdown()
 {
 #ifdef MOZ_VISUAL_EVENT_TRACER
   gCapture = false;
   gInitialized = false;
 
   RecordBatch::DeleteLog();
 
@@ -452,31 +452,31 @@ void Shutdown()
 
   if (gMaxBacklogTime) {
     delete gMaxBacklogTime;
     gMaxBacklogTime = nullptr;
   }
 #endif
 }
 
-// static 
+// static
 void Mark(uint32_t aType, void * aItem, const char * aText, const char * aText2)
 {
 #ifdef MOZ_VISUAL_EVENT_TRACER
   if (!gInitialized || !gCapture)
     return;
 
   if (aType == eNone)
     return;
 
   if (!CheckEventFilters(aType, aItem, aText)) // Events use just aText
     return;
 
   RecordBatch * threadLogPrivate = static_cast<RecordBatch *>(
-      PR_GetThreadPrivate(gThreadPrivateIndex));
+    PR_GetThreadPrivate(gThreadPrivateIndex));
   if (!threadLogPrivate) {
     threadLogPrivate = RecordBatch::Register();
     if (!threadLogPrivate)
       return;
 
     PR_SetThreadPrivate(gThreadPrivateIndex, threadLogPrivate);
   }
 
@@ -584,17 +584,17 @@ nsresult
 VisualEventTracerLog::WriteToProfilingFile()
 {
   const char* filename = PR_GetEnv("MOZ_TRACE_FILE");
   if (!filename) {
     return NS_OK;
   }
 
   PRFileDesc* fd = PR_Open(filename, PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE,
-			   0644);
+                           0644);
   if (!fd) {
     return NS_ERROR_FILE_ACCESS_DENIED;
   }
 
   nsCString json;
   GetJSONString(json);
 
   int32_t bytesWritten = PR_Write(fd, json.get(), json.Length());
--- a/xpcom/base/VisualEventTracer.h
+++ b/xpcom/base/VisualEventTracer.h
@@ -2,113 +2,113 @@
  * 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/. */
 
 /* Visual event tracer, creates a log of events on each thread for visualization */
 
 /**
  * The event tracer code is by default disabled in both build and run time.
  *
- * To enable this code at build time, add --enable-visual-profiling to your 
+ * To enable this code at build time, add --enable-visual-profiling to your
  * configure options.
  *
  * To enable this code at run time, export MOZ_TRACE_FILE env var with a
  * path to the file to write the log to. This is all you need to * produce
  * the log of all events instrumentation in the mozilla code. Check
  * MOZ_EVENT_TRACER_* macros below to add your own.
  *
- * To let the event tracer log only some events to save disk space, export 
- * MOZ_PROFILING_EVENTS with comma separated list of event names you want 
+ * To let the event tracer log only some events to save disk space, export
+ * MOZ_PROFILING_EVENTS with comma separated list of event names you want
  * to record in the log.
  */
 
 #ifndef VisualEventTracer_h___
 #define VisualEventTracer_h___
 
 #include <stdint.h>
 #include "mozilla/Attributes.h"
 #include "mozilla/GuardObjects.h"
 
 #ifdef MOZ_VISUAL_EVENT_TRACER
 #include "nsIVisualEventTracer.h"
 
-// Bind an object instance, usually |this|, to a name, usually URL or 
-// host name, the instance deals with for its lifetime.  The name string 
+// Bind an object instance, usually |this|, to a name, usually URL or
+// host name, the instance deals with for its lifetime.  The name string
 // is duplicated.
 // IMPORTANT: it is up to the caller to pass the correct static_cast
 // of the |instance| pointer to all these macros ; otherwise the linking
 // of events and objects will not work!
 // The name will show in details of the events on the timeline and also
 // will allow events filtering by host names, URLs etc.
 #define MOZ_EVENT_TRACER_NAME_OBJECT(instance, name) \
   mozilla::eventtracer::Mark(mozilla::eventtracer::eName, instance, name)
 
 // The same as MOZ_EVENT_TRACER_NAME_OBJECT, just simplifies building
 // names when it consists of two parts
 #define MOZ_EVENT_TRACER_COMPOUND_NAME(instance, name, name2) \
   mozilla::eventtracer::Mark(mozilla::eventtracer::eName, instance, name, name2)
 
 
-// Call the followings with the same |instance| reference as you have 
+// Call the followings with the same |instance| reference as you have
 // previously called MOZ_EVENT_TRACER_NAME_OBJECT.
-// Let |name| be the name of the event happening, like "resolving", 
+// Let |name| be the name of the event happening, like "resolving",
 // "connecting", "loading" etc.
 
-// This will crate a single-point-in-time event marked with an arrow 
+// This will crate a single-point-in-time event marked with an arrow
 // on the timeline, this is a way to indicate an event without a duration.
 #define MOZ_EVENT_TRACER_MARK(instance, name) \
   mozilla::eventtracer::Mark(mozilla::eventtracer::eShot, instance, name)
 
 // Following macros are used to log events with duration.
-// There always has to be complete WAIT,EXEC,DONE or EXEC,DONE 
-// uninterrupted and non-interferring tuple(s) for an event to be correctly 
+// There always has to be complete WAIT,EXEC,DONE or EXEC,DONE
+// uninterrupted and non-interferring tuple(s) for an event to be correctly
 // shown on the timeline.  Each can be called on any thread, the event tape is
 // finally displayed on the thread where it has been EXECuted.
 
 // Example of 3 phases usage for "HTTP request channel":
 // WAIT: we've just created the channel and called AsyncOpen on it
 // EXEC: we've just got first call to OnDataAvailable, so we are actually
 //       receiving the content after some time like connection establising,
 //       opening a cache entry, sending the GET request...
 // DONE: we've just got OnStopRequest call that indicates the content
 //       has been completely delivered and the request is now finished
 
-// Indicate an event pending start, on the timeline this will 
+// Indicate an event pending start, on the timeline this will
 // start the event's interval tape with a pale color, the time will
 // show in details.  Usually used when an event is being posted or
 // we wait for a lock acquisition.
 // WAITING is not mandatory, some events don't have a pending phase.
 #define MOZ_EVENT_TRACER_WAIT(instance, name) \
   mozilla::eventtracer::Mark(mozilla::eventtracer::eWait, instance, name)
 
-// Indicate start of an event actual execution, on the timeline this will 
+// Indicate start of an event actual execution, on the timeline this will
 // change the event's tape to a deeper color, the time will show in details.
 #define MOZ_EVENT_TRACER_EXEC(instance, name) \
   mozilla::eventtracer::Mark(mozilla::eventtracer::eExec, instance, name)
 
 // Indicate the end of an event execution (the event has been done),
 // on the timeline this will end the event's tape and show the time in
 // event details.
 // NOTE: when the event duration is extremely short, like 1ms, it will convert
 // to an event w/o a duration - the same as MOZ_EVENT_TRACER_MARK would be used.
 #define MOZ_EVENT_TRACER_DONE(instance, name) \
   mozilla::eventtracer::Mark(mozilla::eventtracer::eDone, instance, name)
 
 // The same meaning as the above macros, just for concurent events.
 // Concurent event means it can happen for the same instance on more
-// then just a single thread, e.g. a service method call, a global lock 
+// then just a single thread, e.g. a service method call, a global lock
 // acquisition, enter and release.
 #define MOZ_EVENT_TRACER_WAIT_THREADSAFE(instance, name) \
   mozilla::eventtracer::Mark(mozilla::eventtracer::eWait | mozilla::eventtracer::eThreadConcurrent, instance, name)
 #define MOZ_EVENT_TRACER_EXEC_THREADSAFE(instance, name) \
   mozilla::eventtracer::Mark(mozilla::eventtracer::eExec | mozilla::eventtracer::eThreadConcurrent, instance, name)
 #define MOZ_EVENT_TRACER_DONE_THREASAFE(instance, name) \
   mozilla::eventtracer::Mark(mozilla::eventtracer::eDone | mozilla::eventtracer::eThreadConcurrent, instance, name)
 
-#else 
+#else
 
 // MOZ_VISUAL_EVENT_TRACER disabled
 
 #define MOZ_EVENT_TRACER_NAME_OBJECT(instance, name) (void)0
 #define MOZ_EVENT_TRACER_COMPOUND_NAME(instance, name, name2) (void)0
 #define MOZ_EVENT_TRACER_MARK(instance, name) (void)0
 #define MOZ_EVENT_TRACER_WAIT(instance, name) (void)0
 #define MOZ_EVENT_TRACER_EXEC(instance, name) (void)0
@@ -121,17 +121,17 @@
 
 
 namespace mozilla {
 namespace eventtracer {
 
 // Initialize the event tracer engine, called automatically on XPCOM startup.
 void Init();
 
-// Shuts the event tracer engine down and closes the log file, called 
+// Shuts the event tracer engine down and closes the log file, called
 // automatically during XPCOM shutdown.
 void Shutdown();
 
 enum MarkType {
   eNone, // No operation, ignored
   eName, // This is used to bind an object instance with a name
 
   eShot, // An event with no duration
@@ -141,52 +141,52 @@ enum MarkType {
   eLast, // Sentinel
 
   // Flags
 
   // The same object can execute the same event on several threads concurently
   eThreadConcurrent = 0x10000
 };
 
-// Records an event on the calling thread. 
-// @param aType 
+// Records an event on the calling thread.
+// @param aType
 //    One of MarkType fields, can be bitwise or'ed with the flags.
 // @param aItem
 //    Reference to the object we want to bind a name to or the event is
 //    happening on.  Can be actually anything, but valid poitners should
 //    be used.
 // @param aText
 //    Text of the name (for eName) or event's name for others.  The string
 //    is duplicated.
 // @param aText2
 //    Optional second part of the instnace name, or event name.
 //    Event filtering does apply only to the first part (aText).
-void Mark(uint32_t aType, void * aItem, 
+void Mark(uint32_t aType, void * aItem,
           const char * aText, const char * aText2 = 0);
 
 
 // Helper guard object.  Use to mark an event in the constructor and a different
 // event in the destructor.
 //
 // Example:
 // int class::func()
 // {
 //    AutoEventTracer tracer(this, eventtracer::eExec, eventtracer::eDone, "func");
 //
 //    do_something_taking_a_long_time();
 // }
 class MOZ_STACK_CLASS AutoEventTracer
 {
 public:
-  AutoEventTracer(void * aInstance, 
-               uint32_t aTypeOn, // MarkType marked in constructor
-               uint32_t aTypeOff, // MarkType marked in destructor
-               const char * aName, 
-               const char * aName2 = 0 
-               MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+  AutoEventTracer(void * aInstance,
+                  uint32_t aTypeOn, // MarkType marked in constructor
+                  uint32_t aTypeOff, // MarkType marked in destructor
+                  const char * aName,
+                  const char * aName2 = 0
+                  MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
     : mInstance(aInstance)
     , mName(aName)
     , mName2(aName2)
     , mTypeOn(aTypeOn)
     , mTypeOff(aTypeOff)
   {
     MOZ_GUARD_OBJECT_NOTIFIER_INIT;
 
--- a/xpcom/base/nsAgg.h
+++ b/xpcom/base/nsAgg.h
@@ -1,31 +1,32 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 #ifndef nsAgg_h___
 #define nsAgg_h___
 
 #include "nsISupports.h"
 #include "nsCycleCollectionParticipant.h"
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Put NS_DECL_AGGREGATED or NS_DECL_CYCLE_COLLECTING_AGGREGATED in your class's
 // declaration.
 #define NS_DECL_AGGREGATED                                                  \
-    NS_DECL_ISUPPORTS                                                       \
-    NS_DECL_AGGREGATED_HELPER
+  NS_DECL_ISUPPORTS                                                         \
+  NS_DECL_AGGREGATED_HELPER
 
 #define NS_DECL_CYCLE_COLLECTING_AGGREGATED                                 \
-    NS_DECL_CYCLE_COLLECTING_ISUPPORTS                                      \
-    NS_DECL_AGGREGATED_HELPER
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS                                        \
+  NS_DECL_AGGREGATED_HELPER
 
 #define NS_DECL_AGGREGATED_HELPER                                           \
 public:                                                                     \
                                                                             \
     /**                                                                     \
      * Returns the nsISupports pointer of the inner object (aka the         \
      * aggregatee). This pointer is really only useful to the outer object  \
      * (aka the aggregator), which can use it to hold on to the inner       \
@@ -225,20 +226,20 @@ NS_IMETHODIMP                           
 }
 
 /**
  * Just holds the IID so NS_GET_IID works.
  */
 class nsAggregatedCycleCollectionParticipant
 {
 public:
-    NS_DECLARE_STATIC_IID_ACCESSOR(NS_AGGREGATED_CYCLECOLLECTIONPARTICIPANT_IID)
+  NS_DECLARE_STATIC_IID_ACCESSOR(NS_AGGREGATED_CYCLECOLLECTIONPARTICIPANT_IID)
 };
 
-NS_DEFINE_STATIC_IID_ACCESSOR(nsAggregatedCycleCollectionParticipant, 
+NS_DEFINE_STATIC_IID_ACCESSOR(nsAggregatedCycleCollectionParticipant,
                               NS_AGGREGATED_CYCLECOLLECTIONPARTICIPANT_IID)
 
 // for use with QI macros in nsISupportsUtils.h:
 
 #define NS_INTERFACE_MAP_BEGIN_AGGREGATED(_class)                           \
   NS_IMPL_AGGREGATED_QUERY_HEAD(_class)
 
 #define NS_INTERFACE_MAP_ENTRY_CYCLE_COLLECTION_AGGREGATED(_class)          \
--- a/xpcom/base/nsAutoPtr.h
+++ b/xpcom/base/nsAutoPtr.h
@@ -1,9 +1,10 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 #ifndef nsAutoPtr_h___
 #define nsAutoPtr_h___
 
 #include "nsCOMPtr.h"
@@ -12,1121 +13,1121 @@
 #include "mozilla/MemoryReporting.h"
 
 /*****************************************************************************/
 
 // template <class T> class nsAutoPtrGetterTransfers;
 
 template <class T>
 class nsAutoPtr
+{
+private:
+  void**
+  begin_assignment()
   {
-    private:
-      void**
-      begin_assignment()
-        {
-          assign(0);
-          return reinterpret_cast<void**>(&mRawPtr);
-        }
+    assign(0);
+    return reinterpret_cast<void**>(&mRawPtr);
+  }
 
-      void
-      assign( T* newPtr )
-        {
-          T* oldPtr = mRawPtr;
+  void
+  assign( T* newPtr )
+  {
+    T* oldPtr = mRawPtr;
 
-          if (newPtr != nullptr && newPtr == oldPtr) {
-            NS_RUNTIMEABORT("Logic flaw in the caller");
-          }
+    if (newPtr != nullptr && newPtr == oldPtr) {
+      NS_RUNTIMEABORT("Logic flaw in the caller");
+    }
 
-          mRawPtr = newPtr;
-          delete oldPtr;
-        }
+    mRawPtr = newPtr;
+    delete oldPtr;
+  }
 
-      // |class Ptr| helps us prevent implicit "copy construction"
-      // through |operator T*() const| from a |const nsAutoPtr<T>|
-      // because two implicit conversions in a row aren't allowed.
-      // It still allows assignment from T* through implicit conversion
-      // from |T*| to |nsAutoPtr<T>::Ptr|
-      class Ptr
-        {
-          public:
-            Ptr( T* aPtr )
-                  : mPtr(aPtr)
-              {
-              }
+  // |class Ptr| helps us prevent implicit "copy construction"
+  // through |operator T*() const| from a |const nsAutoPtr<T>|
+  // because two implicit conversions in a row aren't allowed.
+  // It still allows assignment from T* through implicit conversion
+  // from |T*| to |nsAutoPtr<T>::Ptr|
+  class Ptr
+  {
+  public:
+    Ptr( T* aPtr )
+      : mPtr(aPtr)
+    {
+    }
 
-            operator T*() const
-              {
-                return mPtr;
-              }
+    operator T*() const
+    {
+      return mPtr;
+    }
 
-          private:
-            T* mPtr;
-        };
+  private:
+    T* mPtr;
+  };
 
-    private:
-      T* mRawPtr;
+private:
+  T* mRawPtr;
 
-    public:
-      typedef T element_type;
-      
-     ~nsAutoPtr()
-        {
-          delete mRawPtr;
-        }
+public:
+  typedef T element_type;
+
+  ~nsAutoPtr()
+  {
+    delete mRawPtr;
+  }
 
-        // Constructors
+  // Constructors
 
-      nsAutoPtr()
-            : mRawPtr(0)
-          // default constructor
-        {
-        }
+  nsAutoPtr()
+    : mRawPtr(0)
+    // default constructor
+  {
+  }
 
-      nsAutoPtr( Ptr aRawPtr )
-            : mRawPtr(aRawPtr)
-          // construct from a raw pointer (of the right type)
-        {
-        }
+  nsAutoPtr( Ptr aRawPtr )
+    : mRawPtr(aRawPtr)
+    // construct from a raw pointer (of the right type)
+  {
+  }
 
-      // This constructor shouldn't exist; we should just use the &&
-      // constructor.
-      nsAutoPtr( nsAutoPtr<T>& aSmartPtr )
-            : mRawPtr( aSmartPtr.forget() )
-          // Construct by transferring ownership from another smart pointer.
-        {
-        }
+  // This constructor shouldn't exist; we should just use the &&
+  // constructor.
+  nsAutoPtr( nsAutoPtr<T>& aSmartPtr )
+    : mRawPtr( aSmartPtr.forget() )
+    // Construct by transferring ownership from another smart pointer.
+  {
+  }
 
-      nsAutoPtr( nsAutoPtr<T>&& aSmartPtr )
-            : mRawPtr( aSmartPtr.forget() )
-          // Construct by transferring ownership from another smart pointer.
-        {
-        }
+  nsAutoPtr( nsAutoPtr<T>&& aSmartPtr )
+    : mRawPtr( aSmartPtr.forget() )
+    // Construct by transferring ownership from another smart pointer.
+  {
+  }
 
-        // Assignment operators
+  // Assignment operators
 
-      nsAutoPtr<T>&
-      operator=( T* rhs )
-          // assign from a raw pointer (of the right type)
-        {
-          assign(rhs);
-          return *this;
-        }
+  nsAutoPtr<T>&
+  operator=( T* rhs )
+  // assign from a raw pointer (of the right type)
+  {
+    assign(rhs);
+    return *this;
+  }
 
-      nsAutoPtr<T>& operator=( nsAutoPtr<T>& rhs )
-          // assign by transferring ownership from another smart pointer.
-        {
-          assign(rhs.forget());
-          return *this;
-        }
+  nsAutoPtr<T>& operator=( nsAutoPtr<T>& rhs )
+  // assign by transferring ownership from another smart pointer.
+  {
+    assign(rhs.forget());
+    return *this;
+  }
 
-        // Other pointer operators
+  // Other pointer operators
 
-      T*
-      get() const
-          /*
-            Prefer the implicit conversion provided automatically by
-            |operator T*() const|.  Use |get()| _only_ to resolve
-            ambiguity.
-          */
-        {
-          return mRawPtr;
-        }
+  T*
+  get() const
+  /*
+    Prefer the implicit conversion provided automatically by
+    |operator T*() const|.  Use |get()| _only_ to resolve
+    ambiguity.
+  */
+  {
+    return mRawPtr;
+  }
 
-      operator T*() const
-          /*
-            ...makes an |nsAutoPtr| act like its underlying raw pointer
-            type  whenever it is used in a context where a raw pointer
-            is expected.  It is this operator that makes an |nsAutoPtr|
-            substitutable for a raw pointer.
+  operator T*() const
+  /*
+    ...makes an |nsAutoPtr| act like its underlying raw pointer
+    type  whenever it is used in a context where a raw pointer
+    is expected.  It is this operator that makes an |nsAutoPtr|
+    substitutable for a raw pointer.
 
-            Prefer the implicit use of this operator to calling |get()|,
-            except where necessary to resolve ambiguity.
-          */
-        {
-          return get();
-        }
+    Prefer the implicit use of this operator to calling |get()|,
+    except where necessary to resolve ambiguity.
+  */
+  {
+    return get();
+  }
 
-      T*
-      forget()
-        {
-          T* temp = mRawPtr;
-          mRawPtr = 0;
-          return temp;
-        }
+  T*
+  forget()
+  {
+    T* temp = mRawPtr;
+    mRawPtr = 0;
+    return temp;
+  }
 
-      T*
-      operator->() const
-        {
-          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoPtr with operator->().");
-          return get();
-        }
+  T*
+  operator->() const
+  {
+    NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoPtr with operator->().");
+    return get();
+  }
 
-      // This operator is needed for gcc <= 4.0.* and for Sun Studio; it
-      // causes internal compiler errors for some MSVC versions.  (It's not
-      // clear to me whether it should be needed.)
+  // This operator is needed for gcc <= 4.0.* and for Sun Studio; it
+  // causes internal compiler errors for some MSVC versions.  (It's not
+  // clear to me whether it should be needed.)
 #ifndef _MSC_VER
-      template <class U, class V>
-      U&
-      operator->*(U V::* aMember)
-        {
-          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoPtr with operator->*().");
-          return get()->*aMember;
-        }
+  template <class U, class V>
+  U&
+  operator->*(U V::* aMember)
+  {
+    NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoPtr with operator->*().");
+    return get()->*aMember;
+  }
 #endif
 
-      nsAutoPtr<T>*
-      get_address()
-          // This is not intended to be used by clients.  See |address_of|
-          // below.
-        {
-          return this;
-        }
+  nsAutoPtr<T>*
+  get_address()
+  // This is not intended to be used by clients.  See |address_of|
+  // below.
+  {
+    return this;
+  }
 
-      const nsAutoPtr<T>*
-      get_address() const
-          // This is not intended to be used by clients.  See |address_of|
-          // below.
-        {
-          return this;
-        }
+  const nsAutoPtr<T>*
+  get_address() const
+  // This is not intended to be used by clients.  See |address_of|
+  // below.
+  {
+    return this;
+  }
 
-    public:
-      T&
-      operator*() const
-        {
-          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoPtr with operator*().");
-          return *get();
-        }
+public:
+  T&
+  operator*() const
+  {
+    NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoPtr with operator*().");
+    return *get();
+  }
 
-      T**
-      StartAssignment()
-        {
+  T**
+  StartAssignment()
+  {
 #ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
-          return reinterpret_cast<T**>(begin_assignment());
+    return reinterpret_cast<T**>(begin_assignment());
 #else
-          assign(0);
-          return reinterpret_cast<T**>(&mRawPtr);
+    assign(0);
+    return reinterpret_cast<T**>(&mRawPtr);
 #endif
-        }
-  };
+  }
+};
 
 template <class T>
 inline
 nsAutoPtr<T>*
 address_of( nsAutoPtr<T>& aPtr )
-  {
-    return aPtr.get_address();
-  }
+{
+  return aPtr.get_address();
+}
 
 template <class T>
 inline
 const nsAutoPtr<T>*
 address_of( const nsAutoPtr<T>& aPtr )
-  {
-    return aPtr.get_address();
-  }
+{
+  return aPtr.get_address();
+}
 
 template <class T>
 class nsAutoPtrGetterTransfers
-    /*
-      ...
+/*
+  ...
 
-      This class is designed to be used for anonymous temporary objects in the
-      argument list of calls that return COM interface pointers, e.g.,
+  This class is designed to be used for anonymous temporary objects in the
+  argument list of calls that return COM interface pointers, e.g.,
 
-        nsAutoPtr<IFoo> fooP;
-        ...->GetTransferedPointer(getter_Transfers(fooP))
+    nsAutoPtr<IFoo> fooP;
+    ...->GetTransferedPointer(getter_Transfers(fooP))
+
+  DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_Transfers()| instead.
 
-      DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_Transfers()| instead.
+  When initialized with a |nsAutoPtr|, as in the example above, it returns
+  a |void**|, a |T**|, or an |nsISupports**| as needed, that the
+  outer call (|GetTransferedPointer| in this case) can fill in.
 
-      When initialized with a |nsAutoPtr|, as in the example above, it returns
-      a |void**|, a |T**|, or an |nsISupports**| as needed, that the
-      outer call (|GetTransferedPointer| in this case) can fill in.
-
-      This type should be a nested class inside |nsAutoPtr<T>|.
-    */
+  This type should be a nested class inside |nsAutoPtr<T>|.
+*/
+{
+public:
+  explicit
+  nsAutoPtrGetterTransfers( nsAutoPtr<T>& aSmartPtr )
+    : mTargetSmartPtr(aSmartPtr)
   {
-    public:
-      explicit
-      nsAutoPtrGetterTransfers( nsAutoPtr<T>& aSmartPtr )
-          : mTargetSmartPtr(aSmartPtr)
-        {
-          // nothing else to do
-        }
+    // nothing else to do
+  }
 
-      operator void**()
-        {
-          return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
-        }
+  operator void**()
+  {
+    return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+  }
 
-      operator T**()
-        {
-          return mTargetSmartPtr.StartAssignment();
-        }
+  operator T**()
+  {
+    return mTargetSmartPtr.StartAssignment();
+  }
 
-      T*&
-      operator*()
-        {
-          return *(mTargetSmartPtr.StartAssignment());
-        }
+  T*&
+  operator*()
+  {
+    return *(mTargetSmartPtr.StartAssignment());
+  }
 
-    private:
-      nsAutoPtr<T>& mTargetSmartPtr;
-  };
+private:
+  nsAutoPtr<T>& mTargetSmartPtr;
+};
 
 template <class T>
 inline
 nsAutoPtrGetterTransfers<T>
 getter_Transfers( nsAutoPtr<T>& aSmartPtr )
-    /*
-      Used around a |nsAutoPtr| when 
-      ...makes the class |nsAutoPtrGetterTransfers<T>| invisible.
-    */
-  {
-    return nsAutoPtrGetterTransfers<T>(aSmartPtr);
-  }
+/*
+  Used around a |nsAutoPtr| when
+  ...makes the class |nsAutoPtrGetterTransfers<T>| invisible.
+*/
+{
+  return nsAutoPtrGetterTransfers<T>(aSmartPtr);
+}
 
 
 
-  // Comparing two |nsAutoPtr|s
+// Comparing two |nsAutoPtr|s
 
 template <class T, class U>
 inline
 bool
 operator==( const nsAutoPtr<T>& lhs, const nsAutoPtr<U>& rhs )
-  {
-    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
-  }
+{
+  return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
+}
 
 
 template <class T, class U>
 inline
 bool
 operator!=( const nsAutoPtr<T>& lhs, const nsAutoPtr<U>& rhs )
-  {
-    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
-  }
+{
+  return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
+}
 
 
-  // Comparing an |nsAutoPtr| to a raw pointer
+// Comparing an |nsAutoPtr| to a raw pointer
 
 template <class T, class U>
 inline
 bool
 operator==( const nsAutoPtr<T>& lhs, const U* rhs )
-  {
-    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
-  }
+{
+  return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
+}
 
 template <class T, class U>
 inline
 bool
 operator==( const U* lhs, const nsAutoPtr<T>& rhs )
-  {
-    return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
-  }
+{
+  return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+}
 
 template <class T, class U>
 inline
 bool
 operator!=( const nsAutoPtr<T>& lhs, const U* rhs )
-  {
-    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
-  }
+{
+  return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
+}
 
 template <class T, class U>
 inline
 bool
 operator!=( const U* lhs, const nsAutoPtr<T>& rhs )
-  {
-    return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
-  }
+{
+  return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+}
 
-  // To avoid ambiguities caused by the presence of builtin |operator==|s
-  // creating a situation where one of the |operator==| defined above
-  // has a better conversion for one argument and the builtin has a
-  // better conversion for the other argument, define additional
-  // |operator==| without the |const| on the raw pointer.
-  // See bug 65664 for details.
+// To avoid ambiguities caused by the presence of builtin |operator==|s
+// creating a situation where one of the |operator==| defined above
+// has a better conversion for one argument and the builtin has a
+// better conversion for the other argument, define additional
+// |operator==| without the |const| on the raw pointer.
+// See bug 65664 for details.
 
 #ifndef NSCAP_DONT_PROVIDE_NONCONST_OPEQ
 template <class T, class U>
 inline
 bool
 operator==( const nsAutoPtr<T>& lhs, U* rhs )
-  {
-    return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
-  }
+{
+  return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
+}
 
 template <class T, class U>
 inline
 bool
 operator==( U* lhs, const nsAutoPtr<T>& rhs )
-  {
-    return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
-  }
+{
+  return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+}
 
 template <class T, class U>
 inline
 bool
 operator!=( const nsAutoPtr<T>& lhs, U* rhs )
-  {
-    return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
-  }
+{
+  return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
+}
 
 template <class T, class U>
 inline
 bool
 operator!=( U* lhs, const nsAutoPtr<T>& rhs )
-  {
-    return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
-  }
+{
+  return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+}
 #endif
 
 
 
-  // Comparing an |nsAutoPtr| to |0|
+// Comparing an |nsAutoPtr| to |0|
 
 template <class T>
 inline
 bool
 operator==( const nsAutoPtr<T>& lhs, NSCAP_Zero* rhs )
-    // specifically to allow |smartPtr == 0|
-  {
-    return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
-  }
+// specifically to allow |smartPtr == 0|
+{
+  return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+}
 
 template <class T>
 inline
 bool
 operator==( NSCAP_Zero* lhs, const nsAutoPtr<T>& rhs )
-    // specifically to allow |0 == smartPtr|
-  {
-    return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
-  }
+// specifically to allow |0 == smartPtr|
+{
+  return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+}
 
 template <class T>
 inline
 bool
 operator!=( const nsAutoPtr<T>& lhs, NSCAP_Zero* rhs )
-    // specifically to allow |smartPtr != 0|
-  {
-    return static_cast<const void*>(lhs.get()) != reinterpret_cast<const void*>(rhs);
-  }
+// specifically to allow |smartPtr != 0|
+{
+  return static_cast<const void*>(lhs.get()) != reinterpret_cast<const void*>(rhs);
+}
 
 template <class T>
 inline
 bool
 operator!=( NSCAP_Zero* lhs, const nsAutoPtr<T>& rhs )
-    // specifically to allow |0 != smartPtr|
-  {
-    return reinterpret_cast<const void*>(lhs) != static_cast<const void*>(rhs.get());
-  }
+// specifically to allow |0 != smartPtr|
+{
+  return reinterpret_cast<const void*>(lhs) != static_cast<const void*>(rhs.get());
+}
 
 
 #ifdef HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
 
-  // We need to explicitly define comparison operators for `int'
-  // because the compiler is lame.
+// We need to explicitly define comparison operators for `int'
+// because the compiler is lame.
 
 template <class T>
 inline
 bool
 operator==( const nsAutoPtr<T>& lhs, int rhs )
-    // specifically to allow |smartPtr == 0|
-  {
-    return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
-  }
+// specifically to allow |smartPtr == 0|
+{
+  return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+}
 
 template <class T>
 inline
 bool
 operator==( int lhs, const nsAutoPtr<T>& rhs )
-    // specifically to allow |0 == smartPtr|
-  {
-    return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
-  }
+// specifically to allow |0 == smartPtr|
+{
+  return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+}
 
 #endif // !defined(HAVE_CPP_TROUBLE_COMPARING_TO_ZERO)
 
 /*****************************************************************************/
 
 // template <class T> class nsAutoArrayPtrGetterTransfers;
 
 template <class T>
 class nsAutoArrayPtr
+{
+private:
+  void**
+  begin_assignment()
   {
-    private:
-      void**
-      begin_assignment()
-        {
-          assign(0);
-          return reinterpret_cast<void**>(&mRawPtr);
-        }
+    assign(0);
+    return reinterpret_cast<void**>(&mRawPtr);
+  }
 
-      void
-      assign( T* newPtr )
-        {
-          T* oldPtr = mRawPtr;
-          mRawPtr = newPtr;
-          delete [] oldPtr;
-        }
+  void
+  assign( T* newPtr )
+  {
+    T* oldPtr = mRawPtr;
+    mRawPtr = newPtr;
+    delete [] oldPtr;
+  }
 
-    private:
-      T* mRawPtr;
+private:
+  T* mRawPtr;
+
+public:
+  typedef T element_type;
 
-    public:
-      typedef T element_type;
-      
-     ~nsAutoArrayPtr()
-        {
-          delete [] mRawPtr;
-        }
+  ~nsAutoArrayPtr()
+  {
+    delete [] mRawPtr;
+  }
 
-        // Constructors
+  // Constructors
 
-      nsAutoArrayPtr()
-            : mRawPtr(0)
-          // default constructor
-        {
-        }
+  nsAutoArrayPtr()
+    : mRawPtr(0)
+    // default constructor
+  {
+  }
 
-      nsAutoArrayPtr( T* aRawPtr )
-            : mRawPtr(aRawPtr)
-          // construct from a raw pointer (of the right type)
-        {
-        }
+  nsAutoArrayPtr( T* aRawPtr )
+    : mRawPtr(aRawPtr)
+    // construct from a raw pointer (of the right type)
+  {
+  }
 
-      nsAutoArrayPtr( nsAutoArrayPtr<T>& aSmartPtr )
-            : mRawPtr( aSmartPtr.forget() )
-          // Construct by transferring ownership from another smart pointer.
-        {
-        }
+  nsAutoArrayPtr( nsAutoArrayPtr<T>& aSmartPtr )
+    : mRawPtr( aSmartPtr.forget() )
+    // Construct by transferring ownership from another smart pointer.
+  {
+  }
 
 
-        // Assignment operators
+  // Assignment operators
 
-      nsAutoArrayPtr<T>&
-      operator=( T* rhs )
-          // assign from a raw pointer (of the right type)
-        {
-          assign(rhs);
-          return *this;
-        }
+  nsAutoArrayPtr<T>&
+  operator=( T* rhs )
+  // assign from a raw pointer (of the right type)
+  {
+    assign(rhs);
+    return *this;
+  }
 
-      nsAutoArrayPtr<T>& operator=( nsAutoArrayPtr<T>& rhs )
-          // assign by transferring ownership from another smart pointer.
-        {
-          assign(rhs.forget());
-          return *this;
-        }
+  nsAutoArrayPtr<T>& operator=( nsAutoArrayPtr<T>& rhs )
+  // assign by transferring ownership from another smart pointer.
+  {
+    assign(rhs.forget());
+    return *this;
+  }
 
-        // Other pointer operators
+  // Other pointer operators
 
-      T*
-      get() const
-          /*
-            Prefer the implicit conversion provided automatically by
-            |operator T*() const|.  Use |get()| _only_ to resolve
-            ambiguity.
-          */
-        {
-          return mRawPtr;
-        }
+  T*
+  get() const
+  /*
+    Prefer the implicit conversion provided automatically by
+    |operator T*() const|.  Use |get()| _only_ to resolve
+    ambiguity.
+  */
+  {
+    return mRawPtr;
+  }
 
-      operator T*() const
-          /*
-            ...makes an |nsAutoArrayPtr| act like its underlying raw pointer
-            type  whenever it is used in a context where a raw pointer
-            is expected.  It is this operator that makes an |nsAutoArrayPtr|
-            substitutable for a raw pointer.
+  operator T*() const
+  /*
+    ...makes an |nsAutoArrayPtr| act like its underlying raw pointer
+    type  whenever it is used in a context where a raw pointer
+    is expected.  It is this operator that makes an |nsAutoArrayPtr|
+    substitutable for a raw pointer.
 
-            Prefer the implicit use of this operator to calling |get()|,
-            except where necessary to resolve ambiguity.
-          */
-        {
-          return get();
-        }
+    Prefer the implicit use of this operator to calling |get()|,
+    except where necessary to resolve ambiguity.
+  */
+  {
+    return get();
+  }
 
-      T*
-      forget()
-        {
-          T* temp = mRawPtr;
-          mRawPtr = 0;
-          return temp;
-        }
+  T*
+  forget()
+  {
+    T* temp = mRawPtr;
+    mRawPtr = 0;
+    return temp;
+  }
 
-      T*
-      operator->() const
-        {
-          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoArrayPtr with operator->().");
-          return get();
-        }
+  T*
+  operator->() const
+  {
+    NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoArrayPtr with operator->().");
+    return get();
+  }
 
-      nsAutoArrayPtr<T>*
-      get_address()
-          // This is not intended to be used by clients.  See |address_of|
-          // below.
-        {
-          return this;
-        }
+  nsAutoArrayPtr<T>*
+  get_address()
+  // This is not intended to be used by clients.  See |address_of|
+  // below.
+  {
+    return this;
+  }
 
-      const nsAutoArrayPtr<T>*
-      get_address() const
-          // This is not intended to be used by clients.  See |address_of|
-          // below.
-        {
-          return this;
-        }
+  const nsAutoArrayPtr<T>*
+  get_address() const
+  // This is not intended to be used by clients.  See |address_of|
+  // below.
+  {
+    return this;
+  }
 
-    public:
-      T&
-      operator*() const
-        {
-          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoArrayPtr with operator*().");
-          return *get();
-        }
+public:
+  T&
+  operator*() const
+  {
+    NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoArrayPtr with operator*().");
+    return *get();
+  }
 
-      T**
-      StartAssignment()
-        {
+  T**
+  StartAssignment()
+  {
 #ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
-          return reinterpret_cast<T**>(begin_assignment());
+    return reinterpret_cast<T**>(begin_assignment());
 #else
-          assign(0);
-          return reinterpret_cast<T**>(&mRawPtr);
+    assign(0);
+    return reinterpret_cast<T**>(&mRawPtr);
 #endif
-        }
+  }
 
-      size_t
-      SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-        {
-          return aMallocSizeOf(mRawPtr);
-        }
+  size_t
+  SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return aMallocSizeOf(mRawPtr);
+  }
 
-      size_t
-      SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
-        {
-          return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
-        }
-  };
+  size_t
+  SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+  {
+    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+  }
+};
 
 template <class T>
 inline
 nsAutoArrayPtr<T>*
 address_of( nsAutoArrayPtr<T>& aPtr )
-  {
-    return aPtr.get_address();
-  }
+{
+  return aPtr.get_address();
+}
 
 template <class T>
 inline
 const nsAutoArrayPtr<T>*
 address_of( const nsAutoArrayPtr<T>& aPtr )
-  {
-    return aPtr.get_address();
-  }
+{
+  return aPtr.get_address();
+}
 
 template <class T>
 class nsAutoArrayPtrGetterTransfers
-    /*
-      ...
+/*
+  ...
 
-      This class is designed to be used for anonymous temporary objects in the
-      argument list of calls that return COM interface pointers, e.g.,
+  This class is designed to be used for anonymous temporary objects in the
+  argument list of calls that return COM interface pointers, e.g.,
 
-        nsAutoArrayPtr<IFoo> fooP;
-        ...->GetTransferedPointer(getter_Transfers(fooP))
+    nsAutoArrayPtr<IFoo> fooP;
+    ...->GetTransferedPointer(getter_Transfers(fooP))
+
+  DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_Transfers()| instead.
 
-      DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_Transfers()| instead.
+  When initialized with a |nsAutoArrayPtr|, as in the example above, it returns
+  a |void**|, a |T**|, or an |nsISupports**| as needed, that the
+  outer call (|GetTransferedPointer| in this case) can fill in.
 
-      When initialized with a |nsAutoArrayPtr|, as in the example above, it returns
-      a |void**|, a |T**|, or an |nsISupports**| as needed, that the
-      outer call (|GetTransferedPointer| in this case) can fill in.
-
-      This type should be a nested class inside |nsAutoArrayPtr<T>|.
-    */
+  This type should be a nested class inside |nsAutoArrayPtr<T>|.
+*/
+{
+public:
+  explicit
+  nsAutoArrayPtrGetterTransfers( nsAutoArrayPtr<T>& aSmartPtr )
+    : mTargetSmartPtr(aSmartPtr)
   {
-    public:
-      explicit
-      nsAutoArrayPtrGetterTransfers( nsAutoArrayPtr<T>& aSmartPtr )
-          : mTargetSmartPtr(aSmartPtr)
-        {
-          // nothing else to do
-        }
+    // nothing else to do
+  }
 
-      operator void**()
-        {
-          return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
-        }
+  operator void**()
+  {
+    return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+  }
 
-      operator T**()
-        {
-          return mTargetSmartPtr.StartAssignment();
-        }
+  operator T**()
+  {
+    return mTargetSmartPtr.StartAssignment();
+  }
 
-      T*&
-      operator*()
-        {
-          return *(mTargetSmartPtr.StartAssignment());
-        }
+  T*&
+  operator*()
+  {
+    return *(mTargetSmartPtr.StartAssignment());
+  }
 
-    private:
-      nsAutoArrayPtr<T>& mTargetSmartPtr;
-  };
+private:
+  nsAutoArrayPtr<T>& mTargetSmartPtr;
+};
 
 template <class T>
 inline
 nsAutoArrayPtrGetterTransfers<T>
 getter_Transfers( nsAutoArrayPtr<T>& aSmartPtr )
-    /*
-      Used around a |nsAutoArrayPtr| when 
-      ...makes the class |nsAutoArrayPtrGetterTransfers<T>| invisible.
-    */
-  {
-    return nsAutoArrayPtrGetterTransfers<T>(aSmartPtr);
-  }
+/*
+  Used around a |nsAutoArrayPtr| when
+  ...makes the class |nsAutoArrayPtrGetterTransfers<T>| invisible.
+*/
+{
+  return nsAutoArrayPtrGetterTransfers<T>(aSmartPtr);
+}
 
 
 
-  // Comparing two |nsAutoArrayPtr|s
+// Comparing two |nsAutoArrayPtr|s
 
 template <class T, class U>
 inline
 bool
 operator==( const nsAutoArrayPtr<T>& lhs, const nsAutoArrayPtr<U>& rhs )
-  {
-    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
-  }
+{
+  return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
+}
 
 
 template <class T, class U>
 inline
 bool
 operator!=( const nsAutoArrayPtr<T>& lhs, const nsAutoArrayPtr<U>& rhs )
-  {
-    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
-  }
+{
+  return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
+}
 
 
-  // Comparing an |nsAutoArrayPtr| to a raw pointer
+// Comparing an |nsAutoArrayPtr| to a raw pointer
 
 template <class T, class U>
 inline
 bool
 operator==( const nsAutoArrayPtr<T>& lhs, const U* rhs )
-  {
-    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
-  }
+{
+  return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
+}
 
 template <class T, class U>
 inline
 bool
 operator==( const U* lhs, const nsAutoArrayPtr<T>& rhs )
-  {
-    return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
-  }
+{
+  return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+}
 
 template <class T, class U>
 inline
 bool
 operator!=( const nsAutoArrayPtr<T>& lhs, const U* rhs )
-  {
-    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
-  }
+{
+  return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
+}
 
 template <class T, class U>
 inline
 bool
 operator!=( const U* lhs, const nsAutoArrayPtr<T>& rhs )
-  {
-    return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
-  }
+{
+  return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+}
 
-  // To avoid ambiguities caused by the presence of builtin |operator==|s
-  // creating a situation where one of the |operator==| defined above
-  // has a better conversion for one argument and the builtin has a
-  // better conversion for the other argument, define additional
-  // |operator==| without the |const| on the raw pointer.
-  // See bug 65664 for details.
+// To avoid ambiguities caused by the presence of builtin |operator==|s
+// creating a situation where one of the |operator==| defined above
+// has a better conversion for one argument and the builtin has a
+// better conversion for the other argument, define additional
+// |operator==| without the |const| on the raw pointer.
+// See bug 65664 for details.
 
 #ifndef NSCAP_DONT_PROVIDE_NONCONST_OPEQ
 template <class T, class U>
 inline
 bool
 operator==( const nsAutoArrayPtr<T>& lhs, U* rhs )
-  {
-    return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
-  }
+{
+  return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
+}
 
 template <class T, class U>
 inline
 bool
 operator==( U* lhs, const nsAutoArrayPtr<T>& rhs )
-  {
-    return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
-  }
+{
+  return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+}
 
 template <class T, class U>
 inline
 bool
 operator!=( const nsAutoArrayPtr<T>& lhs, U* rhs )
-  {
-    return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
-  }
+{
+  return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
+}
 
 template <class T, class U>
 inline
 bool
 operator!=( U* lhs, const nsAutoArrayPtr<T>& rhs )
-  {
-    return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
-  }
+{
+  return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+}
 #endif
 
 
 
-  // Comparing an |nsAutoArrayPtr| to |0|
+// Comparing an |nsAutoArrayPtr| to |0|
 
 template <class T>
 inline
 bool
 operator==( const nsAutoArrayPtr<T>& lhs, NSCAP_Zero* rhs )
-    // specifically to allow |smartPtr == 0|
-  {
-    return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
-  }
+// specifically to allow |smartPtr == 0|
+{
+  return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+}
 
 template <class T>
 inline
 bool
 operator==( NSCAP_Zero* lhs, const nsAutoArrayPtr<T>& rhs )
-    // specifically to allow |0 == smartPtr|
-  {
-    return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
-  }
+// specifically to allow |0 == smartPtr|
+{
+  return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+}
 
 template <class T>
 inline
 bool
 operator!=( const nsAutoArrayPtr<T>& lhs, NSCAP_Zero* rhs )
-    // specifically to allow |smartPtr != 0|
-  {
-    return static_cast<const void*>(lhs.get()) != reinterpret_cast<const void*>(rhs);
-  }
+// specifically to allow |smartPtr != 0|
+{
+  return static_cast<const void*>(lhs.get()) != reinterpret_cast<const void*>(rhs);
+}
 
 template <class T>
 inline
 bool
 operator!=( NSCAP_Zero* lhs, const nsAutoArrayPtr<T>& rhs )
-    // specifically to allow |0 != smartPtr|
-  {
-    return reinterpret_cast<const void*>(lhs) != static_cast<const void*>(rhs.get());
-  }
+// specifically to allow |0 != smartPtr|
+{
+  return reinterpret_cast<const void*>(lhs) != static_cast<const void*>(rhs.get());
+}
 
 
 #ifdef HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
 
-  // We need to explicitly define comparison operators for `int'
-  // because the compiler is lame.
+// We need to explicitly define comparison operators for `int'
+// because the compiler is lame.
 
 template <class T>
 inline
 bool
 operator==( const nsAutoArrayPtr<T>& lhs, int rhs )
-    // specifically to allow |smartPtr == 0|
-  {
-    return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
-  }
+// specifically to allow |smartPtr == 0|
+{
+  return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+}
 
 template <class T>
 inline
 bool
 operator==( int lhs, const nsAutoArrayPtr<T>& rhs )
-    // specifically to allow |0 == smartPtr|
-  {
-    return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
-  }
+// specifically to allow |0 == smartPtr|
+{
+  return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+}
 
 #endif // !defined(HAVE_CPP_TROUBLE_COMPARING_TO_ZERO)
 
 
 /*****************************************************************************/
 
 // template <class T> class nsRefPtrGetterAddRefs;
 
 template <class T>
 class nsRefPtr
-  {
-    private:
+{
+private:
 
-      void
-      assign_with_AddRef( T* rawPtr )
-        {
-          if ( rawPtr )
-            rawPtr->AddRef();
-          assign_assuming_AddRef(rawPtr);
-        }
+  void
+  assign_with_AddRef( T* rawPtr )
+  {
+    if ( rawPtr )
+      rawPtr->AddRef();
+    assign_assuming_AddRef(rawPtr);
+  }
 
-      void**
-      begin_assignment()
-        {
-          assign_assuming_AddRef(0);
-          return reinterpret_cast<void**>(&mRawPtr);
-        }
+  void**
+  begin_assignment()
+  {
+    assign_assuming_AddRef(0);
+    return reinterpret_cast<void**>(&mRawPtr);
+  }
 
-      void
-      assign_assuming_AddRef( T* newPtr )
-        {
-          T* oldPtr = mRawPtr;
-          mRawPtr = newPtr;
-          if ( oldPtr )
-            oldPtr->Release();
-        }
+  void
+  assign_assuming_AddRef( T* newPtr )
+  {
+    T* oldPtr = mRawPtr;
+    mRawPtr = newPtr;
+    if ( oldPtr )
+      oldPtr->Release();
+  }
 
-    private:
-      T* mRawPtr;
+private:
+  T* mRawPtr;
+
+public:
+  typedef T element_type;
 
-    public:
-      typedef T element_type;
-      
-     ~nsRefPtr()
-        {
-          if ( mRawPtr )
-            mRawPtr->Release();
-        }
+  ~nsRefPtr()
+  {
+    if ( mRawPtr )
+      mRawPtr->Release();
+  }
 
-        // Constructors
+  // Constructors
 
-      nsRefPtr()
-            : mRawPtr(0)
-          // default constructor
-        {
-        }
+  nsRefPtr()
+    : mRawPtr(0)
+    // default constructor
+  {
+  }
 
-      nsRefPtr(const nsRefPtr<T>& aSmartPtr)
-            : mRawPtr(aSmartPtr.mRawPtr)
-          // copy-constructor
-        {
-          if ( mRawPtr )
-            mRawPtr->AddRef();
-        }
+  nsRefPtr(const nsRefPtr<T>& aSmartPtr)
+    : mRawPtr(aSmartPtr.mRawPtr)
+    // copy-constructor
+  {
+    if ( mRawPtr )
+      mRawPtr->AddRef();
+  }
 
-      nsRefPtr(nsRefPtr<T>&& aRefPtr)
-            : mRawPtr(aRefPtr.mRawPtr)
-        {
-          aRefPtr.mRawPtr = nullptr;
-        }
+  nsRefPtr(nsRefPtr<T>&& aRefPtr)
+    : mRawPtr(aRefPtr.mRawPtr)
+  {
+    aRefPtr.mRawPtr = nullptr;
+  }
 
-      // construct from a raw pointer (of the right type)
+  // construct from a raw pointer (of the right type)
 
-      nsRefPtr(T* aRawPtr)
-        : mRawPtr(aRawPtr)
-        {
-          if ( mRawPtr )
-            mRawPtr->AddRef();
-        }
+  nsRefPtr(T* aRawPtr)
+    : mRawPtr(aRawPtr)
+  {
+    if ( mRawPtr )
+      mRawPtr->AddRef();
+  }
 
-      template <typename I>
-      nsRefPtr( already_AddRefed<I>& aSmartPtr )
-            : mRawPtr(aSmartPtr.take())
-          // construct from |already_AddRefed|
-        {
-        }
+  template <typename I>
+  nsRefPtr( already_AddRefed<I>& aSmartPtr )
+    : mRawPtr(aSmartPtr.take())
+    // construct from |already_AddRefed|
+  {
+  }
 
-      template <typename I>
-      nsRefPtr( already_AddRefed<I>&& aSmartPtr )
-            : mRawPtr(aSmartPtr.take())
-          // construct from |otherRefPtr.forget()|
-        {
-        }
+  template <typename I>
+  nsRefPtr( already_AddRefed<I>&& aSmartPtr )
+    : mRawPtr(aSmartPtr.take())
+    // construct from |otherRefPtr.forget()|
+  {
+  }
 
-      nsRefPtr( const nsCOMPtr_helper& helper )
-        {
-          void* newRawPtr;
-          if (NS_FAILED(helper(NS_GET_TEMPLATE_IID(T), &newRawPtr)))
-            newRawPtr = 0;
-          mRawPtr = static_cast<T*>(newRawPtr);
-        }
+  nsRefPtr( const nsCOMPtr_helper& helper )
+  {
+    void* newRawPtr;
+    if (NS_FAILED(helper(NS_GET_TEMPLATE_IID(T), &newRawPtr)))
+      newRawPtr = 0;
+    mRawPtr = static_cast<T*>(newRawPtr);
+  }
 
-        // Assignment operators
+  // Assignment operators
 
-      nsRefPtr<T>&
-      operator=(const nsRefPtr<T>& rhs)
-          // copy assignment operator
-        {
-          assign_with_AddRef(rhs.mRawPtr);
-          return *this;
-        }
+  nsRefPtr<T>&
+  operator=(const nsRefPtr<T>& rhs)
+  // copy assignment operator
+  {
+    assign_with_AddRef(rhs.mRawPtr);
+    return *this;
+  }
 
-      nsRefPtr<T>&
-      operator=( T* rhs )
-          // assign from a raw pointer (of the right type)
-        {
-          assign_with_AddRef(rhs);
-          return *this;
-        }
+  nsRefPtr<T>&
+  operator=( T* rhs )
+  // assign from a raw pointer (of the right type)
+  {
+    assign_with_AddRef(rhs);
+    return *this;
+  }
 
-      template <typename I>
-      nsRefPtr<T>&
-      operator=( already_AddRefed<I>& rhs )
-          // assign from |already_AddRefed|
-        {
-          assign_assuming_AddRef(rhs.take());
-          return *this;
-        }
+  template <typename I>
+  nsRefPtr<T>&
+  operator=( already_AddRefed<I>& rhs )
+  // assign from |already_AddRefed|
+  {
+    assign_assuming_AddRef(rhs.take());
+    return *this;
+  }
 
-      template <typename I>
-      nsRefPtr<T>&
-      operator=( already_AddRefed<I>&& rhs )
-          // assign from |otherRefPtr.forget()|
-        {
-          assign_assuming_AddRef(rhs.take());
-          return *this;
-        }
+  template <typename I>
+  nsRefPtr<T>&
+  operator=( already_AddRefed<I>&& rhs )
+  // assign from |otherRefPtr.forget()|
+  {
+    assign_assuming_AddRef(rhs.take());
+    return *this;
+  }
 
-      nsRefPtr<T>&
-      operator=( const nsCOMPtr_helper& helper )
-        {
-          void* newRawPtr;
-          if (NS_FAILED(helper(NS_GET_TEMPLATE_IID(T), &newRawPtr)))
-            newRawPtr = 0;
-          assign_assuming_AddRef(static_cast<T*>(newRawPtr));
-          return *this;
-        }
+  nsRefPtr<T>&
+  operator=( const nsCOMPtr_helper& helper )
+  {
+    void* newRawPtr;
+    if (NS_FAILED(helper(NS_GET_TEMPLATE_IID(T), &newRawPtr)))
+      newRawPtr = 0;
+    assign_assuming_AddRef(static_cast<T*>(newRawPtr));
+    return *this;
+  }
 
-      nsRefPtr<T>&
-      operator=(nsRefPtr<T>&& aRefPtr)
-      {
-        assign_assuming_AddRef(aRefPtr.mRawPtr);
-        aRefPtr.mRawPtr = nullptr;
-        return *this;
-      }
+  nsRefPtr<T>&
+  operator=(nsRefPtr<T>&& aRefPtr)
+  {
+    assign_assuming_AddRef(aRefPtr.mRawPtr);
+    aRefPtr.mRawPtr = nullptr;
+    return *this;
+  }
 
-        // Other pointer operators
+  // Other pointer operators
 
-      void
-      swap( nsRefPtr<T>& rhs )
-          // ...exchange ownership with |rhs|; can save a pair of refcount operations
-        {
-          T* temp = rhs.mRawPtr;
-          rhs.mRawPtr = mRawPtr;
-          mRawPtr = temp;
-        }
+  void
+  swap( nsRefPtr<T>& rhs )
+  // ...exchange ownership with |rhs|; can save a pair of refcount operations
+  {
+    T* temp = rhs.mRawPtr;
+    rhs.mRawPtr = mRawPtr;
+    mRawPtr = temp;
+  }
 
-      void
-      swap( T*& rhs )
-          // ...exchange ownership with |rhs|; can save a pair of refcount operations
-        {
-          T* temp = rhs;
-          rhs = mRawPtr;
-          mRawPtr = temp;
-        }
+  void
+  swap( T*& rhs )
+  // ...exchange ownership with |rhs|; can save a pair of refcount operations
+  {
+    T* temp = rhs;
+    rhs = mRawPtr;
+    mRawPtr = temp;
+  }
 
-      already_AddRefed<T>
-      forget()
-          // return the value of mRawPtr and null out mRawPtr. Useful for
-          // already_AddRefed return values.
-        {
-          T* temp = 0;
-          swap(temp);
-          return already_AddRefed<T>(temp);
-        }
+  already_AddRefed<T>
+  forget()
+  // return the value of mRawPtr and null out mRawPtr. Useful for
+  // already_AddRefed return values.
+  {
+    T* temp = 0;
+    swap(temp);
+    return already_AddRefed<T>(temp);
+  }
 
-      template <typename I>
-      void
-      forget( I** rhs)
-          // Set the target of rhs to the value of mRawPtr and null out mRawPtr.
-          // Useful to avoid unnecessary AddRef/Release pairs with "out"
-          // parameters where rhs bay be a T** or an I** where I is a base class
-          // of T.
-        {
-          NS_ASSERTION(rhs, "Null pointer passed to forget!");
-          *rhs = mRawPtr;
-          mRawPtr = 0;
-        }
+  template <typename I>
+  void
+  forget( I** rhs)
+  // Set the target of rhs to the value of mRawPtr and null out mRawPtr.
+  // Useful to avoid unnecessary AddRef/Release pairs with "out"
+  // parameters where rhs bay be a T** or an I** where I is a base class
+  // of T.
+  {
+    NS_ASSERTION(rhs, "Null pointer passed to forget!");
+    *rhs = mRawPtr;
+    mRawPtr = 0;
+  }
 
-      T*
-      get() const
-          /*
-            Prefer the implicit conversion provided automatically by |operator T*() const|.
-            Use |get()| to resolve ambiguity or to get a castable pointer.
-          */
-        {
-          return const_cast<T*>(mRawPtr);
-        }
+  T*
+  get() const
+  /*
+    Prefer the implicit conversion provided automatically by |operator T*() const|.
+    Use |get()| to resolve ambiguity or to get a castable pointer.
+  */
+  {
+    return const_cast<T*>(mRawPtr);
+  }
 
-      operator T*() const
-          /*
-            ...makes an |nsRefPtr| act like its underlying raw pointer type whenever it
-            is used in a context where a raw pointer is expected.  It is this operator
-            that makes an |nsRefPtr| substitutable for a raw pointer.
+  operator T*() const
+  /*
+    ...makes an |nsRefPtr| act like its underlying raw pointer type whenever it
+    is used in a context where a raw pointer is expected.  It is this operator
+    that makes an |nsRefPtr| substitutable for a raw pointer.
 
-            Prefer the implicit use of this operator to calling |get()|, except where
-            necessary to resolve ambiguity.
-          */
-        {
-          return get();
-        }
+    Prefer the implicit use of this operator to calling |get()|, except where
+    necessary to resolve ambiguity.
+  */
+  {
+    return get();
+  }
 
-      T*
-      operator->() const
-        {
-          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsRefPtr with operator->().");
-          return get();
-        }
+  T*
+  operator->() const
+  {
+    NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsRefPtr with operator->().");
+    return get();
+  }
 
-      // This operator is needed for gcc <= 4.0.* and for Sun Studio; it
-      // causes internal compiler errors for some MSVC versions.  (It's not
-      // clear to me whether it should be needed.)
+  // This operator is needed for gcc <= 4.0.* and for Sun Studio; it
+  // causes internal compiler errors for some MSVC versions.  (It's not
+  // clear to me whether it should be needed.)
 #ifndef _MSC_VER
-      template <class U, class V>
-      U&
-      operator->*(U V::* aMember)
-        {
-          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsRefPtr with operator->*().");
-          return get()->*aMember;
-        }
+  template <class U, class V>
+  U&
+  operator->*(U V::* aMember)
+  {
+    NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsRefPtr with operator->*().");
+    return get()->*aMember;
+  }
 #endif
 
-      nsRefPtr<T>*
-      get_address()
-          // This is not intended to be used by clients.  See |address_of|
-          // below.
-        {
-          return this;
-        }
+  nsRefPtr<T>*
+  get_address()
+  // This is not intended to be used by clients.  See |address_of|
+  // below.
+  {
+    return this;
+  }
 
-      const nsRefPtr<T>*
-      get_address() const
-          // This is not intended to be used by clients.  See |address_of|
-          // below.
-        {
-          return this;
-        }
+  const nsRefPtr<T>*
+  get_address() const
+  // This is not intended to be used by clients.  See |address_of|
+  // below.
+  {
+    return this;
+  }
 
-    public:
-      T&
-      operator*() const
-        {
-          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsRefPtr with operator*().");
-          return *get();
-        }
+public:
+  T&
+  operator*() const
+  {
+    NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsRefPtr with operator*().");
+    return *get();
+  }
 
-      T**
-      StartAssignment()
-        {
+  T**
+  StartAssignment()
+  {
 #ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
-          return reinterpret_cast<T**>(begin_assignment());
+    return reinterpret_cast<T**>(begin_assignment());
 #else
-          assign_assuming_AddRef(0);
-          return reinterpret_cast<T**>(&mRawPtr);
+    assign_assuming_AddRef(0);
+    return reinterpret_cast<T**>(&mRawPtr);
 #endif
-        }
-  };
+  }
+};
 
 template <typename T>
 inline void
 ImplCycleCollectionUnlink(nsRefPtr<T>& aField)
 {
   aField = nullptr;
 }
 
@@ -1139,258 +1140,258 @@ ImplCycleCollectionTraverse(nsCycleColle
 {
   CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags);
 }
 
 template <class T>
 inline
 nsRefPtr<T>*
 address_of( nsRefPtr<T>& aPtr )
-  {
-    return aPtr.get_address();
-  }
+{
+  return aPtr.get_address();
+}
 
 template <class T>
 inline
 const nsRefPtr<T>*
 address_of( const nsRefPtr<T>& aPtr )
-  {
-    return aPtr.get_address();
-  }
+{
+  return aPtr.get_address();
+}
 
 template <class T>
 class nsRefPtrGetterAddRefs
-    /*
-      ...
+/*
+  ...
 
-      This class is designed to be used for anonymous temporary objects in the
-      argument list of calls that return COM interface pointers, e.g.,
+  This class is designed to be used for anonymous temporary objects in the
+  argument list of calls that return COM interface pointers, e.g.,
 
-        nsRefPtr<IFoo> fooP;
-        ...->GetAddRefedPointer(getter_AddRefs(fooP))
+    nsRefPtr<IFoo> fooP;
+    ...->GetAddRefedPointer(getter_AddRefs(fooP))
+
+  DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_AddRefs()| instead.
 
-      DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_AddRefs()| instead.
+  When initialized with a |nsRefPtr|, as in the example above, it returns
+  a |void**|, a |T**|, or an |nsISupports**| as needed, that the
+  outer call (|GetAddRefedPointer| in this case) can fill in.
 
-      When initialized with a |nsRefPtr|, as in the example above, it returns
-      a |void**|, a |T**|, or an |nsISupports**| as needed, that the
-      outer call (|GetAddRefedPointer| in this case) can fill in.
-
-      This type should be a nested class inside |nsRefPtr<T>|.
-    */
+  This type should be a nested class inside |nsRefPtr<T>|.
+*/
+{
+public:
+  explicit
+  nsRefPtrGetterAddRefs( nsRefPtr<T>& aSmartPtr )
+    : mTargetSmartPtr(aSmartPtr)
   {
-    public:
-      explicit
-      nsRefPtrGetterAddRefs( nsRefPtr<T>& aSmartPtr )
-          : mTargetSmartPtr(aSmartPtr)
-        {
-          // nothing else to do
-        }
+    // nothing else to do
+  }
 
-      operator void**()
-        {
-          return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
-        }
+  operator void**()
+  {
+    return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+  }
 
-      operator T**()
-        {
-          return mTargetSmartPtr.StartAssignment();
-        }
+  operator T**()
+  {
+    return mTargetSmartPtr.StartAssignment();
+  }
 
-      T*&
-      operator*()
-        {
-          return *(mTargetSmartPtr.StartAssignment());
-        }
+  T*&
+  operator*()
+  {
+    return *(mTargetSmartPtr.StartAssignment());
+  }
 
-    private:
-      nsRefPtr<T>& mTargetSmartPtr;
-  };
+private:
+  nsRefPtr<T>& mTargetSmartPtr;
+};
 
 template <class T>
 inline
 nsRefPtrGetterAddRefs<T>
 getter_AddRefs( nsRefPtr<T>& aSmartPtr )
-    /*
-      Used around a |nsRefPtr| when 
-      ...makes the class |nsRefPtrGetterAddRefs<T>| invisible.
-    */
-  {
-    return nsRefPtrGetterAddRefs<T>(aSmartPtr);
-  }
+/*
+  Used around a |nsRefPtr| when
+  ...makes the class |nsRefPtrGetterAddRefs<T>| invisible.
+*/
+{
+  return nsRefPtrGetterAddRefs<T>(aSmartPtr);
+}
 
 
 
-  // Comparing two |nsRefPtr|s
+// Comparing two |nsRefPtr|s
 
 template <class T, class U>
 inline
 bool
 operator==( const nsRefPtr<T>& lhs, const nsRefPtr<U>& rhs )
-  {
-    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
-  }
+{
+  return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
+}
 
 
 template <class T, class U>
 inline
 bool
 operator!=( const nsRefPtr<T>& lhs, const nsRefPtr<U>& rhs )
-  {
-    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
-  }
+{
+  return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
+}
 
 
-  // Comparing an |nsRefPtr| to a raw pointer
+// Comparing an |nsRefPtr| to a raw pointer
 
 template <class T, class U>
 inline
 bool
 operator==( const nsRefPtr<T>& lhs, const U* rhs )
-  {
-    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
-  }
+{
+  return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
+}
 
 template <class T, class U>
 inline
 bool
 operator==( const U* lhs, const nsRefPtr<T>& rhs )
-  {
-    return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
-  }
+{
+  return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+}
 
 template <class T, class U>
 inline
 bool
 operator!=( const nsRefPtr<T>& lhs, const U* rhs )
-  {
-    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
-  }
+{
+  return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
+}
 
 template <class T, class U>
 inline
 bool
 operator!=( const U* lhs, const nsRefPtr<T>& rhs )
-  {
-    return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
-  }
+{
+  return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+}
 
-  // To avoid ambiguities caused by the presence of builtin |operator==|s
-  // creating a situation where one of the |operator==| defined above
-  // has a better conversion for one argument and the builtin has a
-  // better conversion for the other argument, define additional
-  // |operator==| without the |const| on the raw pointer.
-  // See bug 65664 for details.
+// To avoid ambiguities caused by the presence of builtin |operator==|s
+// creating a situation where one of the |operator==| defined above
+// has a better conversion for one argument and the builtin has a
+// better conversion for the other argument, define additional
+// |operator==| without the |const| on the raw pointer.
+// See bug 65664 for details.
 
 #ifndef NSCAP_DONT_PROVIDE_NONCONST_OPEQ
 template <class T, class U>
 inline
 bool
 operator==( const nsRefPtr<T>& lhs, U* rhs )
-  {
-    return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
-  }
+{
+  return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
+}
 
 template <class T, class U>
 inline
 bool
 operator==( U* lhs, const nsRefPtr<T>& rhs )
-  {
-    return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
-  }
+{
+  return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+}
 
 template <class T, class U>
 inline
 bool
 operator!=( const nsRefPtr<T>& lhs, U* rhs )
-  {
-    return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
-  }
+{
+  return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
+}
 
 template <class T, class U>
 inline
 bool
 operator!=( U* lhs, const nsRefPtr<T>& rhs )
-  {
-    return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
-  }
+{
+  return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+}
 #endif
 
 
 
-  // Comparing an |nsRefPtr| to |0|
+// Comparing an |nsRefPtr| to |0|
 
 template <class T>
 inline
 bool
 operator==( const nsRefPtr<T>& lhs, NSCAP_Zero* rhs )
-    // specifically to allow |smartPtr == 0|
-  {
-    return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
-  }
+// specifically to allow |smartPtr == 0|
+{
+  return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+}
 
 template <class T>
 inline
 bool
 operator==( NSCAP_Zero* lhs, const nsRefPtr<T>& rhs )
-    // specifically to allow |0 == smartPtr|
-  {
-    return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
-  }
+// specifically to allow |0 == smartPtr|
+{
+  return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+}
 
 template <class T>
 inline
 bool
 operator!=( const nsRefPtr<T>& lhs, NSCAP_Zero* rhs )
-    // specifically to allow |smartPtr != 0|
-  {
-    return static_cast<const void*>(lhs.get()) != reinterpret_cast<const void*>(rhs);
-  }
+// specifically to allow |smartPtr != 0|
+{
+  return static_cast<const void*>(lhs.get()) != reinterpret_cast<const void*>(rhs);
+}
 
 template <class T>
 inline
 bool
 operator!=( NSCAP_Zero* lhs, const nsRefPtr<T>& rhs )
-    // specifically to allow |0 != smartPtr|
-  {
-    return reinterpret_cast<const void*>(lhs) != static_cast<const void*>(rhs.get());
-  }
+// specifically to allow |0 != smartPtr|
+{
+  return reinterpret_cast<const void*>(lhs) != static_cast<const void*>(rhs.get());
+}
 
 
 #ifdef HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
 
-  // We need to explicitly define comparison operators for `int'
-  // because the compiler is lame.
+// We need to explicitly define comparison operators for `int'
+// because the compiler is lame.
 
 template <class T>
 inline
 bool
 operator==( const nsRefPtr<T>& lhs, int rhs )
-    // specifically to allow |smartPtr == 0|
-  {
-    return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
-  }
+// specifically to allow |smartPtr == 0|
+{
+  return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+}
 
 template <class T>
 inline
 bool
 operator==( int lhs, const nsRefPtr<T>& rhs )
-    // specifically to allow |0 == smartPtr|
-  {
-    return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
-  }
+// specifically to allow |0 == smartPtr|
+{
+  return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+}
 
 #endif // !defined(HAVE_CPP_TROUBLE_COMPARING_TO_ZERO)
 
 template <class SourceType, class DestinationType>
 inline
 nsresult
 CallQueryInterface( nsRefPtr<SourceType>& aSourcePtr, DestinationType** aDestPtr )
-  {
-    return CallQueryInterface(aSourcePtr.get(), aDestPtr);
-  }
+{
+  return CallQueryInterface(aSourcePtr.get(), aDestPtr);
+}
 
 /*****************************************************************************/
 
 template<class T>
 class nsQueryObject : public nsCOMPtr_helper
 {
 public:
   nsQueryObject(T* aRawPtr)
--- a/xpcom/base/nsAutoRef.h
+++ b/xpcom/base/nsAutoRef.h
@@ -1,10 +1,10 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set shiftwidth=4 tabstop=8 autoindent cindent expandtab: */
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 #ifndef nsAutoRef_h_
 #define nsAutoRef_h_
 
 #include "mozilla/Attributes.h"
@@ -103,119 +103,119 @@ template <class T> class nsReturningRef;
  *
  */
 
 
 template <class T>
 class nsAutoRef : public nsAutoRefBase<T>
 {
 protected:
-    typedef nsAutoRef<T> ThisClass;
-    typedef nsAutoRefBase<T> BaseClass;
-    typedef nsSimpleRef<T> SimpleRef;
-    typedef typename BaseClass::RawRefOnly RawRefOnly;
-    typedef typename BaseClass::LocalSimpleRef LocalSimpleRef;
+  typedef nsAutoRef<T> ThisClass;
+  typedef nsAutoRefBase<T> BaseClass;
+  typedef nsSimpleRef<T> SimpleRef;
+  typedef typename BaseClass::RawRefOnly RawRefOnly;
+  typedef typename BaseClass::LocalSimpleRef LocalSimpleRef;
 
 public:
-    nsAutoRef()
-    {
-    }
+  nsAutoRef()
+  {
+  }
 
-    // Explicit construction is required so as not to risk unintentionally
-    // releasing the resource associated with a raw ref.
-    explicit nsAutoRef(RawRefOnly aRefToRelease)
-        : BaseClass(aRefToRelease)
-    {
-    }
+  // Explicit construction is required so as not to risk unintentionally
+  // releasing the resource associated with a raw ref.
+  explicit nsAutoRef(RawRefOnly aRefToRelease)
+    : BaseClass(aRefToRelease)
+  {
+  }
 
-    // Construction from a nsReturnRef<T> function return value, which expects
-    // to give up ownership, transfers ownership.
-    // (nsReturnRef<T> is converted to const nsReturningRef<T>.)
-    explicit nsAutoRef(const nsReturningRef<T>& aReturning)
-        : BaseClass(aReturning)
-    {
-    }
+  // Construction from a nsReturnRef<T> function return value, which expects
+  // to give up ownership, transfers ownership.
+  // (nsReturnRef<T> is converted to const nsReturningRef<T>.)
+  explicit nsAutoRef(const nsReturningRef<T>& aReturning)
+    : BaseClass(aReturning)
+  {
+  }
 
-    // The only assignment operator provided is for transferring from an
-    // nsReturnRef smart reference, which expects to pass its ownership to
-    // another object.
-    //
-    // With raw references and other smart references, the type of the lhs and
-    // its taking and releasing nature is often not obvious from an assignment
-    // statement.  Assignment from a raw ptr especially is not normally
-    // expected to release the reference.
-    //
-    // Use |steal| for taking ownership from other smart refs.
-    //
-    // For raw references, use |own| to indicate intention to have the
-    // resource released.
-    //
-    // Or, to create another owner of the same reference, use an nsCountedRef.
+  // The only assignment operator provided is for transferring from an
+  // nsReturnRef smart reference, which expects to pass its ownership to
+  // another object.
+  //
+  // With raw references and other smart references, the type of the lhs and
+  // its taking and releasing nature is often not obvious from an assignment
+  // statement.  Assignment from a raw ptr especially is not normally
+  // expected to release the reference.
+  //
+  // Use |steal| for taking ownership from other smart refs.
+  //
+  // For raw references, use |own| to indicate intention to have the
+  // resource released.
+  //
+  // Or, to create another owner of the same reference, use an nsCountedRef.
 
-    ThisClass& operator=(const nsReturningRef<T>& aReturning)
-    {
-        BaseClass::steal(aReturning.mReturnRef);
-        return *this;
-    }
+  ThisClass& operator=(const nsReturningRef<T>& aReturning)
+  {
+    BaseClass::steal(aReturning.mReturnRef);
+    return *this;
+  }
 
-    // Conversion to a raw reference allow the nsAutoRef<T> to often be used
-    // like a raw reference.
-    operator typename SimpleRef::RawRef() const
-    {
-        return this->get();
-    }
+  // Conversion to a raw reference allow the nsAutoRef<T> to often be used
+  // like a raw reference.
+  operator typename SimpleRef::RawRef() const
+  {
+    return this->get();
+  }
 
-    // Transfer ownership from another smart reference.
-    void steal(ThisClass& aOtherRef)
-    {
-        BaseClass::steal(aOtherRef);
-    }
+  // Transfer ownership from another smart reference.
+  void steal(ThisClass& aOtherRef)
+  {
+    BaseClass::steal(aOtherRef);
+  }
 
-    // Assume ownership of a raw ref.
-    //
-    // |own| has similar function to |steal|, and is useful for receiving
-    // ownership from a return value of a function.  It is named differently
-    // because |own| requires more care to ensure that the function intends to
-    // give away ownership, and so that |steal| can be safely used, knowing
-    // that it won't steal ownership from any methods returning raw ptrs to
-    // data owned by a foreign object.
-    void own(RawRefOnly aRefToRelease)
-    {
-        BaseClass::own(aRefToRelease);
-    }
+  // Assume ownership of a raw ref.
+  //
+  // |own| has similar function to |steal|, and is useful for receiving
+  // ownership from a return value of a function.  It is named differently
+  // because |own| requires more care to ensure that the function intends to
+  // give away ownership, and so that |steal| can be safely used, knowing
+  // that it won't steal ownership from any methods returning raw ptrs to
+  // data owned by a foreign object.
+  void own(RawRefOnly aRefToRelease)
+  {
+    BaseClass::own(aRefToRelease);
+  }
 
-    // Exchange ownership with |aOther|
-    void swap(ThisClass& aOther)
-    {
-        LocalSimpleRef temp;
-        temp.SimpleRef::operator=(*this);
-        SimpleRef::operator=(aOther);
-        aOther.SimpleRef::operator=(temp);
-    }
+  // Exchange ownership with |aOther|
+  void swap(ThisClass& aOther)
+  {
+    LocalSimpleRef temp;
+    temp.SimpleRef::operator=(*this);
+    SimpleRef::operator=(aOther);
+    aOther.SimpleRef::operator=(temp);
+  }
 
-    // Release the reference now.
-    void reset()
-    {
-        this->SafeRelease();
-        LocalSimpleRef empty;
-        SimpleRef::operator=(empty);
-    }
+  // Release the reference now.
+  void reset()
+  {
+    this->SafeRelease();
+    LocalSimpleRef empty;
+    SimpleRef::operator=(empty);
+  }
 
-    // Pass out the reference for a function return values.
-    nsReturnRef<T> out()
-    {
-        return nsReturnRef<T>(this->disown());
-    }
+  // Pass out the reference for a function return values.
+  nsReturnRef<T> out()
+  {
+    return nsReturnRef<T>(this->disown());
+  }
 
-    // operator->() and disown() are provided by nsAutoRefBase<T>.
-    // The default nsSimpleRef<T> provides get().
+  // operator->() and disown() are provided by nsAutoRefBase<T>.
+  // The default nsSimpleRef<T> provides get().
 
 private:
-    // No copy constructor
-    explicit nsAutoRef(ThisClass& aRefToSteal);
+  // No copy constructor
+  explicit nsAutoRef(ThisClass& aRefToSteal);
 };
 
 /**
  * template <class T> class nsCountedRef
  *
  * A class that creates (adds) a new reference to a resource on construction
  * or assignment and releases on destruction.
  *
@@ -227,133 +227,133 @@ private:
  * class assumes that the resource itself counts references and so can only be
  * used when |T| represents a reference-counting resource.
  */
 
 template <class T>
 class nsCountedRef : public nsAutoRef<T>
 {
 protected:
-    typedef nsCountedRef<T> ThisClass;
-    typedef nsAutoRef<T> BaseClass;
-    typedef nsSimpleRef<T> SimpleRef;
-    typedef typename BaseClass::RawRef RawRef;
+  typedef nsCountedRef<T> ThisClass;
+  typedef nsAutoRef<T> BaseClass;
+  typedef nsSimpleRef<T> SimpleRef;
+  typedef typename BaseClass::RawRef RawRef;
 
 public:
-    nsCountedRef()
-    {
-    }
+  nsCountedRef()
+  {
+  }
 
-    // Construction and assignment from a another nsCountedRef
-    // or a raw ref copies and increments the ref count.
-    nsCountedRef(const ThisClass& aRefToCopy)
-    {
-        SimpleRef::operator=(aRefToCopy);
-        SafeAddRef();
-    }
-    ThisClass& operator=(const ThisClass& aRefToCopy)
-    {
-        if (this == &aRefToCopy)
-            return *this;
+  // Construction and assignment from a another nsCountedRef
+  // or a raw ref copies and increments the ref count.
+  nsCountedRef(const ThisClass& aRefToCopy)
+  {
+    SimpleRef::operator=(aRefToCopy);
+    SafeAddRef();
+  }
+  ThisClass& operator=(const ThisClass& aRefToCopy)
+  {
+    if (this == &aRefToCopy)
+      return *this;
 
-        this->SafeRelease();
-        SimpleRef::operator=(aRefToCopy);
-        SafeAddRef();
-        return *this;
-    }
+    this->SafeRelease();
+    SimpleRef::operator=(aRefToCopy);
+    SafeAddRef();
+    return *this;
+  }
 
-    // Implicit conversion from another smart ref argument (to a raw ref) is
-    // accepted here because construction and assignment safely creates a new
-    // reference without interfering with the reference to copy.
-    explicit nsCountedRef(RawRef aRefToCopy)
-        : BaseClass(aRefToCopy)
-    {
-        SafeAddRef();
-    }
-    ThisClass& operator=(RawRef aRefToCopy)
-    {
-        this->own(aRefToCopy);
-        SafeAddRef();
-        return *this;
-    }
+  // Implicit conversion from another smart ref argument (to a raw ref) is
+  // accepted here because construction and assignment safely creates a new
+  // reference without interfering with the reference to copy.
+  explicit nsCountedRef(RawRef aRefToCopy)
+    : BaseClass(aRefToCopy)
+  {
+    SafeAddRef();
+  }
+  ThisClass& operator=(RawRef aRefToCopy)
+  {
+    this->own(aRefToCopy);
+    SafeAddRef();
+    return *this;
+  }
 
-    // Construction and assignment from an nsReturnRef function return value,
-    // which expects to give up ownership, transfers ownership.
-    explicit nsCountedRef(const nsReturningRef<T>& aReturning)
-        : BaseClass(aReturning)
-    {
-    }
-    ThisClass& operator=(const nsReturningRef<T>& aReturning)
-    {
-        BaseClass::operator=(aReturning);
-        return *this;
-    }
+  // Construction and assignment from an nsReturnRef function return value,
+  // which expects to give up ownership, transfers ownership.
+  explicit nsCountedRef(const nsReturningRef<T>& aReturning)
+    : BaseClass(aReturning)
+  {
+  }
+  ThisClass& operator=(const nsReturningRef<T>& aReturning)
+  {
+    BaseClass::operator=(aReturning);
+    return *this;
+  }
 
 protected:
-    // Increase the reference count if there is a resource.
-    void SafeAddRef()
-    {
-        if (this->HaveResource())
-            this->AddRef(this->get());
-    }
+  // Increase the reference count if there is a resource.
+  void SafeAddRef()
+  {
+    if (this->HaveResource())
+      this->AddRef(this->get());
+  }
 };
 
 /**
  * template <class T> class nsReturnRef
  *
  * A type for function return values that hold a reference to a resource that
  * must be released.  See also |nsAutoRef<T>::out()|.
  */
 
 template <class T>
 class nsReturnRef : public nsAutoRefBase<T>
 {
 protected:
-    typedef nsAutoRefBase<T> BaseClass;
-    typedef typename BaseClass::RawRefOnly RawRefOnly;
+  typedef nsAutoRefBase<T> BaseClass;
+  typedef typename BaseClass::RawRefOnly RawRefOnly;
 
 public:
-    // For constructing a return value with no resource
-    nsReturnRef()
-    {
-    }
+  // For constructing a return value with no resource
+  nsReturnRef()
+  {
+  }
 
-    // For returning a smart reference from a raw reference that must be
-    // released.  Explicit construction is required so as not to risk
-    // unintentionally releasing the resource associated with a raw ref.
-    explicit nsReturnRef(RawRefOnly aRefToRelease)
-        : BaseClass(aRefToRelease)
-    {
-    }
+  // For returning a smart reference from a raw reference that must be
+  // released.  Explicit construction is required so as not to risk
+  // unintentionally releasing the resource associated with a raw ref.
+  explicit nsReturnRef(RawRefOnly aRefToRelease)
+    : BaseClass(aRefToRelease)
+  {
+  }
 
-    // Copy construction transfers ownership
-    nsReturnRef(nsReturnRef<T>& aRefToSteal)
-        : BaseClass(aRefToSteal)
-    {
-    }
+  // Copy construction transfers ownership
+  nsReturnRef(nsReturnRef<T>& aRefToSteal)
+    : BaseClass(aRefToSteal)
+  {
+  }
 
-    nsReturnRef(const nsReturningRef<T>& aReturning)
-        : BaseClass(aReturning)
-    {
-    }
+  nsReturnRef(const nsReturningRef<T>& aReturning)
+    : BaseClass(aReturning)
+  {
+  }
 
-    // Conversion to a temporary (const) object referring to this object so
-    // that the reference may be passed from a function return value
-    // (temporary) to another smart reference.  There is no need to use this
-    // explicitly.  Simply assign a nsReturnRef<T> function return value to a
-    // smart reference.
-    operator nsReturningRef<T>()
-    {
-        return nsReturningRef<T>(*this);
-    }
+  // Conversion to a temporary (const) object referring to this object so
+  // that the reference may be passed from a function return value
+  // (temporary) to another smart reference.  There is no need to use this
+  // explicitly.  Simply assign a nsReturnRef<T> function return value to a
+  // smart reference.
+  operator nsReturningRef<T>()
+  {
+    return nsReturningRef<T>(*this);
+  }
 
-    // No conversion to RawRef operator is provided on nsReturnRef, to ensure
-    // that the return value is not carelessly assigned to a raw ptr (and the
-    // resource then released).  If passing to a function that takes a raw
-    // ptr, use get or disown as appropriate.
+  // No conversion to RawRef operator is provided on nsReturnRef, to ensure
+  // that the return value is not carelessly assigned to a raw ptr (and the
+  // resource then released).  If passing to a function that takes a raw
+  // ptr, use get or disown as appropriate.
 };
 
 /**
  * template <class T> class nsReturningRef
  *
  * A class to allow ownership to be transferred from nsReturnRef function
  * return values.
  *
@@ -365,24 +365,24 @@ public:
  * class nsReturningRef<T> around a non-const reference to the nsReturnRef.
  * The wrapper can then be passed as an rvalue parameter.
  */
 
 template <class T>
 class nsReturningRef
 {
 private:
-    friend class nsReturnRef<T>;
+  friend class nsReturnRef<T>;
 
-    explicit nsReturningRef(nsReturnRef<T>& aReturnRef)
-        : mReturnRef(aReturnRef)
-    {
-    }
+  explicit nsReturningRef(nsReturnRef<T>& aReturnRef)
+    : mReturnRef(aReturnRef)
+  {
+  }
 public:
-    nsReturnRef<T>& mReturnRef;
+  nsReturnRef<T>& mReturnRef;
 };
 
 /**
  * template <class T> class nsAutoRefTraits
  *
  * A class describing traits of references managed by the default
  * |nsSimpleRef<T>| implementation and thus |nsAutoRef<T>| and |nsCountedRef|.
  * The default |nsSimpleRef<T> is suitable for resources with handles that
@@ -459,20 +459,20 @@ template <class T> class nsAutoRefTraits
  *     static void AddRef(FcPattern *ptr) { FcPatternReference(ptr); }
  * };
  */
 
 template <class T>
 class nsPointerRefTraits
 {
 public:
-    // The handle is a pointer to T.
-    typedef T* RawRef;
-    // A nullptr does not have a resource.
-    static RawRef Void() { return nullptr; }
+  // The handle is a pointer to T.
+  typedef T* RawRef;
+  // A nullptr does not have a resource.
+  static RawRef Void() { return nullptr; }
 };
 
 /**
  * template <class T> class nsSimpleRef
  *
  * Constructs a non-smart reference, and provides methods to test whether
  * there is an associated resource and (if so) get its raw handle.
  *
@@ -485,182 +485,182 @@ public:
  * and, if |nsCountedRef<T>| is required, AddRef(RawRef), as described in
  * nsAutoRefTraits<T>.
  */
 
 template <class T>
 class nsSimpleRef : protected nsAutoRefTraits<T>
 {
 protected:
-    // The default implementation uses nsAutoRefTrait<T>.
-    // Specializations need not define this typedef.
-    typedef nsAutoRefTraits<T> Traits;
-    // The type of the handle to the resource.
-    // A specialization must provide a typedef for RawRef.
-    typedef typename Traits::RawRef RawRef;
+  // The default implementation uses nsAutoRefTrait<T>.
+  // Specializations need not define this typedef.
+  typedef nsAutoRefTraits<T> Traits;
+  // The type of the handle to the resource.
+  // A specialization must provide a typedef for RawRef.
+  typedef typename Traits::RawRef RawRef;
 
-    // Construct with no resource.
-    //
-    // If this constructor is not accessible then some limited nsAutoRef
-    // functionality will still be available, but the default constructor,
-    // |reset|, and most transfer of ownership methods will not be available.
-    nsSimpleRef()
-        : mRawRef(Traits::Void())
-    {
-    }
-    // Construct with a handle to a resource.
-    // A specialization must provide this. 
-    nsSimpleRef(RawRef aRawRef)
-        : mRawRef(aRawRef)
-    {
-    }
+  // Construct with no resource.
+  //
+  // If this constructor is not accessible then some limited nsAutoRef
+  // functionality will still be available, but the default constructor,
+  // |reset|, and most transfer of ownership methods will not be available.
+  nsSimpleRef()
+    : mRawRef(Traits::Void())
+  {
+  }
+  // Construct with a handle to a resource.
+  // A specialization must provide this.
+  nsSimpleRef(RawRef aRawRef)
+    : mRawRef(aRawRef)
+  {
+  }
 
-    // Test whether there is an associated resource.  A specialization must
-    // provide this.  The function is permitted to always return true if the
-    // default constructor is not accessible, or if Release (and AddRef) can
-    // deal with void handles.
-    bool HaveResource() const
-    {
-        return mRawRef != Traits::Void();
-    }
+  // Test whether there is an associated resource.  A specialization must
+  // provide this.  The function is permitted to always return true if the
+  // default constructor is not accessible, or if Release (and AddRef) can
+  // deal with void handles.
+  bool HaveResource() const
+  {
+    return mRawRef != Traits::Void();
+  }
 
 public:
-    // A specialization must provide get() or loose some functionality.  This
-    // is inherited by derived classes and the specialization may choose
-    // whether it is public or protected.
-    RawRef get() const
-    {
-        return mRawRef;
-    }
+  // A specialization must provide get() or loose some functionality.  This
+  // is inherited by derived classes and the specialization may choose
+  // whether it is public or protected.
+  RawRef get() const
+  {
+    return mRawRef;
+  }
 
 private:
-    RawRef mRawRef;
+  RawRef mRawRef;
 };
 
 
 /**
  * template <class T> class nsAutoRefBase
  *
  * Internal base class for |nsAutoRef<T>| and |nsReturnRef<T>|.
  * Adds release on destruction to a |nsSimpleRef<T>|.
  */
 
 template <class T>
 class nsAutoRefBase : public nsSimpleRef<T>
 {
 protected:
-    typedef nsAutoRefBase<T> ThisClass;
-    typedef nsSimpleRef<T> SimpleRef;
-    typedef typename SimpleRef::RawRef RawRef;
+  typedef nsAutoRefBase<T> ThisClass;
+  typedef nsSimpleRef<T> SimpleRef;
+  typedef typename SimpleRef::RawRef RawRef;
+
+  nsAutoRefBase()
+  {
+  }
 
-    nsAutoRefBase()
+  // A type for parameters that should be passed a raw ref but should not
+  // accept implicit conversions (from another smart ref).  (The only
+  // conversion to this type is from a raw ref so only raw refs will be
+  // accepted.)
+  class RawRefOnly
+  {
+  public:
+    RawRefOnly(RawRef aRawRef)
+      : mRawRef(aRawRef)
     {
     }
-
-    // A type for parameters that should be passed a raw ref but should not
-    // accept implicit conversions (from another smart ref).  (The only
-    // conversion to this type is from a raw ref so only raw refs will be
-    // accepted.)
-    class RawRefOnly
+    operator RawRef() const
     {
-    public:
-        RawRefOnly(RawRef aRawRef)
-            : mRawRef(aRawRef)
-        {
-        }
-        operator RawRef() const
-        {
-            return mRawRef;
-        }
-    private:
-        RawRef mRawRef;
-    };
+      return mRawRef;
+    }
+  private:
+    RawRef mRawRef;
+  };
+
+  // Construction from a raw ref assumes ownership
+  explicit nsAutoRefBase(RawRefOnly aRefToRelease)
+    : SimpleRef(aRefToRelease)
+  {
+  }
 
-    // Construction from a raw ref assumes ownership
-    explicit nsAutoRefBase(RawRefOnly aRefToRelease)
-        : SimpleRef(aRefToRelease)
-    {
-    }
+  // Constructors that steal ownership
+  explicit nsAutoRefBase(ThisClass& aRefToSteal)
+    : SimpleRef(aRefToSteal.disown())
+  {
+  }
+  explicit nsAutoRefBase(const nsReturningRef<T>& aReturning)
+    : SimpleRef(aReturning.mReturnRef.disown())
+  {
+  }
 
-    // Constructors that steal ownership
-    explicit nsAutoRefBase(ThisClass& aRefToSteal)
-        : SimpleRef(aRefToSteal.disown())
-    {
-    }
-    explicit nsAutoRefBase(const nsReturningRef<T>& aReturning)
-        : SimpleRef(aReturning.mReturnRef.disown())
+  ~nsAutoRefBase()
+  {
+    SafeRelease();
+  }
+
+  // An internal class providing access to protected nsSimpleRef<T>
+  // constructors for construction of temporary simple references (that are
+  // not ThisClass).
+  class LocalSimpleRef : public SimpleRef
+  {
+  public:
+    LocalSimpleRef()
     {
     }
-
-    ~nsAutoRefBase()
+    explicit LocalSimpleRef(RawRef aRawRef)
+      : SimpleRef(aRawRef)
     {
-        SafeRelease();
     }
-
-    // An internal class providing access to protected nsSimpleRef<T>
-    // constructors for construction of temporary simple references (that are
-    // not ThisClass).
-    class LocalSimpleRef : public SimpleRef
-    {
-    public:
-        LocalSimpleRef()
-        {
-        }
-        explicit LocalSimpleRef(RawRef aRawRef)
-            : SimpleRef(aRawRef)
-        {
-        }
-    };
+  };
 
 private:
-    ThisClass& operator=(const ThisClass& aSmartRef) MOZ_DELETE;
-    
+  ThisClass& operator=(const ThisClass& aSmartRef) MOZ_DELETE;
+
 public:
-    RawRef operator->() const
-    {
-        return this->get();
-    }
+  RawRef operator->() const
+  {
+    return this->get();
+  }
 
-    // Transfer ownership to a raw reference.
-    //
-    // THE CALLER MUST ENSURE THAT THE REFERENCE IS EXPLICITLY RELEASED.
-    //
-    // Is this really what you want to use?  Using this removes any guarantee
-    // of release.  Use nsAutoRef<T>::out() for return values, or an
-    // nsAutoRef<T> modifiable lvalue for an out parameter.  Use disown() when
-    // the reference must be stored in a POD type object, such as may be
-    // preferred for a namespace-scope object with static storage duration,
-    // for example.
-    RawRef disown()
-    {
-        RawRef temp = this->get();
-        LocalSimpleRef empty;
-        SimpleRef::operator=(empty);
-        return temp;
-    }
+  // Transfer ownership to a raw reference.
+  //
+  // THE CALLER MUST ENSURE THAT THE REFERENCE IS EXPLICITLY RELEASED.
+  //
+  // Is this really what you want to use?  Using this removes any guarantee
+  // of release.  Use nsAutoRef<T>::out() for return values, or an
+  // nsAutoRef<T> modifiable lvalue for an out parameter.  Use disown() when
+  // the reference must be stored in a POD type object, such as may be
+  // preferred for a namespace-scope object with static storage duration,
+  // for example.
+  RawRef disown()
+  {
+    RawRef temp = this->get();
+    LocalSimpleRef empty;
+    SimpleRef::operator=(empty);
+    return temp;
+  }
 
 protected:
-    // steal and own are protected because they make no sense on nsReturnRef,
-    // but steal is implemented on this class for access to aOtherRef.disown()
-    // when aOtherRef is an nsReturnRef;
+  // steal and own are protected because they make no sense on nsReturnRef,
+  // but steal is implemented on this class for access to aOtherRef.disown()
+  // when aOtherRef is an nsReturnRef;
 
-    // Transfer ownership from another smart reference.
-    void steal(ThisClass& aOtherRef)
-    {
-        own(aOtherRef.disown());
-    }
-    // Assume ownership of a raw ref.
-    void own(RawRefOnly aRefToRelease)
-    {
-        SafeRelease();
-        LocalSimpleRef ref(aRefToRelease);
-        SimpleRef::operator=(ref);
-    }
+  // Transfer ownership from another smart reference.
+  void steal(ThisClass& aOtherRef)
+  {
+    own(aOtherRef.disown());
+  }
+  // Assume ownership of a raw ref.
+  void own(RawRefOnly aRefToRelease)
+  {
+    SafeRelease();
+    LocalSimpleRef ref(aRefToRelease);
+    SimpleRef::operator=(ref);
+  }
 
-    // Release a resource if there is one.
-    void SafeRelease()
-    {
-        if (this->HaveResource())
-            this->Release(this->get());
-    }
+  // Release a resource if there is one.
+  void SafeRelease()
+  {
+    if (this->HaveResource())
+      this->Release(this->get());
+  }
 };
 
 #endif // !defined(nsAutoRef_h_)
--- a/xpcom/base/nsConsoleMessage.cpp
+++ b/xpcom/base/nsConsoleMessage.cpp
@@ -1,25 +1,26 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 /*
  * Base implementation for console messages.
  */
 
 #include "nsConsoleMessage.h"
 #include "jsapi.h"
 
 NS_IMPL_ISUPPORTS(nsConsoleMessage, nsIConsoleMessage)
 
 nsConsoleMessage::nsConsoleMessage()
-    :  mTimeStamp(0),
-       mMessage()
+  : mTimeStamp(0),
+    mMessage()
 {
 }
 
 nsConsoleMessage::nsConsoleMessage(const char16_t *message)
 {
   mTimeStamp = JS_Now() / 1000;
   mMessage.Assign(message);
 }
--- a/xpcom/base/nsConsoleMessage.h
+++ b/xpcom/base/nsConsoleMessage.h
@@ -1,29 +1,30 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 #ifndef __nsconsolemessage_h__
 #define __nsconsolemessage_h__
 
 #include "mozilla/Attributes.h"
 
 #include "nsIConsoleMessage.h"
 #include "nsString.h"
 
 class nsConsoleMessage MOZ_FINAL : public nsIConsoleMessage {
 public:
-    nsConsoleMessage();
-    nsConsoleMessage(const char16_t *message);
+  nsConsoleMessage();
+  nsConsoleMessage(const char16_t *message);
 
-    NS_DECL_THREADSAFE_ISUPPORTS
-    NS_DECL_NSICONSOLEMESSAGE
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSICONSOLEMESSAGE
 
 private:
-    ~nsConsoleMessage() {}
+  ~nsConsoleMessage() {}
 
-    int64_t mTimeStamp;
-    nsString mMessage;
+  int64_t mTimeStamp;
+  nsString mMessage;
 };
 
 #endif /* __nsconsolemessage_h__ */
--- a/xpcom/base/nsConsoleService.cpp
+++ b/xpcom/base/nsConsoleService.cpp
@@ -1,9 +1,10 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 /*
  * Maintains a circular buffer of recent messages, and notifies
  * listeners when new messages are logged.
  */
@@ -36,338 +37,338 @@ NS_IMPL_RELEASE(nsConsoleService)
 NS_IMPL_CLASSINFO(nsConsoleService, nullptr, nsIClassInfo::THREADSAFE | nsIClassInfo::SINGLETON, NS_CONSOLESERVICE_CID)
 NS_IMPL_QUERY_INTERFACE_CI(nsConsoleService, nsIConsoleService)
 NS_IMPL_CI_INTERFACE_GETTER(nsConsoleService, nsIConsoleService)
 
 static bool sLoggingEnabled = true;
 static bool sLoggingBuffered = true;
 
 nsConsoleService::nsConsoleService()
-    : mMessages(nullptr)
-    , mCurrent(0)
-    , mFull(false)
-    , mDeliveringMessage(false)
-    , mLock("nsConsoleService.mLock")
+  : mMessages(nullptr)
+  , mCurrent(0)
+  , mFull(false)
+  , mDeliveringMessage(false)
+  , mLock("nsConsoleService.mLock")
 {
-    // XXX grab this from a pref!
-    // hm, but worry about circularity, bc we want to be able to report
-    // prefs errs...
-    mBufferSize = 250;
+  // XXX grab this from a pref!
+  // hm, but worry about circularity, bc we want to be able to report
+  // prefs errs...
+  mBufferSize = 250;
 }
 
 nsConsoleService::~nsConsoleService()
 {
-    uint32_t i = 0;
-    while (i < mBufferSize && mMessages[i] != nullptr) {
-        NS_RELEASE(mMessages[i]);
-        i++;
-    }
+  uint32_t i = 0;
+  while (i < mBufferSize && mMessages[i] != nullptr) {
+    NS_RELEASE(mMessages[i]);
+    i++;
+  }
 
-    if (mMessages)
-        nsMemory::Free(mMessages);
+  if (mMessages)
+    nsMemory::Free(mMessages);
 }
 
 class AddConsolePrefWatchers : public nsRunnable
 {
 public:
-    AddConsolePrefWatchers(nsConsoleService* aConsole) : mConsole(aConsole) {}
+  AddConsolePrefWatchers(nsConsoleService* aConsole) : mConsole(aConsole) {}
 
-    NS_IMETHOD Run()
-    {
-        Preferences::AddBoolVarCache(&sLoggingEnabled, "consoleservice.enabled", true);
-        Preferences::AddBoolVarCache(&sLoggingBuffered, "consoleservice.buffered", true);
-        if (!sLoggingBuffered) {
-            mConsole->Reset();
-        }
-        return NS_OK;
+  NS_IMETHOD Run()
+  {
+    Preferences::AddBoolVarCache(&sLoggingEnabled, "consoleservice.enabled", true);
+    Preferences::AddBoolVarCache(&sLoggingBuffered, "consoleservice.buffered", true);
+    if (!sLoggingBuffered) {
+      mConsole->Reset();
     }
+    return NS_OK;
+  }
 
 private:
-    nsRefPtr<nsConsoleService> mConsole;
+  nsRefPtr<nsConsoleService> mConsole;
 };
 
 nsresult
 nsConsoleService::Init()
 {
-    mMessages = (nsIConsoleMessage **)
-        nsMemory::Alloc(mBufferSize * sizeof(nsIConsoleMessage *));
-    if (!mMessages)
-        return NS_ERROR_OUT_OF_MEMORY;
+  mMessages = (nsIConsoleMessage **)
+    nsMemory::Alloc(mBufferSize * sizeof(nsIConsoleMessage *));
+  if (!mMessages)
+    return NS_ERROR_OUT_OF_MEMORY;
 
-    // Array elements should be 0 initially for circular buffer algorithm.
-    memset(mMessages, 0, mBufferSize * sizeof(nsIConsoleMessage *));
+  // Array elements should be 0 initially for circular buffer algorithm.
+  memset(mMessages, 0, mBufferSize * sizeof(nsIConsoleMessage *));
 
-    NS_DispatchToMainThread(new AddConsolePrefWatchers(this));
+  NS_DispatchToMainThread(new AddConsolePrefWatchers(this));
 
-    return NS_OK;
+  return NS_OK;
 }
 
 namespace {
 
 class LogMessageRunnable : public nsRunnable
 {
 public:
-    LogMessageRunnable(nsIConsoleMessage* message, nsConsoleService* service)
-        : mMessage(message)
-        , mService(service)
-    { }
+  LogMessageRunnable(nsIConsoleMessage* message, nsConsoleService* service)
+    : mMessage(message)
+    , mService(service)
+  { }
 
-    NS_DECL_NSIRUNNABLE
+  NS_DECL_NSIRUNNABLE
 
 private:
-    nsCOMPtr<nsIConsoleMessage> mMessage;
-    nsRefPtr<nsConsoleService> mService;
+  nsCOMPtr<nsIConsoleMessage> mMessage;
+  nsRefPtr<nsConsoleService> mService;
 };
 
 typedef nsCOMArray<nsIConsoleListener> ListenerArrayType;
 
 PLDHashOperator
 CollectCurrentListeners(nsISupports* aKey, nsIConsoleListener* aValue,
                         void* closure)
 {
-    ListenerArrayType* listeners = static_cast<ListenerArrayType*>(closure);
-    listeners->AppendObject(aValue);
-    return PL_DHASH_NEXT;
+  ListenerArrayType* listeners = static_cast<ListenerArrayType*>(closure);
+  listeners->AppendObject(aValue);
+  return PL_DHASH_NEXT;
 }
 
 NS_IMETHODIMP
 LogMessageRunnable::Run()
 {
-    MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(NS_IsMainThread());
 
-    // Snapshot of listeners so that we don't reenter this hash during
-    // enumeration.
-    nsCOMArray<nsIConsoleListener> listeners;
-    mService->EnumerateListeners(CollectCurrentListeners, &listeners);
+  // Snapshot of listeners so that we don't reenter this hash during
+  // enumeration.
+  nsCOMArray<nsIConsoleListener> listeners;
+  mService->EnumerateListeners(CollectCurrentListeners, &listeners);
 
-    mService->SetIsDelivering();
+  mService->SetIsDelivering();
 
-    for (int32_t i = 0; i < listeners.Count(); ++i)
-        listeners[i]->Observe(mMessage);
+  for (int32_t i = 0; i < listeners.Count(); ++i)
+    listeners[i]->Observe(mMessage);
 
-    mService->SetDoneDelivering();
+  mService->SetDoneDelivering();
 
-    return NS_OK;
+  return NS_OK;
 }
 
 } // anonymous namespace
 
 // nsIConsoleService methods
 NS_IMETHODIMP
 nsConsoleService::LogMessage(nsIConsoleMessage *message)
 {
-    return LogMessageWithMode(message, OutputToLog);
+  return LogMessageWithMode(message, OutputToLog);
 }
 
 nsresult
 nsConsoleService::LogMessageWithMode(nsIConsoleMessage *message, nsConsoleService::OutputMode outputMode)
 {
-    if (message == nullptr)
-        return NS_ERROR_INVALID_ARG;
+  if (message == nullptr)
+    return NS_ERROR_INVALID_ARG;
 
-    if (!sLoggingEnabled) {
-        return NS_OK;
-    }
+  if (!sLoggingEnabled) {
+    return NS_OK;
+  }
 
-    if (NS_IsMainThread() && mDeliveringMessage) {
-        nsCString msg;
-        message->ToString(msg);
-        NS_WARNING(nsPrintfCString("Reentrancy error: some client attempted "
-            "to display a message to the console while in a console listener. "
-            "The following message was discarded: \"%s\"", msg.get()).get());
-        return NS_ERROR_FAILURE;
-    }
+  if (NS_IsMainThread() && mDeliveringMessage) {
+    nsCString msg;
+    message->ToString(msg);
+    NS_WARNING(nsPrintfCString("Reentrancy error: some client attempted "
+      "to display a message to the console while in a console listener. "
+      "The following message was discarded: \"%s\"", msg.get()).get());
+    return NS_ERROR_FAILURE;
+  }
 
-    nsRefPtr<LogMessageRunnable> r;
-    nsIConsoleMessage *retiredMessage;
+  nsRefPtr<LogMessageRunnable> r;
+  nsIConsoleMessage *retiredMessage;
 
-    if (sLoggingBuffered) {
-        NS_ADDREF(message); // early, in case it's same as replaced below.
-    }
+  if (sLoggingBuffered) {
+    NS_ADDREF(message); // early, in case it's same as replaced below.
+  }
 
-    /*
-     * Lock while updating buffer, and while taking snapshot of
-     * listeners array.
-     */
-    {
-        MutexAutoLock lock(mLock);
+  /*
+   * Lock while updating buffer, and while taking snapshot of
+   * listeners array.
+   */
+  {
+    MutexAutoLock lock(mLock);
 
 #if defined(ANDROID)
-        if (outputMode == OutputToLog)
-        {
-            nsCString msg;
-            message->ToString(msg);
-            __android_log_print(ANDROID_LOG_ERROR, "GeckoConsole",
-                        "%s", msg.get());
-        }
+    if (outputMode == OutputToLog)
+    {
+      nsCString msg;
+      message->ToString(msg);
+      __android_log_print(ANDROID_LOG_ERROR, "GeckoConsole",
+                          "%s", msg.get());
+    }
 #endif
 #ifdef XP_WIN
-        if (IsDebuggerPresent()) {
-            nsString msg;
-            message->GetMessageMoz(getter_Copies(msg));
-            msg.AppendLiteral("\n");
-            OutputDebugStringW(msg.get());
-        }
+    if (IsDebuggerPresent()) {
+      nsString msg;
+      message->GetMessageMoz(getter_Copies(msg));
+      msg.AppendLiteral("\n");
+      OutputDebugStringW(msg.get());
+    }
 #endif
 
-        /*
-         * If there's already a message in the slot we're about to replace,
-         * we've wrapped around, and we need to release the old message.  We
-         * save a pointer to it, so we can release below outside the lock.
-         */
-        retiredMessage = mMessages[mCurrent];
+    /*
+     * If there's already a message in the slot we're about to replace,
+     * we've wrapped around, and we need to release the old message.  We
+     * save a pointer to it, so we can release below outside the lock.
+     */
+    retiredMessage = mMessages[mCurrent];
 
-        if (sLoggingBuffered) {
-            mMessages[mCurrent++] = message;
-            if (mCurrent == mBufferSize) {
-                mCurrent = 0; // wrap around.
-                mFull = true;
-            }
-        }
-
-        if (mListeners.Count() > 0) {
-            r = new LogMessageRunnable(message, this);
-        }
+    if (sLoggingBuffered) {
+      mMessages[mCurrent++] = message;
+      if (mCurrent == mBufferSize) {
+        mCurrent = 0; // wrap around.
+        mFull = true;
+      }
     }
 
-    if (retiredMessage != nullptr)
-        NS_RELEASE(retiredMessage);
+    if (mListeners.Count() > 0) {
+      r = new LogMessageRunnable(message, this);
+    }
+  }
 
-    if (r)
-        NS_DispatchToMainThread(r);
+  if (retiredMessage != nullptr)
+    NS_RELEASE(retiredMessage);
 
-    return NS_OK;
+  if (r)
+    NS_DispatchToMainThread(r);
+
+  return NS_OK;
 }
 
 void
 nsConsoleService::EnumerateListeners(ListenerHash::EnumReadFunction aFunction,
                                      void* aClosure)
 {
-    MutexAutoLock lock(mLock);
-    mListeners.EnumerateRead(aFunction, aClosure);
+  MutexAutoLock lock(mLock);
+  mListeners.EnumerateRead(aFunction, aClosure);
 }
 
 NS_IMETHODIMP
 nsConsoleService::LogStringMessage(const char16_t *message)
 {
-    if (!sLoggingEnabled) {
-        return NS_OK;
-    }
+  if (!sLoggingEnabled) {
+    return NS_OK;
+  }
 
-    nsRefPtr<nsConsoleMessage> msg(new nsConsoleMessage(message));
-    return this->LogMessage(msg);
+  nsRefPtr<nsConsoleMessage> msg(new nsConsoleMessage(message));
+  return this->LogMessage(msg);
 }
 
 NS_IMETHODIMP
 nsConsoleService::GetMessageArray(uint32_t *count, nsIConsoleMessage ***messages)
 {
-    nsIConsoleMessage **messageArray;
-
-    /*
-     * Lock the whole method, as we don't want anyone mucking with mCurrent or
-     * mFull while we're copying out the buffer.
-     */
-    MutexAutoLock lock(mLock);
+  nsIConsoleMessage **messageArray;
 
-    if (mCurrent == 0 && !mFull) {
-        /*
-         * Make a 1-length output array so that nobody gets confused,
-         * and return a count of 0.  This should result in a 0-length
-         * array object when called from script.
-         */
-        messageArray = (nsIConsoleMessage **)
-            nsMemory::Alloc(sizeof (nsIConsoleMessage *));
-        *messageArray = nullptr;
-        *messages = messageArray;
-        *count = 0;
-
-        return NS_OK;
-    }
+  /*
+   * Lock the whole method, as we don't want anyone mucking with mCurrent or
+   * mFull while we're copying out the buffer.
+   */
+  MutexAutoLock lock(mLock);
 
-    uint32_t resultSize = mFull ? mBufferSize : mCurrent;
-    messageArray =
-        (nsIConsoleMessage **)nsMemory::Alloc((sizeof (nsIConsoleMessage *))
-                                              * resultSize);
-
-    if (messageArray == nullptr) {
-        *messages = nullptr;
-        *count = 0;
-        return NS_ERROR_FAILURE;
-    }
-
-    uint32_t i;
-    if (mFull) {
-        for (i = 0; i < mBufferSize; i++) {
-            // if full, fill the buffer starting from mCurrent (which'll be
-            // oldest) wrapping around the buffer to the most recent.
-            messageArray[i] = mMessages[(mCurrent + i) % mBufferSize];
-            NS_ADDREF(messageArray[i]);
-        }
-    } else {
-        for (i = 0; i < mCurrent; i++) {
-            messageArray[i] = mMessages[i];
-            NS_ADDREF(messageArray[i]);
-        }
-    }
-    *count = resultSize;
+  if (mCurrent == 0 && !mFull) {
+    /*
+     * Make a 1-length output array so that nobody gets confused,
+     * and return a count of 0.  This should result in a 0-length
+     * array object when called from script.
+     */
+    messageArray = (nsIConsoleMessage **)
+      nsMemory::Alloc(sizeof (nsIConsoleMessage *));
+    *messageArray = nullptr;
     *messages = messageArray;
+    *count = 0;
 
     return NS_OK;
+  }
+
+  uint32_t resultSize = mFull ? mBufferSize : mCurrent;
+  messageArray =
+    (nsIConsoleMessage **)nsMemory::Alloc((sizeof (nsIConsoleMessage *))
+                                          * resultSize);
+
+  if (messageArray == nullptr) {
+    *messages = nullptr;
+    *count = 0;
+    return NS_ERROR_FAILURE;
+  }
+
+  uint32_t i;
+  if (mFull) {
+    for (i = 0; i < mBufferSize; i++) {
+      // if full, fill the buffer starting from mCurrent (which'll be
+      // oldest) wrapping around the buffer to the most recent.
+      messageArray[i] = mMessages[(mCurrent + i) % mBufferSize];
+      NS_ADDREF(messageArray[i]);
+    }
+  } else {
+    for (i = 0; i < mCurrent; i++) {
+      messageArray[i] = mMessages[i];
+      NS_ADDREF(messageArray[i]);
+    }
+  }
+  *count = resultSize;
+  *messages = messageArray;
+
+  return NS_OK;
 }
 
 NS_IMETHODIMP
 nsConsoleService::RegisterListener(nsIConsoleListener *listener)
 {
-    if (!NS_IsMainThread()) {
-        NS_ERROR("nsConsoleService::RegisterListener is main thread only.");
-        return NS_ERROR_NOT_SAME_THREAD;
-    }
+  if (!NS_IsMainThread()) {
+    NS_ERROR("nsConsoleService::RegisterListener is main thread only.");
+    return NS_ERROR_NOT_SAME_THREAD;
+  }
 
-    nsCOMPtr<nsISupports> canonical = do_QueryInterface(listener);
+  nsCOMPtr<nsISupports> canonical = do_QueryInterface(listener);
 
-    MutexAutoLock lock(mLock);
-    if (mListeners.GetWeak(canonical)) {
-        // Reregistering a listener isn't good
-        return NS_ERROR_FAILURE;
-    }
-    mListeners.Put(canonical, listener);
-    return NS_OK;
+  MutexAutoLock lock(mLock);
+  if (mListeners.GetWeak(canonical)) {
+    // Reregistering a listener isn't good
+    return NS_ERROR_FAILURE;
+  }
+  mListeners.Put(canonical, listener);
+  return NS_OK;
 }
 
 NS_IMETHODIMP
 nsConsoleService::UnregisterListener(nsIConsoleListener *listener)
 {
-    if (!NS_IsMainThread()) {
-        NS_ERROR("nsConsoleService::UnregisterListener is main thread only.");
-        return NS_ERROR_NOT_SAME_THREAD;
-    }
+  if (!NS_IsMainThread()) {
+    NS_ERROR("nsConsoleService::UnregisterListener is main thread only.");
+    return NS_ERROR_NOT_SAME_THREAD;
+  }
 
-    nsCOMPtr<nsISupports> canonical = do_QueryInterface(listener);
+  nsCOMPtr<nsISupports> canonical = do_QueryInterface(listener);
 
-    MutexAutoLock lock(mLock);
+  MutexAutoLock lock(mLock);
 
-    if (!mListeners.GetWeak(canonical)) {
-        // Unregistering a listener that was never registered?
-        return NS_ERROR_FAILURE;
-    }
-    mListeners.Remove(canonical);
-    return NS_OK;
+  if (!mListeners.GetWeak(canonical)) {
+    // Unregistering a listener that was never registered?
+    return NS_ERROR_FAILURE;
+  }
+  mListeners.Remove(canonical);
+  return NS_OK;
 }
 
 NS_IMETHODIMP
 nsConsoleService::Reset()
 {
-    /*
-     * Make sure nobody trips into the buffer while it's being reset
-     */
-    MutexAutoLock lock(mLock);
+  /*
+   * Make sure nobody trips into the buffer while it's being reset
+   */
+  MutexAutoLock lock(mLock);
 
-    mCurrent = 0;
-    mFull = false;
+  mCurrent = 0;
+  mFull = false;
 
-    /*
-     * Free all messages stored so far (cf. destructor)
-     */
-    for (uint32_t i = 0; i < mBufferSize && mMessages[i] != nullptr; i++)
-        NS_RELEASE(mMessages[i]);
+  /*
+   * Free all messages stored so far (cf. destructor)
+   */
+  for (uint32_t i = 0; i < mBufferSize && mMessages[i] != nullptr; i++)
+    NS_RELEASE(mMessages[i]);
 
-    return NS_OK;
+  return NS_OK;
 }
--- a/xpcom/base/nsConsoleService.h
+++ b/xpcom/base/nsConsoleService.h
@@ -1,9 +1,10 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 /*
  * nsConsoleService class declaration.
  */
 
@@ -16,67 +17,67 @@
 #include "nsInterfaceHashtable.h"
 #include "nsHashKeys.h"
 
 #include "nsIConsoleService.h"
 
 class nsConsoleService MOZ_FINAL : public nsIConsoleService
 {
 public:
-    nsConsoleService();
-    nsresult Init();
+  nsConsoleService();
+  nsresult Init();
 
-    NS_DECL_THREADSAFE_ISUPPORTS
-    NS_DECL_NSICONSOLESERVICE
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSICONSOLESERVICE
 
-    void SetIsDelivering() {
-        MOZ_ASSERT(NS_IsMainThread());
-        MOZ_ASSERT(!mDeliveringMessage);
-        mDeliveringMessage = true;
-    }
+  void SetIsDelivering() {
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(!mDeliveringMessage);
+    mDeliveringMessage = true;
+  }
 
-    void SetDoneDelivering() {
-        MOZ_ASSERT(NS_IsMainThread());
-        MOZ_ASSERT(mDeliveringMessage);
-        mDeliveringMessage = false;
-    }
+  void SetDoneDelivering() {
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(mDeliveringMessage);
+    mDeliveringMessage = false;
+  }
 
-    // This is a variant of LogMessage which allows the caller to determine
-    // if the message should be output to an OS-specific log. This is used on
-    // B2G to control whether the message is logged to the android log or not.
+  // This is a variant of LogMessage which allows the caller to determine
+  // if the message should be output to an OS-specific log. This is used on
+  // B2G to control whether the message is logged to the android log or not.
 
-    enum OutputMode {
-        SuppressLog,
-        OutputToLog
-    };
-    virtual nsresult LogMessageWithMode(nsIConsoleMessage *message, OutputMode outputMode);
+  enum OutputMode {
+    SuppressLog,
+    OutputToLog
+  };
+  virtual nsresult LogMessageWithMode(nsIConsoleMessage *message, OutputMode outputMode);
 
-    typedef nsInterfaceHashtable<nsISupportsHashKey, nsIConsoleListener> ListenerHash;
-    void EnumerateListeners(ListenerHash::EnumReadFunction aFunction, void* aClosure);
+  typedef nsInterfaceHashtable<nsISupportsHashKey, nsIConsoleListener> ListenerHash;
+  void EnumerateListeners(ListenerHash::EnumReadFunction aFunction, void* aClosure);
 
 private:
-    ~nsConsoleService();
+  ~nsConsoleService();
 
-    // Circular buffer of saved messages
-    nsIConsoleMessage **mMessages;
+  // Circular buffer of saved messages
+  nsIConsoleMessage **mMessages;
 
-    // How big?
-    uint32_t mBufferSize;
+  // How big?
+  uint32_t mBufferSize;
 
-    // Index of slot in mMessages that'll be filled by *next* log message
-    uint32_t mCurrent;
+  // Index of slot in mMessages that'll be filled by *next* log message
+  uint32_t mCurrent;
 
-    // Is the buffer full? (Has mCurrent wrapped around at least once?)
-    bool mFull;
+  // Is the buffer full? (Has mCurrent wrapped around at least once?)
+  bool mFull;
 
-    // Are we currently delivering a console message on the main thread? If
-    // so, we suppress incoming messages on the main thread only, to avoid
-    // infinite repitition.
-    bool mDeliveringMessage;
+  // Are we currently delivering a console message on the main thread? If
+  // so, we suppress incoming messages on the main thread only, to avoid
+  // infinite repitition.
+  bool mDeliveringMessage;
 
-    // Listeners to notify whenever a new message is logged.
-    ListenerHash mListeners;
+  // Listeners to notify whenever a new message is logged.
+  ListenerHash mListeners;
 
-    // To serialize interesting methods.
-    mozilla::Mutex mLock;
+  // To serialize interesting methods.
+  mozilla::Mutex mLock;
 };
 
 #endif /* __nsconsoleservice_h__ */
--- a/xpcom/base/nsCrashOnException.cpp
+++ b/xpcom/base/nsCrashOnException.cpp
@@ -1,9 +1,10 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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 "nsCrashOnException.h"
 #include "nsCOMPtr.h"
 #include "nsServiceManagerUtils.h"
 
@@ -21,17 +22,17 @@ static int ReportException(EXCEPTION_POI
   if (cr)
     cr->WriteMinidumpForException(aExceptionInfo);
 #endif
   return EXCEPTION_EXECUTE_HANDLER;
 }
 
 XPCOM_API(LRESULT)
 CallWindowProcCrashProtected(WNDPROC wndProc, HWND hWnd, UINT msg,
-                            WPARAM wParam, LPARAM lParam)
+                             WPARAM wParam, LPARAM lParam)
 {
   MOZ_SEH_TRY {
     return wndProc(hWnd, msg, wParam, lParam);
   }
   MOZ_SEH_EXCEPT(ReportException(GetExceptionInformation())) {
     ::TerminateProcess(::GetCurrentProcess(), 253);
   }
   return 0; // not reached
--- a/xpcom/base/nsCrashOnException.h
+++ b/xpcom/base/nsCrashOnException.h
@@ -1,21 +1,22 @@
 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 #ifndef nsCrashOnException_h
 #define nsCrashOnException_h
 
 #include <nscore.h>
 #include <windows.h>
 
 namespace mozilla {
 
 // Call a given window procedure, and catch any Win32 exceptions raised from it,
 // and report them as crashes.
 XPCOM_API(LRESULT) CallWindowProcCrashProtected(WNDPROC wndProc, HWND hWnd, UINT msg,
-                                               WPARAM wParam, LPARAM lParam);
+                                                WPARAM wParam, LPARAM lParam);
 
 }
 
 #endif
--- a/xpcom/base/nsCycleCollector.cpp
+++ b/xpcom/base/nsCycleCollector.cpp
@@ -1,10 +1,10 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* vim: set ts=8 sts=4 et sw=4 tw=80: */
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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/. */
 
 //
 // This file implements a garbage-cycle collector based on the paper
 //
 //   Concurrent Cycle Collection in Reference Counted Systems
@@ -228,266 +228,266 @@ using namespace mozilla;
 // logs from MOZ_CC_LOG_ALL and MOZ_CC_LOG_SHUTDOWN, or other uses
 // of nsICycleCollectorListener)
 
 // Various parameters of this collector can be tuned using environment
 // variables.
 
 struct nsCycleCollectorParams
 {
-    bool mLogAll;
-    bool mLogShutdown;
-    bool mAllTracesAll;
-    bool mAllTracesShutdown;
-    bool mLogThisThread;
-
-    nsCycleCollectorParams() :
-        mLogAll      (PR_GetEnv("MOZ_CC_LOG_ALL") != nullptr),
-        mLogShutdown (PR_GetEnv("MOZ_CC_LOG_SHUTDOWN") != nullptr),
-        mAllTracesAll(false),
-        mAllTracesShutdown(false)
-    {
-        const char* logThreadEnv = PR_GetEnv("MOZ_CC_LOG_THREAD");
-        bool threadLogging = true;
-        if (logThreadEnv && !!strcmp(logThreadEnv, "all")) {
-            if (NS_IsMainThread()) {
-                threadLogging = !strcmp(logThreadEnv, "main");
-            } else {
-                threadLogging = !strcmp(logThreadEnv, "worker");
-            }
-        }
-
-        const char* logProcessEnv = PR_GetEnv("MOZ_CC_LOG_PROCESS");
-        bool processLogging = true;
-        if (logProcessEnv && !!strcmp(logProcessEnv, "all")) {
-            switch (XRE_GetProcessType()) {
-                case GeckoProcessType_Default:
-                    processLogging = !strcmp(logProcessEnv, "main");
-                    break;
-                case GeckoProcessType_Plugin:
-                    processLogging = !strcmp(logProcessEnv, "plugins");
-                    break;
-                case GeckoProcessType_Content:
-                    processLogging = !strcmp(logProcessEnv, "content");
-                    break;
-                default:
-                    processLogging = false;
-                    break;
-            }
-        }
-        mLogThisThread = threadLogging && processLogging;
-
-        const char* allTracesEnv = PR_GetEnv("MOZ_CC_ALL_TRACES");
-        if (allTracesEnv) {
-            if (!strcmp(allTracesEnv, "all")) {
-                mAllTracesAll = true;
-            } else if (!strcmp(allTracesEnv, "shutdown")) {
-                mAllTracesShutdown = true;
-            }
-        }
+  bool mLogAll;
+  bool mLogShutdown;
+  bool mAllTracesAll;
+  bool mAllTracesShutdown;
+  bool mLogThisThread;
+
+  nsCycleCollectorParams() :
+    mLogAll      (PR_GetEnv("MOZ_CC_LOG_ALL") != nullptr),
+    mLogShutdown (PR_GetEnv("MOZ_CC_LOG_SHUTDOWN") != nullptr),
+    mAllTracesAll(false),
+    mAllTracesShutdown(false)
+  {
+    const char* logThreadEnv = PR_GetEnv("MOZ_CC_LOG_THREAD");
+    bool threadLogging = true;
+    if (logThreadEnv && !!strcmp(logThreadEnv, "all")) {
+      if (NS_IsMainThread()) {
+        threadLogging = !strcmp(logThreadEnv, "main");
+      } else {
+        threadLogging = !strcmp(logThreadEnv, "worker");
+      }
     }
 
-    bool LogThisCC(bool aIsShutdown)
-    {
-        return (mLogAll || (aIsShutdown && mLogShutdown)) && mLogThisThread;
+    const char* logProcessEnv = PR_GetEnv("MOZ_CC_LOG_PROCESS");
+    bool processLogging = true;
+    if (logProcessEnv && !!strcmp(logProcessEnv, "all")) {
+      switch (XRE_GetProcessType()) {
+        case GeckoProcessType_Default:
+          processLogging = !strcmp(logProcessEnv, "main");
+          break;
+        case GeckoProcessType_Plugin:
+          processLogging = !strcmp(logProcessEnv, "plugins");
+          break;
+        case GeckoProcessType_Content:
+          processLogging = !strcmp(logProcessEnv, "content");
+          break;
+        default:
+          processLogging = false;
+          break;
+      }
     }
-
-    bool AllTracesThisCC(bool aIsShutdown)
-    {
-        return mAllTracesAll || (aIsShutdown && mAllTracesShutdown);
+    mLogThisThread = threadLogging && processLogging;
+
+    const char* allTracesEnv = PR_GetEnv("MOZ_CC_ALL_TRACES");
+    if (allTracesEnv) {
+      if (!strcmp(allTracesEnv, "all")) {
+        mAllTracesAll = true;
+      } else if (!strcmp(allTracesEnv, "shutdown")) {
+        mAllTracesShutdown = true;
+      }
     }
+  }
+
+  bool LogThisCC(bool aIsShutdown)
+  {
+    return (mLogAll || (aIsShutdown && mLogShutdown)) && mLogThisThread;
+  }
+
+  bool AllTracesThisCC(bool aIsShutdown)
+  {
+    return mAllTracesAll || (aIsShutdown && mAllTracesShutdown);
+  }
 };
 
 #ifdef COLLECT_TIME_DEBUG
 class TimeLog
 {
 public:
-    TimeLog() : mLastCheckpoint(TimeStamp::Now()) {}
-
-    void
-    Checkpoint(const char* aEvent)
-    {
-        TimeStamp now = TimeStamp::Now();
-        uint32_t dur = (uint32_t) ((now - mLastCheckpoint).ToMilliseconds());
-        if (dur > 0) {
-            printf("cc: %s took %dms\n", aEvent, dur);
-        }
-        mLastCheckpoint = now;
+  TimeLog() : mLastCheckpoint(TimeStamp::Now()) {}
+
+  void
+  Checkpoint(const char* aEvent)
+  {
+    TimeStamp now = TimeStamp::Now();
+    uint32_t dur = (uint32_t) ((now - mLastCheckpoint).ToMilliseconds());
+    if (dur > 0) {
+      printf("cc: %s took %dms\n", aEvent, dur);
     }
+    mLastCheckpoint = now;
+  }
 
 private:
-    TimeStamp mLastCheckpoint;
+  TimeStamp mLastCheckpoint;
 };
 #else
 class TimeLog
 {
 public:
-    TimeLog() {}
-    void Checkpoint(const char* aEvent) {}
+  TimeLog() {}
+  void Checkpoint(const char* aEvent) {}
 };
 #endif
 
 
 ////////////////////////////////////////////////////////////////////////
 // Base types
 ////////////////////////////////////////////////////////////////////////
 
 struct PtrInfo;
 
 class EdgePool
 {
 public:
-    // EdgePool allocates arrays of void*, primarily to hold PtrInfo*.
-    // However, at the end of a block, the last two pointers are a null
-    // and then a void** pointing to the next block.  This allows
-    // EdgePool::Iterators to be a single word but still capable of crossing
-    // block boundaries.
-
-    EdgePool()
-    {
-        mSentinelAndBlocks[0].block = nullptr;
-        mSentinelAndBlocks[1].block = nullptr;
+  // EdgePool allocates arrays of void*, primarily to hold PtrInfo*.
+  // However, at the end of a block, the last two pointers are a null
+  // and then a void** pointing to the next block.  This allows
+  // EdgePool::Iterators to be a single word but still capable of crossing
+  // block boundaries.
+
+  EdgePool()
+  {
+    mSentinelAndBlocks[0].block = nullptr;
+    mSentinelAndBlocks[1].block = nullptr;
+  }
+
+  ~EdgePool()
+  {
+    MOZ_ASSERT(!mSentinelAndBlocks[0].block &&
+               !mSentinelAndBlocks[1].block,
+               "Didn't call Clear()?");
+  }
+
+  void Clear()
+  {
+    Block *b = Blocks();
+    while (b) {
+      Block *next = b->Next();
+      delete b;
+      b = next;
     }
 
-    ~EdgePool()
-    {
-        MOZ_ASSERT(!mSentinelAndBlocks[0].block &&
-                   !mSentinelAndBlocks[1].block,
-                   "Didn't call Clear()?");
-    }
-
-    void Clear()
-    {
-        Block *b = Blocks();
-        while (b) {
-            Block *next = b->Next();
-            delete b;
-            b = next;
-        }
-
-        mSentinelAndBlocks[0].block = nullptr;
-        mSentinelAndBlocks[1].block = nullptr;
-    }
+    mSentinelAndBlocks[0].block = nullptr;
+    mSentinelAndBlocks[1].block = nullptr;
+  }
 
 #ifdef DEBUG
-    bool IsEmpty()
-    {
-        return !mSentinelAndBlocks[0].block &&
-               !mSentinelAndBlocks[1].block;
-    }
+  bool IsEmpty()
+  {
+    return !mSentinelAndBlocks[0].block &&
+           !mSentinelAndBlocks[1].block;
+  }
 #endif
 
 private:
-    struct Block;
-    union PtrInfoOrBlock {
-        // Use a union to avoid reinterpret_cast and the ensuing
-        // potential aliasing bugs.
-        PtrInfo *ptrInfo;
-        Block *block;
-    };
-    struct Block {
-        enum { BlockSize = 16 * 1024 };
-
-        PtrInfoOrBlock mPointers[BlockSize];
-        Block() {
-            mPointers[BlockSize - 2].block = nullptr; // sentinel
-            mPointers[BlockSize - 1].block = nullptr; // next block pointer
-        }
-        Block*& Next()          { return mPointers[BlockSize - 1].block; }
-        PtrInfoOrBlock* Start() { return &mPointers[0]; }
-        PtrInfoOrBlock* End()   { return &mPointers[BlockSize - 2]; }
-    };
-
-    // Store the null sentinel so that we can have valid iterators
-    // before adding any edges and without adding any blocks.
-    PtrInfoOrBlock mSentinelAndBlocks[2];
-
-    Block*& Blocks()       { return mSentinelAndBlocks[1].block; }
-    Block*  Blocks() const { return mSentinelAndBlocks[1].block; }
+  struct Block;
+  union PtrInfoOrBlock {
+    // Use a union to avoid reinterpret_cast and the ensuing
+    // potential aliasing bugs.
+    PtrInfo *ptrInfo;
+    Block *block;
+  };
+  struct Block {
+    enum { BlockSize = 16 * 1024 };
+
+    PtrInfoOrBlock mPointers[BlockSize];
+    Block() {
+      mPointers[BlockSize - 2].block = nullptr; // sentinel
+      mPointers[BlockSize - 1].block = nullptr; // next block pointer
+    }
+    Block*& Next()          { return mPointers[BlockSize - 1].block; }
+    PtrInfoOrBlock* Start() { return &mPointers[0]; }
+    PtrInfoOrBlock* End()   { return &mPointers[BlockSize - 2]; }
+  };
+
+  // Store the null sentinel so that we can have valid iterators
+  // before adding any edges and without adding any blocks.
+  PtrInfoOrBlock mSentinelAndBlocks[2];
+
+  Block*& Blocks()       { return mSentinelAndBlocks[1].block; }
+  Block*  Blocks() const { return mSentinelAndBlocks[1].block; }
 
 public:
-    class Iterator
+  class Iterator
+  {
+  public:
+    Iterator() : mPointer(nullptr) {}
+    Iterator(PtrInfoOrBlock *aPointer) : mPointer(aPointer) {}
+    Iterator(const Iterator& aOther) : mPointer(aOther.mPointer) {}
+
+    Iterator& operator++()
     {
-    public:
-        Iterator() : mPointer(nullptr) {}
-        Iterator(PtrInfoOrBlock *aPointer) : mPointer(aPointer) {}
-        Iterator(const Iterator& aOther) : mPointer(aOther.mPointer) {}
-
-        Iterator& operator++()
-        {
-            if (mPointer->ptrInfo == nullptr) {
-                // Null pointer is a sentinel for link to the next block.
-                mPointer = (mPointer + 1)->block->mPointers;
-            }
-            ++mPointer;
-            return *this;
-        }
-
-        PtrInfo* operator*() const
-        {
-            if (mPointer->ptrInfo == nullptr) {
-                // Null pointer is a sentinel for link to the next block.
-                return (mPointer + 1)->block->mPointers->ptrInfo;
-            }
-            return mPointer->ptrInfo;
-        }
-        bool operator==(const Iterator& aOther) const
-            { return mPointer == aOther.mPointer; }
-        bool operator!=(const Iterator& aOther) const
-            { return mPointer != aOther.mPointer; }
+      if (mPointer->ptrInfo == nullptr) {
+        // Null pointer is a sentinel for link to the next block.
+        mPointer = (mPointer + 1)->block->mPointers;
+      }
+      ++mPointer;
+      return *this;
+    }
+
+    PtrInfo* operator*() const
+    {
+      if (mPointer->ptrInfo == nullptr) {
+        // Null pointer is a sentinel for link to the next block.
+        return (mPointer + 1)->block->mPointers->ptrInfo;
+      }
+      return mPointer->ptrInfo;
+    }
+    bool operator==(const Iterator& aOther) const
+    { return mPointer == aOther.mPointer; }
+    bool operator!=(const Iterator& aOther) const
+    { return mPointer != aOther.mPointer; }
 
 #ifdef DEBUG_CC_GRAPH
-        bool Initialized() const
-        {
-            return mPointer != nullptr;
-        }
+    bool Initialized() const
+    {
+      return mPointer != nullptr;
+    }
 #endif
 
-    private:
-        PtrInfoOrBlock *mPointer;
-    };
-
-    class Builder;
-    friend class Builder;
-    class Builder {
-    public:
-        Builder(EdgePool &aPool)
-            : mCurrent(&aPool.mSentinelAndBlocks[0]),
-              mBlockEnd(&aPool.mSentinelAndBlocks[0]),
-              mNextBlockPtr(&aPool.Blocks())
-        {
-        }
-
-        Iterator Mark() { return Iterator(mCurrent); }
-
-        void Add(PtrInfo* aEdge) {
-            if (mCurrent == mBlockEnd) {
-                Block *b = new Block();
-                *mNextBlockPtr = b;
-                mCurrent = b->Start();
-                mBlockEnd = b->End();
-                mNextBlockPtr = &b->Next();
-            }
-            (mCurrent++)->ptrInfo = aEdge;
-        }
-    private:
-        // mBlockEnd points to space for null sentinel
-        PtrInfoOrBlock *mCurrent, *mBlockEnd;
-        Block **mNextBlockPtr;
-    };
-
-    size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
-        size_t n = 0;
-        Block *b = Blocks();
-        while (b) {
-            n += aMallocSizeOf(b);
-            b = b->Next();
-        }
-        return n;
+  private:
+    PtrInfoOrBlock *mPointer;
+  };
+
+  class Builder;
+  friend class Builder;
+  class Builder {
+  public:
+    Builder(EdgePool &aPool)
+      : mCurrent(&aPool.mSentinelAndBlocks[0]),
+        mBlockEnd(&aPool.mSentinelAndBlocks[0]),
+        mNextBlockPtr(&aPool.Blocks())
+    {
     }
+
+    Iterator Mark() { return Iterator(mCurrent); }
+
+    void Add(PtrInfo* aEdge) {
+      if (mCurrent == mBlockEnd) {
+        Block *b = new Block();
+        *mNextBlockPtr = b;
+        mCurrent = b->Start();
+        mBlockEnd = b->End();
+        mNextBlockPtr = &b->Next();
+      }
+      (mCurrent++)->ptrInfo = aEdge;
+    }
+  private:
+    // mBlockEnd points to space for null sentinel
+    PtrInfoOrBlock *mCurrent, *mBlockEnd;
+    Block **mNextBlockPtr;
+  };
+
+  size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
+    size_t n = 0;
+    Block *b = Blocks();
+    while (b) {
+      n += aMallocSizeOf(b);
+      b = b->Next();
+    }
+    return n;
+  }
 };
 
 #ifdef DEBUG_CC_GRAPH
 #define CC_GRAPH_ASSERT(b) MOZ_ASSERT(b)
 #else
 #define CC_GRAPH_ASSERT(b)
 #endif
 
@@ -503,383 +503,383 @@ public:
 enum NodeColor { black, white, grey };
 
 // This structure should be kept as small as possible; we may expect
 // hundreds of thousands of them to be allocated and touched
 // repeatedly during each cycle collection.
 
 struct PtrInfo
 {
-    void *mPointer;
-    nsCycleCollectionParticipant *mParticipant;
-    uint32_t mColor : 2;
-    uint32_t mInternalRefs : 30;
-    uint32_t mRefCount;
+  void *mPointer;
+  nsCycleCollectionParticipant *mParticipant;
+  uint32_t mColor : 2;
+  uint32_t mInternalRefs : 30;
+  uint32_t mRefCount;
 private:
-    EdgePool::Iterator mFirstChild;
+  EdgePool::Iterator mFirstChild;
 
 public:
 
-    PtrInfo(void *aPointer, nsCycleCollectionParticipant *aParticipant)
-        : mPointer(aPointer),
-          mParticipant(aParticipant),
-          mColor(grey),
-          mInternalRefs(0),
-          mRefCount(UINT32_MAX - 1),
-          mFirstChild()
-    {
-        // We initialize mRefCount to a large non-zero value so
-        // that it doesn't look like a JS object to the cycle collector
-        // in the case where the object dies before being traversed.
-
-        MOZ_ASSERT(aParticipant);
-    }
-
-    // Allow NodePool::Block's constructor to compile.
-    PtrInfo() {
-        NS_NOTREACHED("should never be called");
-    }
-
-    EdgePool::Iterator FirstChild()
-    {
-        CC_GRAPH_ASSERT(mFirstChild.Initialized());
-        return mFirstChild;
-    }
-
-    // this PtrInfo must be part of a NodePool
-    EdgePool::Iterator LastChild()
-    {
-        CC_GRAPH_ASSERT((this + 1)->mFirstChild.Initialized());
-        return (this + 1)->mFirstChild;
-    }
-
-    void SetFirstChild(EdgePool::Iterator aFirstChild)
-    {
-        CC_GRAPH_ASSERT(aFirstChild.Initialized());
-        mFirstChild = aFirstChild;
-    }
-
-    // this PtrInfo must be part of a NodePool
-    void SetLastChild(EdgePool::Iterator aLastChild)
-    {
-        CC_GRAPH_ASSERT(aLastChild.Initialized());
-        (this + 1)->mFirstChild = aLastChild;
-    }
+  PtrInfo(void *aPointer, nsCycleCollectionParticipant *aParticipant)
+    : mPointer(aPointer),
+      mParticipant(aParticipant),
+      mColor(grey),
+      mInternalRefs(0),
+      mRefCount(UINT32_MAX - 1),
+      mFirstChild()
+  {
+    // We initialize mRefCount to a large non-zero value so
+    // that it doesn't look like a JS object to the cycle collector
+    // in the case where the object dies before being traversed.
+
+    MOZ_ASSERT(aParticipant);
+  }
+
+  // Allow NodePool::Block's constructor to compile.
+  PtrInfo() {
+    NS_NOTREACHED("should never be called");
+  }
+
+  EdgePool::Iterator FirstChild()
+  {
+    CC_GRAPH_ASSERT(mFirstChild.Initialized());
+    return mFirstChild;
+  }
+
+  // this PtrInfo must be part of a NodePool
+  EdgePool::Iterator LastChild()
+  {
+    CC_GRAPH_ASSERT((this + 1)->mFirstChild.Initialized());
+    return (this + 1)->mFirstChild;
+  }
+
+  void SetFirstChild(EdgePool::Iterator aFirstChild)
+  {
+    CC_GRAPH_ASSERT(aFirstChild.Initialized());
+    mFirstChild = aFirstChild;
+  }
+
+  // this PtrInfo must be part of a NodePool
+  void SetLastChild(EdgePool::Iterator aLastChild)
+  {
+    CC_GRAPH_ASSERT(aLastChild.Initialized());
+    (this + 1)->mFirstChild = aLastChild;
+  }
 };
 
 /**
  * A structure designed to be used like a linked list of PtrInfo, except
  * that allocates the PtrInfo 32K-at-a-time.
  */
 class NodePool
 {
 private:
-    enum { BlockSize = 8 * 1024 }; // could be int template parameter
-
-    struct Block {
-        // We create and destroy Block using NS_Alloc/NS_Free rather
-        // than new and delete to avoid calling its constructor and
-        // destructor.
-        Block()  { NS_NOTREACHED("should never be called"); }
-        ~Block() { NS_NOTREACHED("should never be called"); }
-
-        Block* mNext;
-        PtrInfo mEntries[BlockSize + 1]; // +1 to store last child of last node
-    };
+  enum { BlockSize = 8 * 1024 }; // could be int template parameter
+
+  struct Block {
+    // We create and destroy Block using NS_Alloc/NS_Free rather
+    // than new and delete to avoid calling its constructor and
+    // destructor.
+    Block()  { NS_NOTREACHED("should never be called"); }
+    ~Block() { NS_NOTREACHED("should never be called"); }
+
+    Block* mNext;
+    PtrInfo mEntries[BlockSize + 1]; // +1 to store last child of last node
+  };
 
 public:
-    NodePool()
-        : mBlocks(nullptr),
-          mLast(nullptr)
-    {
-    }
-
-    ~NodePool()
-    {
-        MOZ_ASSERT(!mBlocks, "Didn't call Clear()?");
+  NodePool()
+    : mBlocks(nullptr),
+      mLast(nullptr)
+  {
+  }
+
+  ~NodePool()
+  {
+    MOZ_ASSERT(!mBlocks, "Didn't call Clear()?");
+  }
+
+  void Clear()
+  {
+    Block *b = mBlocks;
+    while (b) {
+      Block *n = b->mNext;
+      NS_Free(b);
+      b = n;
     }
 
-    void Clear()
-    {
-        Block *b = mBlocks;
-        while (b) {
-            Block *n = b->mNext;
-            NS_Free(b);
-            b = n;
-        }
-
-        mBlocks = nullptr;
-        mLast = nullptr;
-    }
+    mBlocks = nullptr;
+    mLast = nullptr;
+  }
 
 #ifdef DEBUG
-    bool IsEmpty()
-    {
-        return !mBlocks && !mLast;
-    }
+  bool IsEmpty()
+  {
+    return !mBlocks && !mLast;
+  }
 #endif
 
-    class Builder;
-    friend class Builder;
-    class Builder {
-    public:
-        Builder(NodePool& aPool)
-            : mNextBlock(&aPool.mBlocks),
-              mNext(aPool.mLast),
-              mBlockEnd(nullptr)
-        {
-            MOZ_ASSERT(aPool.mBlocks == nullptr && aPool.mLast == nullptr,
-                       "pool not empty");
-        }
-        PtrInfo *Add(void *aPointer, nsCycleCollectionParticipant *aParticipant)
-        {
-            if (mNext == mBlockEnd) {
-                Block *block = static_cast<Block*>(NS_Alloc(sizeof(Block)));
-                *mNextBlock = block;
-                mNext = block->mEntries;
-                mBlockEnd = block->mEntries + BlockSize;
-                block->mNext = nullptr;
-                mNextBlock = &block->mNext;
-            }
-            return new (mNext++) PtrInfo(aPointer, aParticipant);
-        }
-    private:
-        Block **mNextBlock;
-        PtrInfo *&mNext;
-        PtrInfo *mBlockEnd;
-    };
-
-    class Enumerator;
-    friend class Enumerator;
-    class Enumerator {
-    public:
-        Enumerator(NodePool& aPool)
-            : mFirstBlock(aPool.mBlocks),
-              mCurBlock(nullptr),
-              mNext(nullptr),
-              mBlockEnd(nullptr),
-              mLast(aPool.mLast)
-        {
-        }
-
-        bool IsDone() const
-        {
-            return mNext == mLast;
-        }
-
-        bool AtBlockEnd() const
-        {
-            return mNext == mBlockEnd;
-        }
-
-        PtrInfo* GetNext()
-        {
-            MOZ_ASSERT(!IsDone(), "calling GetNext when done");
-            if (mNext == mBlockEnd) {
-                Block *nextBlock = mCurBlock ? mCurBlock->mNext : mFirstBlock;
-                mNext = nextBlock->mEntries;
-                mBlockEnd = mNext + BlockSize;
-                mCurBlock = nextBlock;
-            }
-            return mNext++;
-        }
-    private:
-        // mFirstBlock is a reference to allow an Enumerator to be constructed
-        // for an empty graph.
-        Block *&mFirstBlock;
-        Block *mCurBlock;
-        // mNext is the next value we want to return, unless mNext == mBlockEnd
-        // NB: mLast is a reference to allow enumerating while building!
-        PtrInfo *mNext, *mBlockEnd, *&mLast;
-    };
-
-    size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
-        // We don't measure the things pointed to by mEntries[] because those
-        // pointers are non-owning.
-        size_t n = 0;
-        Block *b = mBlocks;
-        while (b) {
-            n += aMallocSizeOf(b);
-            b = b->mNext;
-        }
-        return n;
+  class Builder;
+  friend class Builder;
+  class Builder {
+  public:
+    Builder(NodePool& aPool)
+      : mNextBlock(&aPool.mBlocks),
+        mNext(aPool.mLast),
+        mBlockEnd(nullptr)
+    {
+      MOZ_ASSERT(aPool.mBlocks == nullptr && aPool.mLast == nullptr,
+                 "pool not empty");
+    }
+    PtrInfo *Add(void *aPointer, nsCycleCollectionParticipant *aParticipant)
+    {
+      if (mNext == mBlockEnd) {
+        Block *block = static_cast<Block*>(NS_Alloc(sizeof(Block)));
+        *mNextBlock = block;
+        mNext = block->mEntries;
+        mBlockEnd = block->mEntries + BlockSize;
+        block->mNext = nullptr;
+        mNextBlock = &block->mNext;
+      }
+      return new (mNext++) PtrInfo(aPointer, aParticipant);
+    }
+  private:
+    Block **mNextBlock;
+    PtrInfo *&mNext;
+    PtrInfo *mBlockEnd;
+  };
+
+  class Enumerator;
+  friend class Enumerator;
+  class Enumerator {
+  public:
+    Enumerator(NodePool& aPool)
+      : mFirstBlock(aPool.mBlocks),
+        mCurBlock(nullptr),
+        mNext(nullptr),
+        mBlockEnd(nullptr),
+        mLast(aPool.mLast)
+    {
     }
 
+    bool IsDone() const
+    {
+      return mNext == mLast;
+    }
+
+    bool AtBlockEnd() const
+    {
+      return mNext == mBlockEnd;
+    }
+
+    PtrInfo* GetNext()
+    {
+      MOZ_ASSERT(!IsDone(), "calling GetNext when done");
+      if (mNext == mBlockEnd) {
+        Block *nextBlock = mCurBlock ? mCurBlock->mNext : mFirstBlock;
+        mNext = nextBlock->mEntries;
+        mBlockEnd = mNext + BlockSize;
+        mCurBlock = nextBlock;
+      }
+      return mNext++;
+    }
+  private:
+    // mFirstBlock is a reference to allow an Enumerator to be constructed
+    // for an empty graph.
+    Block *&mFirstBlock;
+    Block *mCurBlock;
+    // mNext is the next value we want to return, unless mNext == mBlockEnd
+    // NB: mLast is a reference to allow enumerating while building!
+    PtrInfo *mNext, *mBlockEnd, *&mLast;
+  };
+
+  size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
+    // We don't measure the things pointed to by mEntries[] because those
+    // pointers are non-owning.
+    size_t n = 0;
+    Block *b = mBlocks;
+    while (b) {
+      n += aMallocSizeOf(b);
+      b = b->mNext;
+    }
+    return n;
+  }
+
 private:
-    Block *mBlocks;
-    PtrInfo *mLast;
+  Block *mBlocks;
+  PtrInfo *mLast;
 };
 
 
 // Declarations for mPtrToNodeMap.
 
 struct PtrToNodeEntry : public PLDHashEntryHdr
 {
-    // The key is mNode->mPointer
-    PtrInfo *mNode;
+  // The key is mNode->mPointer
+  PtrInfo *mNode;
 };
 
 static bool
 PtrToNodeMatchEntry(PLDHashTable *table,
                     const PLDHashEntryHdr *entry,
                     const void *key)
 {
-    const PtrToNodeEntry *n = static_cast<const PtrToNodeEntry*>(entry);
-    return n->mNode->mPointer == key;
+  const PtrToNodeEntry *n = static_cast<const PtrToNodeEntry*>(entry);
+  return n->mNode->mPointer == key;
 }
 
 static PLDHashTableOps PtrNodeOps = {
-    PL_DHashAllocTable,
-    PL_DHashFreeTable,
-    PL_DHashVoidPtrKeyStub,
-    PtrToNodeMatchEntry,
-    PL_DHashMoveEntryStub,
-    PL_DHashClearEntryStub,
-    PL_DHashFinalizeStub,
-    nullptr
+  PL_DHashAllocTable,
+  PL_DHashFreeTable,
+  PL_DHashVoidPtrKeyStub,
+  PtrToNodeMatchEntry,
+  PL_DHashMoveEntryStub,
+  PL_DHashClearEntryStub,
+  PL_DHashFinalizeStub,
+  nullptr
 };
 
 
 struct WeakMapping
 {
-    // map and key will be null if the corresponding objects are GC marked
-    PtrInfo *mMap;
-    PtrInfo *mKey;
-    PtrInfo *mKeyDelegate;
-    PtrInfo *mVal;
+  // map and key will be null if the corresponding objects are GC marked
+  PtrInfo *mMap;
+  PtrInfo *mKey;
+  PtrInfo *mKeyDelegate;
+  PtrInfo *mVal;
 };
 
 class GCGraphBuilder;
 
 struct GCGraph
 {
-    NodePool mNodes;
-    EdgePool mEdges;
-    nsTArray<WeakMapping> mWeakMaps;
-    uint32_t mRootCount;
+  NodePool mNodes;
+  EdgePool mEdges;
+  nsTArray<WeakMapping> mWeakMaps;
+  uint32_t mRootCount;
 
 private:
-    PLDHashTable mPtrToNodeMap;
+  PLDHashTable mPtrToNodeMap;
 
 public:
-    GCGraph() : mRootCount(0)
-    {
-        mPtrToNodeMap.ops = nullptr;
-    }
-
-    ~GCGraph()
-    {
-        if (mPtrToNodeMap.ops) {
-            PL_DHashTableFinish(&mPtrToNodeMap);
-        }
+  GCGraph() : mRootCount(0)
+  {
+    mPtrToNodeMap.ops = nullptr;
+  }
+
+  ~GCGraph()
+  {
+    if (mPtrToNodeMap.ops) {
+      PL_DHashTableFinish(&mPtrToNodeMap);
     }
-
-    void Init()
-    {
-        MOZ_ASSERT(IsEmpty(), "Failed to call GCGraph::Clear");
-        PL_DHashTableInit(&mPtrToNodeMap, &PtrNodeOps, nullptr,
-                          sizeof(PtrToNodeEntry), 32768);
-    }
-
-    void Clear()
-    {
-        mNodes.Clear();
-        mEdges.Clear();
-        mWeakMaps.Clear();
-        mRootCount = 0;
-        PL_DHashTableFinish(&mPtrToNodeMap);
-        mPtrToNodeMap.ops = nullptr;
-    }
+  }
+
+  void Init()
+  {
+    MOZ_ASSERT(IsEmpty(), "Failed to call GCGraph::Clear");
+    PL_DHashTableInit(&mPtrToNodeMap, &PtrNodeOps, nullptr,
+                      sizeof(PtrToNodeEntry), 32768);
+  }
+
+  void Clear()
+  {
+    mNodes.Clear();
+    mEdges.Clear();
+    mWeakMaps.Clear();
+    mRootCount = 0;
+    PL_DHashTableFinish(&mPtrToNodeMap);
+    mPtrToNodeMap.ops = nullptr;
+  }
 
 #ifdef DEBUG
-    bool IsEmpty()
-    {
-        return mNodes.IsEmpty() && mEdges.IsEmpty() &&
-            mWeakMaps.IsEmpty() && mRootCount == 0 &&
-            !mPtrToNodeMap.ops;
-    }
+  bool IsEmpty()
+  {
+    return mNodes.IsEmpty() && mEdges.IsEmpty() &&
+           mWeakMaps.IsEmpty() && mRootCount == 0 &&
+           !mPtrToNodeMap.ops;
+  }
 #endif
 
-    PtrInfo* FindNode(void *aPtr);
-    PtrToNodeEntry* AddNodeToMap(void *aPtr);
-    void RemoveNodeFromMap(void *aPtr);
-
-    uint32_t MapCount() const
-    {
-        return mPtrToNodeMap.entryCount;
-    }
-
-    void SizeOfExcludingThis(MallocSizeOf aMallocSizeOf,
-                             size_t *aNodesSize, size_t *aEdgesSize,
-                             size_t *aWeakMapsSize) const {
-        *aNodesSize = mNodes.SizeOfExcludingThis(aMallocSizeOf);
-        *aEdgesSize = mEdges.SizeOfExcludingThis(aMallocSizeOf);
-
-        // We don't measure what the WeakMappings point to, because the
-        // pointers are non-owning.
-        *aWeakMapsSize = mWeakMaps.SizeOfExcludingThis(aMallocSizeOf);
-    }
+  PtrInfo* FindNode(void *aPtr);
+  PtrToNodeEntry* AddNodeToMap(void *aPtr);
+  void RemoveNodeFromMap(void *aPtr);
+
+  uint32_t MapCount() const
+  {
+    return mPtrToNodeMap.entryCount;
+  }
+
+  void SizeOfExcludingThis(MallocSizeOf aMallocSizeOf,
+                           size_t *aNodesSize, size_t *aEdgesSize,
+                           size_t *aWeakMapsSize) const {
+    *aNodesSize = mNodes.SizeOfExcludingThis(aMallocSizeOf);
+    *aEdgesSize = mEdges.SizeOfExcludingThis(aMallocSizeOf);
+
+    // We don't measure what the WeakMappings point to, because the
+    // pointers are non-owning.
+    *aWeakMapsSize = mWeakMaps.SizeOfExcludingThis(aMallocSizeOf);
+  }
 };
 
 PtrInfo*
 GCGraph::FindNode(void *aPtr)
 {
-    PtrToNodeEntry *e = static_cast<PtrToNodeEntry*>(PL_DHashTableOperate(&mPtrToNodeMap, aPtr, PL_DHASH_LOOKUP));
-    if (!PL_DHASH_ENTRY_IS_BUSY(e)) {
-        return nullptr;
-    }
-    return e->mNode;
+  PtrToNodeEntry *e = static_cast<PtrToNodeEntry*>(PL_DHashTableOperate(&mPtrToNodeMap, aPtr, PL_DHASH_LOOKUP));
+  if (!PL_DHASH_ENTRY_IS_BUSY(e)) {
+    return nullptr;
+  }
+  return e->mNode;
 }
 
 PtrToNodeEntry*
 GCGraph::AddNodeToMap(void *aPtr)
 {
-    PtrToNodeEntry *e = static_cast<PtrToNodeEntry*>(PL_DHashTableOperate(&mPtrToNodeMap, aPtr, PL_DHASH_ADD));
-    if (!e) {
-        // Caller should track OOMs
-        return nullptr;
-    }
-    return e;
+  PtrToNodeEntry *e = static_cast<PtrToNodeEntry*>(PL_DHashTableOperate(&mPtrToNodeMap, aPtr, PL_DHASH_ADD));
+  if (!e) {
+    // Caller should track OOMs
+    return nullptr;
+  }
+  return e;
 }
 
 void
 GCGraph::RemoveNodeFromMap(void *aPtr)
 {
-    PL_DHashTableOperate(&mPtrToNodeMap, aPtr, PL_DHASH_REMOVE);
+  PL_DHashTableOperate(&mPtrToNodeMap, aPtr, PL_DHASH_REMOVE);
 }
 
 
 static nsISupports *
 CanonicalizeXPCOMParticipant(nsISupports *in)
 {
-    nsISupports* out;
-    in->QueryInterface(NS_GET_IID(nsCycleCollectionISupports),
-                       reinterpret_cast<void**>(&out));
-    return out;
+  nsISupports* out;
+  in->QueryInterface(NS_GET_IID(nsCycleCollectionISupports),
+                     reinterpret_cast<void**>(&out));
+  return out;
 }
 
 static inline void
 ToParticipant(nsISupports *s, nsXPCOMCycleCollectionParticipant **cp);
 
 static void
 CanonicalizeParticipant(void **parti, nsCycleCollectionParticipant **cp)
 {
-    // If the participant is null, this is an nsISupports participant,
-    // so we must QI to get the real participant.
-
-    if (!*cp) {
-        nsISupports *nsparti = static_cast<nsISupports*>(*parti);
-        nsparti = CanonicalizeXPCOMParticipant(nsparti);
-        NS_ASSERTION(nsparti,
-                     "Don't add objects that don't participate in collection!");
-        nsXPCOMCycleCollectionParticipant *xcp;
-        ToParticipant(nsparti, &xcp);
-        *parti = nsparti;
-        *cp = xcp;
-    }
+  // If the participant is null, this is an nsISupports participant,
+  // so we must QI to get the real participant.
+
+  if (!*cp) {
+    nsISupports *nsparti = static_cast<nsISupports*>(*parti);
+    nsparti = CanonicalizeXPCOMParticipant(nsparti);
+    NS_ASSERTION(nsparti,
+                 "Don't add objects that don't participate in collection!");
+    nsXPCOMCycleCollectionParticipant *xcp;
+    ToParticipant(nsparti, &xcp);
+    *parti = nsparti;
+    *cp = xcp;
+  }
 }
 
 struct nsPurpleBufferEntry {
   union {
     void *mObject;                        // when low bit unset
     nsPurpleBufferEntry *mNextInFreeList; // when low bit set
   };
 
@@ -888,406 +888,406 @@ struct nsPurpleBufferEntry {
   nsCycleCollectionParticipant *mParticipant; // nullptr for nsISupports
 };
 
 class nsCycleCollector;
 
 struct nsPurpleBuffer
 {
 private:
-    struct Block {
-        Block *mNext;
-        // Try to match the size of a jemalloc bucket, to minimize slop bytes.
-        // - On 32-bit platforms sizeof(nsPurpleBufferEntry) is 12, so mEntries
-        //   is 16,380 bytes, which leaves 4 bytes for mNext.
-        // - On 64-bit platforms sizeof(nsPurpleBufferEntry) is 24, so mEntries
-        //   is 32,544 bytes, which leaves 8 bytes for mNext.
-        nsPurpleBufferEntry mEntries[1365];
-
-        Block() : mNext(nullptr) {
-            // Ensure Block is the right size (see above).
-            static_assert(
-                sizeof(Block) == 16384 ||       // 32-bit
-                sizeof(Block) == 32768,         // 64-bit
-                "ill-sized nsPurpleBuffer::Block"
-            );
-        }
-
-        template <class PurpleVisitor>
-        void VisitEntries(nsPurpleBuffer &aBuffer, PurpleVisitor &aVisitor)
-        {
-            nsPurpleBufferEntry *eEnd = ArrayEnd(mEntries);
-            for (nsPurpleBufferEntry *e = mEntries; e != eEnd; ++e) {
-                if (!(uintptr_t(e->mObject) & uintptr_t(1))) {
-                    aVisitor.Visit(aBuffer, e);
-                }
-            }
-        }
-    };
-    // This class wraps a linked list of the elements in the purple
-    // buffer.
-
-    uint32_t mCount;
-    Block mFirstBlock;
-    nsPurpleBufferEntry *mFreeList;
-
-public:
-    nsPurpleBuffer()
-    {
-        InitBlocks();
-    }
-
-    ~nsPurpleBuffer()
-    {
-        FreeBlocks();
+  struct Block {
+    Block *mNext;
+    // Try to match the size of a jemalloc bucket, to minimize slop bytes.
+    // - On 32-bit platforms sizeof(nsPurpleBufferEntry) is 12, so mEntries
+    //   is 16,380 bytes, which leaves 4 bytes for mNext.
+    // - On 64-bit platforms sizeof(nsPurpleBufferEntry) is 24, so mEntries
+    //   is 32,544 bytes, which leaves 8 bytes for mNext.
+    nsPurpleBufferEntry mEntries[1365];
+
+    Block() : mNext(nullptr) {
+      // Ensure Block is the right size (see above).
+      static_assert(
+        sizeof(Block) == 16384 ||       // 32-bit
+        sizeof(Block) == 32768,         // 64-bit
+        "ill-sized nsPurpleBuffer::Block"
+      );
     }
 
     template <class PurpleVisitor>
-    void VisitEntries(PurpleVisitor &aVisitor)
-    {
-        for (Block *b = &mFirstBlock; b; b = b->mNext) {
-            b->VisitEntries(*this, aVisitor);
-        }
-    }
-
-    void InitBlocks()
-    {
-        mCount = 0;
-        mFreeList = nullptr;
-        StartBlock(&mFirstBlock);
-    }
-
-    void StartBlock(Block *aBlock)
-    {
-        NS_ABORT_IF_FALSE(!mFreeList, "should not have free list");
-
-        // Put all the entries in the block on the free list.
-        nsPurpleBufferEntry *entries = aBlock->mEntries;
-        mFreeList = entries;
-        for (uint32_t i = 1; i < ArrayLength(aBlock->mEntries); ++i) {
-            entries[i - 1].mNextInFreeList =
-                (nsPurpleBufferEntry*)(uintptr_t(entries + i) | 1);
-        }
-        entries[ArrayLength(aBlock->mEntries) - 1].mNextInFreeList =
-            (nsPurpleBufferEntry*)1;
-    }
-
-    void FreeBlocks()
+    void VisitEntries(nsPurpleBuffer &aBuffer, PurpleVisitor &aVisitor)
     {
-        if (mCount > 0)
-            UnmarkRemainingPurple(&mFirstBlock);
-        Block *b = mFirstBlock.mNext;
-        while (b) {
-            if (mCount > 0)
-                UnmarkRemainingPurple(b);
-            Block *next = b->mNext;
-            delete b;
-            b = next;
+      nsPurpleBufferEntry *eEnd = ArrayEnd(mEntries);
+      for (nsPurpleBufferEntry *e = mEntries; e != eEnd; ++e) {
+        if (!(uintptr_t(e->mObject) & uintptr_t(1))) {
+          aVisitor.Visit(aBuffer, e);
         }
-        mFirstBlock.mNext = nullptr;
+      }
+    }
+  };
+  // This class wraps a linked list of the elements in the purple
+  // buffer.
+
+  uint32_t mCount;
+  Block mFirstBlock;
+  nsPurpleBufferEntry *mFreeList;
+
+public:
+  nsPurpleBuffer()
+  {
+    InitBlocks();
+  }
+
+  ~nsPurpleBuffer()
+  {
+    FreeBlocks();
+  }
+
+  template <class PurpleVisitor>
+  void VisitEntries(PurpleVisitor &aVisitor)
+  {
+    for (Block *b = &mFirstBlock; b; b = b->mNext) {
+      b->VisitEntries(*this, aVisitor);
     }
-
-    struct UnmarkRemainingPurpleVisitor
+  }
+
+  void InitBlocks()
+  {
+    mCount = 0;
+    mFreeList = nullptr;
+    StartBlock(&mFirstBlock);
+  }
+
+  void StartBlock(Block *aBlock)
+  {
+    NS_ABORT_IF_FALSE(!mFreeList, "should not have free list");
+
+    // Put all the entries in the block on the free list.
+    nsPurpleBufferEntry *entries = aBlock->mEntries;
+    mFreeList = entries;
+    for (uint32_t i = 1; i < ArrayLength(aBlock->mEntries); ++i) {
+      entries[i - 1].mNextInFreeList =
+        (nsPurpleBufferEntry*)(uintptr_t(entries + i) | 1);
+    }
+    entries[ArrayLength(aBlock->mEntries) - 1].mNextInFreeList =
+      (nsPurpleBufferEntry*)1;
+  }
+
+  void FreeBlocks()
+  {
+    if (mCount > 0)
+      UnmarkRemainingPurple(&mFirstBlock);
+    Block *b = mFirstBlock.mNext;
+    while (b) {
+      if (mCount > 0)
+        UnmarkRemainingPurple(b);
+      Block *next = b->mNext;
+      delete b;
+      b = next;
+    }
+    mFirstBlock.mNext = nullptr;
+  }
+
+  struct UnmarkRemainingPurpleVisitor
+  {
+    void
+    Visit(nsPurpleBuffer &aBuffer, nsPurpleBufferEntry *aEntry)
     {
-        void
-        Visit(nsPurpleBuffer &aBuffer, nsPurpleBufferEntry *aEntry)
-        {
-            if (aEntry->mRefCnt) {
-                aEntry->mRefCnt->RemoveFromPurpleBuffer();
-                aEntry->mRefCnt = nullptr;
-            }
-            aEntry->mObject = nullptr;
-            --aBuffer.mCount;
-        }
-    };
-
-    void UnmarkRemainingPurple(Block *b)
-    {
-        UnmarkRemainingPurpleVisitor visitor;
-        b->VisitEntries(*this, visitor);
+      if (aEntry->mRefCnt) {
+        aEntry->mRefCnt->RemoveFromPurpleBuffer();
+        aEntry->mRefCnt = nullptr;
+      }
+      aEntry->mObject = nullptr;
+      --aBuffer.mCount;
     }
-
-    void SelectPointers(GCGraphBuilder &builder);
-
-    // RemoveSkippable removes entries from the purple buffer synchronously
-    // (1) if aAsyncSnowWhiteFreeing is false and nsPurpleBufferEntry::mRefCnt is 0 or
-    // (2) if the object's nsXPCOMCycleCollectionParticipant::CanSkip() returns true or
-    // (3) if nsPurpleBufferEntry::mRefCnt->IsPurple() is false.
-    // (4) If removeChildlessNodes is true, then any nodes in the purple buffer
-    //     that will have no children in the cycle collector graph will also be
-    //     removed. CanSkip() may be run on these children.
-    void RemoveSkippable(nsCycleCollector* aCollector,
-                         bool removeChildlessNodes,
-                         bool aAsyncSnowWhiteFreeing,
-                         CC_ForgetSkippableCallback aCb);
-
-    MOZ_ALWAYS_INLINE nsPurpleBufferEntry* NewEntry()
-    {
-        if (MOZ_UNLIKELY(!mFreeList)) {
-            Block *b = new Block;
-            StartBlock(b);
-
-            // Add the new block as the second block in the list.
-            b->mNext = mFirstBlock.mNext;
-            mFirstBlock.mNext = b;
-        }
-
-        nsPurpleBufferEntry *e = mFreeList;
-        mFreeList = (nsPurpleBufferEntry*)
-            (uintptr_t(mFreeList->mNextInFreeList) & ~uintptr_t(1));
-        return e;
+  };
+
+  void UnmarkRemainingPurple(Block *b)
+  {
+    UnmarkRemainingPurpleVisitor visitor;
+    b->VisitEntries(*this, visitor);
+  }
+
+  void SelectPointers(GCGraphBuilder &builder);
+
+  // RemoveSkippable removes entries from the purple buffer synchronously
+  // (1) if aAsyncSnowWhiteFreeing is false and nsPurpleBufferEntry::mRefCnt is 0 or
+  // (2) if the object's nsXPCOMCycleCollectionParticipant::CanSkip() returns true or
+  // (3) if nsPurpleBufferEntry::mRefCnt->IsPurple() is false.
+  // (4) If removeChildlessNodes is true, then any nodes in the purple buffer
+  //     that will have no children in the cycle collector graph will also be
+  //     removed. CanSkip() may be run on these children.
+  void RemoveSkippable(nsCycleCollector* aCollector,
+                       bool removeChildlessNodes,
+                       bool aAsyncSnowWhiteFreeing,
+                       CC_ForgetSkippableCallback aCb);
+
+  MOZ_ALWAYS_INLINE nsPurpleBufferEntry* NewEntry()
+  {
+    if (MOZ_UNLIKELY(!mFreeList)) {
+      Block *b = new Block;
+      StartBlock(b);
+
+      // Add the new block as the second block in the list.
+      b->mNext = mFirstBlock.mNext;
+      mFirstBlock.mNext = b;
     }
 
-    MOZ_ALWAYS_INLINE void Put(void *p, nsCycleCollectionParticipant *cp,
-                               nsCycleCollectingAutoRefCnt *aRefCnt)
-    {
-        nsPurpleBufferEntry *e = NewEntry();
-
-        ++mCount;
-
-        e->mObject = p;
-        e->mRefCnt = aRefCnt;
-        e->mParticipant = cp;
-    }
-
-    void Remove(nsPurpleBufferEntry *e)
-    {
-        MOZ_ASSERT(mCount != 0, "must have entries");
-
-        if (e->mRefCnt) {
-            e->mRefCnt->RemoveFromPurpleBuffer();
-            e->mRefCnt = nullptr;
-        }
-        e->mNextInFreeList =
-            (nsPurpleBufferEntry*)(uintptr_t(mFreeList) | uintptr_t(1));
-        mFreeList = e;
-
-        --mCount;
+    nsPurpleBufferEntry *e = mFreeList;
+    mFreeList = (nsPurpleBufferEntry*)
+      (uintptr_t(mFreeList->mNextInFreeList) & ~uintptr_t(1));
+    return e;
+  }
+
+  MOZ_ALWAYS_INLINE void Put(void *p, nsCycleCollectionParticipant *cp,
+                             nsCycleCollectingAutoRefCnt *aRefCnt)
+  {
+    nsPurpleBufferEntry *e = NewEntry();
+
+    ++mCount;
+
+    e->mObject = p;
+    e->mRefCnt = aRefCnt;
+    e->mParticipant = cp;
+  }
+
+  void Remove(nsPurpleBufferEntry *e)
+  {
+    MOZ_ASSERT(mCount != 0, "must have entries");
+
+    if (e->mRefCnt) {
+      e->mRefCnt->RemoveFromPurpleBuffer();
+      e->mRefCnt = nullptr;
     }
-
-    uint32_t Count() const
-    {
-        return mCount;
+    e->mNextInFreeList =
+      (nsPurpleBufferEntry*)(uintptr_t(mFreeList) | uintptr_t(1));
+    mFreeList = e;
+
+    --mCount;
+  }
+
+  uint32_t Count() const
+  {
+    return mCount;
+  }
+
+  size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
+  {
+    size_t n = 0;
+
+    // Don't measure mFirstBlock because it's within |this|.
+    const Block *block = mFirstBlock.mNext;
+    while (block) {
+      n += aMallocSizeOf(block);
+      block = block->mNext;
     }
 
-    size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
-    {
-        size_t n = 0;
-
-        // Don't measure mFirstBlock because it's within |this|.
-        const Block *block = mFirstBlock.mNext;
-        while (block) {
-            n += aMallocSizeOf(block);
-            block = block->mNext;
-        }
-
-        // mFreeList is deliberately not measured because it points into
-        // the purple buffer, which is within mFirstBlock and thus within |this|.
-        //
-        // We also don't measure the things pointed to by mEntries[] because
-        // those pointers are non-owning.
-
-        return n;
-    }
+    // mFreeList is deliberately not measured because it points into
+    // the purple buffer, which is within mFirstBlock and thus within |this|.
+    //
+    // We also don't measure the things pointed to by mEntries[] because
+    // those pointers are non-owning.
+
+    return n;
+  }
 };
 
 static bool
 AddPurpleRoot(GCGraphBuilder &aBuilder, void *aRoot, nsCycleCollectionParticipant *aParti);
 
 struct SelectPointersVisitor
 {
-    SelectPointersVisitor(GCGraphBuilder &aBuilder)
-        : mBuilder(aBuilder)
-    {}
-
-    void
-    Visit(nsPurpleBuffer &aBuffer, nsPurpleBufferEntry *aEntry)
-    {
-        MOZ_ASSERT(aEntry->mObject, "Null object in purple buffer");
-        MOZ_ASSERT(aEntry->mRefCnt->get() != 0,
-                   "SelectPointersVisitor: snow-white object in the purple buffer");
-        if (!aEntry->mRefCnt->IsPurple() ||
-            AddPurpleRoot(mBuilder, aEntry->mObject, aEntry->mParticipant)) {
-            aBuffer.Remove(aEntry);
-        }
+  SelectPointersVisitor(GCGraphBuilder &aBuilder)
+    : mBuilder(aBuilder)
+  {}
+
+  void
+  Visit(nsPurpleBuffer &aBuffer, nsPurpleBufferEntry *aEntry)
+  {
+    MOZ_ASSERT(aEntry->mObject, "Null object in purple buffer");
+    MOZ_ASSERT(aEntry->mRefCnt->get() != 0,
+               "SelectPointersVisitor: snow-white object in the purple buffer");
+    if (!aEntry->mRefCnt->IsPurple() ||
+        AddPurpleRoot(mBuilder, aEntry->mObject, aEntry->mParticipant)) {
+      aBuffer.Remove(aEntry);
     }
+  }
 
 private:
-    GCGraphBuilder &mBuilder;
+  GCGraphBuilder &mBuilder;
 };
 
 void
 nsPurpleBuffer::SelectPointers(GCGraphBuilder &aBuilder)
 {
-    SelectPointersVisitor visitor(aBuilder);
-    VisitEntries(visitor);
-
-    NS_ASSERTION(mCount == 0, "AddPurpleRoot failed");
-    if (mCount == 0) {
-        FreeBlocks();
-        InitBlocks();
-    }
+  SelectPointersVisitor visitor(aBuilder);
+  VisitEntries(visitor);
+
+  NS_ASSERTION(mCount == 0, "AddPurpleRoot failed");
+  if (mCount == 0) {
+    FreeBlocks();
+    InitBlocks();
+  }
 }
 
 enum ccPhase {
-    IdlePhase,
-    GraphBuildingPhase,
-    ScanAndCollectWhitePhase,
-    CleanupPhase
+  IdlePhase,
+  GraphBuildingPhase,
+  ScanAndCollectWhitePhase,
+  CleanupPhase
 };
 
 enum ccType {
-    SliceCC,     /* If a CC is in progress, continue it. Otherwise, start a new one. */
-    ManualCC,    /* Explicitly triggered. */
-    ShutdownCC   /* Shutdown CC, used for finding leaks. */
+  SliceCC,     /* If a CC is in progress, continue it. Otherwise, start a new one. */
+  ManualCC,    /* Explicitly triggered. */
+  ShutdownCC   /* Shutdown CC, used for finding leaks. */
 };
 
 #ifdef MOZ_NUWA_PROCESS
 #include "ipc/Nuwa.h"
 #endif
 
 ////////////////////////////////////////////////////////////////////////
 // Top level structure for the cycle collector.
 ////////////////////////////////////////////////////////////////////////
 
 typedef js::SliceBudget SliceBudget;
 
 class JSPurpleBuffer;
 
 class nsCycleCollector : public nsIMemoryReporter
 {
-    NS_DECL_ISUPPORTS
-    NS_DECL_NSIMEMORYREPORTER
-
-    bool mActivelyCollecting;
-    bool mFreeingSnowWhite;
-    // mScanInProgress should be false when we're collecting white objects.
-    bool mScanInProgress;
-    CycleCollectorResults mResults;
-    TimeStamp mCollectionStart;
-
-    CycleCollectedJSRuntime *mJSRuntime;
-
-    ccPhase mIncrementalPhase;
-    GCGraph mGraph;
-    nsAutoPtr<GCGraphBuilder> mBuilder;
-    nsAutoPtr<NodePool::Enumerator> mCurrNode;
-    nsCOMPtr<nsICycleCollectorListener> mListener;
-
-    nsIThread* mThread;
-
-    nsCycleCollectorParams mParams;
-
-    uint32_t mWhiteNodeCount;
-
-    CC_BeforeUnlinkCallback mBeforeUnlinkCB;
-    CC_ForgetSkippableCallback mForgetSkippableCB;
-
-    nsPurpleBuffer mPurpleBuf;
-
-    uint32_t mUnmergedNeeded;
-    uint32_t mMergedInARow;
-
-    JSPurpleBuffer* mJSPurpleBuffer;
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIMEMORYREPORTER
+
+  bool mActivelyCollecting;
+  bool mFreeingSnowWhite;
+  // mScanInProgress should be false when we're collecting white objects.
+  bool mScanInProgress;
+  CycleCollectorResults mResults;
+  TimeStamp mCollectionStart;
+
+  CycleCollectedJSRuntime *mJSRuntime;
+
+  ccPhase mIncrementalPhase;
+  GCGraph mGraph;
+  nsAutoPtr<GCGraphBuilder> mBuilder;
+  nsAutoPtr<NodePool::Enumerator> mCurrNode;
+  nsCOMPtr<nsICycleCollectorListener> mListener;
+
+  nsIThread* mThread;
+
+  nsCycleCollectorParams mParams;
+
+  uint32_t mWhiteNodeCount;
+
+  CC_BeforeUnlinkCallback mBeforeUnlinkCB;
+  CC_ForgetSkippableCallback mForgetSkippableCB;
+
+  nsPurpleBuffer mPurpleBuf;
+
+  uint32_t mUnmergedNeeded;
+  uint32_t mMergedInARow;
+
+  JSPurpleBuffer* mJSPurpleBuffer;
 
 public:
-    nsCycleCollector();
-    virtual ~nsCycleCollector();
-
-    void RegisterJSRuntime(CycleCollectedJSRuntime *aJSRuntime);
-    void ForgetJSRuntime();
-
-    void SetBeforeUnlinkCallback(CC_BeforeUnlinkCallback aBeforeUnlinkCB)
-    {
-        CheckThreadSafety();
-        mBeforeUnlinkCB = aBeforeUnlinkCB;
-    }
-
-    void SetForgetSkippableCallback(CC_ForgetSkippableCallback aForgetSkippableCB)
-    {
-        CheckThreadSafety();
-        mForgetSkippableCB = aForgetSkippableCB;
-    }
-
-    void Suspect(void *n, nsCycleCollectionParticipant *cp,
-                 nsCycleCollectingAutoRefCnt *aRefCnt);
-    uint32_t SuspectedCount();
-    void ForgetSkippable(bool aRemoveChildlessNodes, bool aAsyncSnowWhiteFreeing);
-    bool FreeSnowWhite(bool aUntilNoSWInPurpleBuffer);
-
-    // This method assumes its argument is already canonicalized.
-    void RemoveObjectFromGraph(void *aPtr);
-
-    void PrepareForGarbageCollection();
-
-    bool Collect(ccType aCCType,
-                 SliceBudget &aBudget,
-                 nsICycleCollectorListener *aManualListener);
-    void Shutdown();
-
-    void SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
-                             size_t *aObjectSize,
-                             size_t *aGraphNodesSize,
-                             size_t *aGraphEdgesSize,
-                             size_t *aWeakMapsSize,
-                             size_t *aPurpleBufferSize) const;
-
-    JSPurpleBuffer* GetJSPurpleBuffer();
+  nsCycleCollector();
+  virtual ~nsCycleCollector();
+
+  void RegisterJSRuntime(CycleCollectedJSRuntime *aJSRuntime);
+  void ForgetJSRuntime();
+
+  void SetBeforeUnlinkCallback(CC_BeforeUnlinkCallback aBeforeUnlinkCB)
+  {
+    CheckThreadSafety();
+    mBeforeUnlinkCB = aBeforeUnlinkCB;
+  }
+
+  void SetForgetSkippableCallback(CC_ForgetSkippableCallback aForgetSkippableCB)
+  {
+    CheckThreadSafety();
+    mForgetSkippableCB = aForgetSkippableCB;
+  }
+
+  void Suspect(void *n, nsCycleCollectionParticipant *cp,
+               nsCycleCollectingAutoRefCnt *aRefCnt);
+  uint32_t SuspectedCount();
+  void ForgetSkippable(bool aRemoveChildlessNodes, bool aAsyncSnowWhiteFreeing);
+  bool FreeSnowWhite(bool aUntilNoSWInPurpleBuffer);
+
+  // This method assumes its argument is already canonicalized.
+  void RemoveObjectFromGraph(void *aPtr);
+
+  void PrepareForGarbageCollection();
+
+  bool Collect(ccType aCCType,
+               SliceBudget &aBudget,
+               nsICycleCollectorListener *aManualListener);
+  void Shutdown();
+
+  void SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
+                           size_t *aObjectSize,
+                           size_t *aGraphNodesSize,
+                           size_t *aGraphEdgesSize,
+                           size_t *aWeakMapsSize,
+                           size_t *aPurpleBufferSize) const;
+
+  JSPurpleBuffer* GetJSPurpleBuffer();
 private:
-    void CheckThreadSafety();
-    void ShutdownCollect();
-
-    void FixGrayBits(bool aForceGC);
-    bool ShouldMergeZones(ccType aCCType);
-
-    void BeginCollection(ccType aCCType, nsICycleCollectorListener *aManualListener);
-    void MarkRoots(SliceBudget &aBudget);
-    void ScanRoots(bool aFullySynchGraphBuild);
-    void ScanIncrementalRoots();
-    void ScanWeakMaps();
-
-    // returns whether anything was collected
-    bool CollectWhite();
-
-    void CleanupAfterCollection();
+  void CheckThreadSafety();
+  void ShutdownCollect();
+
+  void FixGrayBits(bool aForceGC);
+  bool ShouldMergeZones(ccType aCCType);
+
+  void BeginCollection(ccType aCCType, nsICycleCollectorListener *aManualListener);
+  void MarkRoots(SliceBudget &aBudget);
+  void ScanRoots(bool aFullySynchGraphBuild);
+  void ScanIncrementalRoots();
+  void ScanWeakMaps();
+
+  // returns whether anything was collected
+  bool CollectWhite();
+
+  void CleanupAfterCollection();
 };
 
 NS_IMPL_ISUPPORTS(nsCycleCollector, nsIMemoryReporter)
 
 /**
  * GraphWalker is templatized over a Visitor class that must provide
  * the following two methods:
  *
  * bool ShouldVisitNode(PtrInfo const *pi);
  * void VisitNode(PtrInfo *pi);
  */
 template <class Visitor>
 class GraphWalker
 {
 private:
-    Visitor mVisitor;
-
-    void DoWalk(nsDeque &aQueue);
-
-    void CheckedPush(nsDeque &aQueue, PtrInfo *pi)
-    {
-        if (!pi) {
-            MOZ_CRASH();
-        }
-        if (!aQueue.Push(pi, fallible_t())) {
-            mVisitor.Failed();
-        }
+  Visitor mVisitor;
+
+  void DoWalk(nsDeque &aQueue);
+
+  void CheckedPush(nsDeque &aQueue, PtrInfo *pi)
+  {
+    if (!pi) {
+      MOZ_CRASH();
     }
+    if (!aQueue.Push(pi, fallible_t())) {
+      mVisitor.Failed();
+    }
+  }
 
 public:
-    void Walk(PtrInfo *s0);
-    void WalkFromRoots(GCGraph &aGraph);
-    // copy-constructing the visitor should be cheap, and less
-    // indirection than using a reference
-    GraphWalker(const Visitor aVisitor) : mVisitor(aVisitor) {}
+  void Walk(PtrInfo *s0);
+  void WalkFromRoots(GCGraph &aGraph);
+  // copy-constructing the visitor should be cheap, and less
+  // indirection than using a reference
+  GraphWalker(const Visitor aVisitor) : mVisitor(aVisitor) {}
 };
 
 
 ////////////////////////////////////////////////////////////////////////
 // The static collector struct
 ////////////////////////////////////////////////////////////////////////
 
 struct CollectorData {
@@ -1299,85 +1299,85 @@ static mozilla::ThreadLocal<CollectorDat
 
 ////////////////////////////////////////////////////////////////////////
 // Utility functions
 ////////////////////////////////////////////////////////////////////////
 
 MOZ_NEVER_INLINE static void
 Fault(const char *msg, const void *ptr=nullptr)
 {
-    if (ptr)
-        printf("Fault in cycle collector: %s (ptr: %p)\n", msg, ptr);
-    else
-        printf("Fault in cycle collector: %s\n", msg);
-
-    NS_RUNTIMEABORT("cycle collector fault");
+  if (ptr)
+    printf("Fault in cycle collector: %s (ptr: %p)\n", msg, ptr);
+  else
+    printf("Fault in cycle collector: %s\n", msg);
+
+  NS_RUNTIMEABORT("cycle collector fault");
 }
 
 static void
 Fault(const char *msg, PtrInfo *pi)
 {
-    Fault(msg, pi->mPointer);
+  Fault(msg, pi->mPointer);
 }
 
 static inline void
 ToParticipant(nsISupports *s, nsXPCOMCycleCollectionParticipant **cp)
 {
-    // We use QI to move from an nsISupports to an
-    // nsXPCOMCycleCollectionParticipant, which is a per-class singleton helper
-    // object that implements traversal and unlinking logic for the nsISupports
-    // in question.
-    CallQueryInterface(s, cp);
+  // We use QI to move from an nsISupports to an
+  // nsXPCOMCycleCollectionParticipant, which is a per-class singleton helper
+  // object that implements traversal and unlinking logic for the nsISupports
+  // in question.
+  CallQueryInterface(s, cp);
 }
 
 template <class Visitor>
 MOZ_NEVER_INLINE void
 GraphWalker<Visitor>::Walk(PtrInfo *s0)
 {
-    nsDeque queue;
-    CheckedPush(queue, s0);
-    DoWalk(queue);
+  nsDeque queue;
+  CheckedPush(queue, s0);
+  DoWalk(queue);
 }
 
 template <class Visitor>
 MOZ_NEVER_INLINE void
 GraphWalker<Visitor>::WalkFromRoots(GCGraph& aGraph)
 {
-    nsDeque queue;
-    NodePool::Enumerator etor(aGraph.mNodes);
-    for (uint32_t i = 0; i < aGraph.mRootCount; ++i) {
-        CheckedPush(queue, etor.GetNext());
-    }
-    DoWalk(queue);
+  nsDeque queue;
+  NodePool::Enumerator etor(aGraph.mNodes);
+  for (uint32_t i = 0; i < aGraph.mRootCount; ++i) {
+    CheckedPush(queue, etor.GetNext());
+  }
+  DoWalk(queue);
 }
 
 template <class Visitor>
 MOZ_NEVER_INLINE void
 GraphWalker<Visitor>::DoWalk(nsDeque &aQueue)
 {
-    // Use a aQueue to match the breadth-first traversal used when we
-    // built the graph, for hopefully-better locality.
-    while (aQueue.GetSize() > 0) {
-        PtrInfo *pi = static_cast<PtrInfo*>(aQueue.PopFront());
-
-        if (pi->mParticipant && mVisitor.ShouldVisitNode(pi)) {
-            mVisitor.VisitNode(pi);
-            for (EdgePool::Iterator child = pi->FirstChild(),
-                                child_end = pi->LastChild();
-                 child != child_end; ++child) {
-                CheckedPush(aQueue, *child);
-            }
-        }
+  // Use a aQueue to match the breadth-first traversal used when we
+  // built the graph, for hopefully-better locality.
+  while (aQueue.GetSize() > 0) {
+    PtrInfo *pi = static_cast<PtrInfo*>(aQueue.PopFront());
+
+    if (pi->mParticipant && mVisitor.ShouldVisitNode(pi)) {
+      mVisitor.VisitNode(pi);
+      for (EdgePool::Iterator child = pi->FirstChild(),
+           child_end = pi->LastChild();
+           child != child_end; ++child) {
+        CheckedPush(aQueue, *child);
+      }
     }
+  }
 }
 
 struct CCGraphDescriber : public LinkedListElement<CCGraphDescriber>
 {
   CCGraphDescriber()
-  : mAddress("0x"), mCnt(0), mType(eUnknown) {}
+    : mAddress("0x"), mCnt(0), mType(eUnknown) {}
 
   enum Type
   {
     eRefCountedObject,
     eGCedObject,
     eGCMarkedObject,
     eEdge,
     eRoot,
@@ -1390,2152 +1390,2152 @@ struct CCGraphDescriber : public LinkedL
   nsCString mCompartmentOrToAddress;
   uint32_t mCnt;
   Type mType;
 };
 
 class nsCycleCollectorLogger MOZ_FINAL : public nsICycleCollectorListener
 {
 public:
-    nsCycleCollectorLogger() :
-      mStream(nullptr), mWantAllTraces(false),
-      mDisableLog(false), mWantAfterProcessing(false)
-    {
-    }
-    ~nsCycleCollectorLogger()
-    {
-        ClearDescribers();
-        if (mStream) {
-            MozillaUnRegisterDebugFILE(mStream);
-            fclose(mStream);
-        }
-    }
-    NS_DECL_ISUPPORTS
-
-    void SetAllTraces()
-    {
-        mWantAllTraces = true;
-    }
-
-    NS_IMETHOD AllTraces(nsICycleCollectorListener** aListener)
-    {
-        SetAllTraces();
-        NS_ADDREF(*aListener = this);
-        return NS_OK;
-    }
-
-    NS_IMETHOD GetWantAllTraces(bool* aAllTraces)
-    {
-        *aAllTraces = mWantAllTraces;
-        return NS_OK;
-    }
-
-    NS_IMETHOD GetDisableLog(bool* aDisableLog)
-    {
-        *aDisableLog = mDisableLog;
-        return NS_OK;
+  nsCycleCollectorLogger() :
+    mStream(nullptr), mWantAllTraces(false),
+    mDisableLog(false), mWantAfterProcessing(false)
+  {
+  }
+  ~nsCycleCollectorLogger()
+  {
+    ClearDescribers();
+    if (mStream) {
+      MozillaUnRegisterDebugFILE(mStream);
+      fclose(mStream);
     }
-
-    NS_IMETHOD SetDisableLog(bool aDisableLog)
-    {
-        mDisableLog = aDisableLog;
-        return NS_OK;
-    }
-
-    NS_IMETHOD GetWantAfterProcessing(bool* aWantAfterProcessing)
-    {
-        *aWantAfterProcessing = mWantAfterProcessing;
-        return NS_OK;
-    }
-
-    NS_IMETHOD SetWantAfterProcessing(bool aWantAfterProcessing)
-    {
-        mWantAfterProcessing = aWantAfterProcessing;
-        return NS_OK;
-    }
-
-    NS_IMETHOD GetFilenameIdentifier(nsAString& aIdentifier)
-    {
-        aIdentifier = mFilenameIdentifier;
-        return NS_OK;
-    }
-
-    NS_IMETHOD SetFilenameIdentifier(const nsAString& aIdentifier)
-    {
-        mFilenameIdentifier = aIdentifier;
-        return NS_OK;
-    }
-
-    NS_IMETHOD GetGcLogPath(nsAString &aPath)
-    {
-      aPath = mGCLogPath;
-      return NS_OK;
-    }
-
-    NS_IMETHOD GetCcLogPath(nsAString &aPath)
-    {
-      aPath = mCCLogPath;
+  }
+  NS_DECL_ISUPPORTS
+
+  void SetAllTraces()
+  {
+    mWantAllTraces = true;
+  }
+
+  NS_IMETHOD AllTraces(nsICycleCollectorListener** aListener)
+  {
+    SetAllTraces();
+    NS_ADDREF(*aListener = this);
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetWantAllTraces(bool* aAllTraces)
+  {
+    *aAllTraces = mWantAllTraces;
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetDisableLog(bool* aDisableLog)
+  {
+    *aDisableLog = mDisableLog;
+    return NS_OK;
+  }
+
+  NS_IMETHOD SetDisableLog(bool aDisableLog)
+  {
+    mDisableLog = aDisableLog;
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetWantAfterProcessing(bool* aWantAfterProcessing)
+  {
+    *aWantAfterProcessing = mWantAfterProcessing;
+    return NS_OK;
+  }
+
+  NS_IMETHOD SetWantAfterProcessing(bool aWantAfterProcessing)
+  {
+    mWantAfterProcessing = aWantAfterProcessing;
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetFilenameIdentifier(nsAString& aIdentifier)
+  {
+    aIdentifier = mFilenameIdentifier;
+    return NS_OK;
+  }
+
+  NS_IMETHOD SetFilenameIdentifier(const nsAString& aIdentifier)
+  {
+    mFilenameIdentifier = aIdentifier;
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetGcLogPath(nsAString &aPath)
+  {
+    aPath = mGCLogPath;
+    return NS_OK;
+  }
+
+  NS_IMETHOD GetCcLogPath(nsAString &aPath)
+  {
+    aPath = mCCLogPath;
+    return NS_OK;
+  }
+
+  NS_IMETHOD Begin()
+  {
+    mCurrentAddress.AssignLiteral("0x");
+    ClearDescribers();
+    if (mDisableLog) {
       return NS_OK;
     }
 
-    NS_IMETHOD Begin()
-    {
-        mCurrentAddress.AssignLiteral("0x");
-        ClearDescribers();
-        if (mDisableLog) {
-            return NS_OK;
-        }
-
-        // Initially create the log in a file starting with
-        // "incomplete-gc-edges".  We'll move the file and strip off the
-        // "incomplete-" once the dump completes.  (We do this because we don't
-        // want scripts which poll the filesystem looking for gc/cc dumps to
-        // grab a file before we're finished writing to it.)
-        nsCOMPtr<nsIFile> gcLogFile = CreateTempFile("incomplete-gc-edges");
-        if (NS_WARN_IF(!gcLogFile))
-            return NS_ERROR_UNEXPECTED;
-
-        // Dump the JS heap.
-        FILE* gcLogANSIFile = nullptr;
-        gcLogFile->OpenANSIFileDesc("w", &gcLogANSIFile);
-        if (NS_WARN_IF(!gcLogANSIFile))
-            return NS_ERROR_UNEXPECTED;
-        MozillaRegisterDebugFILE(gcLogANSIFile);
-        CollectorData *data = sCollectorData.get();
-        if (data && data->mRuntime)
-            data->mRuntime->DumpJSHeap(gcLogANSIFile);
-        MozillaUnRegisterDebugFILE(gcLogANSIFile);
-        fclose(gcLogANSIFile);
-
-        // Strip off "incomplete-".
-        nsCOMPtr<nsIFile> gcLogFileFinalDestination =
-            CreateTempFile("gc-edges");
-        if (NS_WARN_IF(!gcLogFileFinalDestination))
-            return NS_ERROR_UNEXPECTED;
-
-        nsAutoString gcLogFileFinalDestinationName;
-        gcLogFileFinalDestination->GetLeafName(gcLogFileFinalDestinationName);
-        if (NS_WARN_IF(gcLogFileFinalDestinationName.IsEmpty()))
-            return NS_ERROR_UNEXPECTED;
-
-        gcLogFile->MoveTo(/* directory */ nullptr, gcLogFileFinalDestinationName);
-
-        // Log to the error console.
-        nsCOMPtr<nsIConsoleService> cs =
-            do_GetService(NS_CONSOLESERVICE_CONTRACTID);
-        if (cs) {
-            nsAutoString gcLogPath;
-            gcLogFileFinalDestination->GetPath(gcLogPath);
-
-            nsString msg = NS_LITERAL_STRING("Garbage Collector log dumped to ") +
-                           gcLogPath;
-            cs->LogStringMessage(msg.get());
-
-            mGCLogPath = gcLogPath;
-        }
-
-        // Open a file for dumping the CC graph.  We again prefix with
-        // "incomplete-".
-        mOutFile = CreateTempFile("incomplete-cc-edges");
-        if (NS_WARN_IF(!mOutFile))
-            return NS_ERROR_UNEXPECTED;
-        MOZ_ASSERT(!mStream);
-        mOutFile->OpenANSIFileDesc("w", &mStream);
-        if (NS_WARN_IF(!mStream))
-            return NS_ERROR_UNEXPECTED;
-        MozillaRegisterDebugFILE(mStream);
-
-        fprintf(mStream, "# WantAllTraces=%s\n", mWantAllTraces ? "true" : "false");
-
-        return NS_OK;
-    }
-    NS_IMETHOD NoteRefCountedObject(uint64_t aAddress, uint32_t refCount,
-                                    const char *aObjectDescription)
-    {
-        if (!mDisableLog) {
-            fprintf(mStream, "%p [rc=%u] %s\n", (void*)aAddress, refCount,
-                    aObjectDescription);
-        }
-        if (mWantAfterProcessing) {
-            CCGraphDescriber* d =  new CCGraphDescriber();
-            mDescribers.insertBack(d);
-            mCurrentAddress.AssignLiteral("0x");
-            mCurrentAddress.AppendInt(aAddress, 16);
-            d->mType = CCGraphDescriber::eRefCountedObject;
-            d->mAddress = mCurrentAddress;
-            d->mCnt = refCount;
-            d->mName.Append(aObjectDescription);
-        }
-        return NS_OK;
-    }
-    NS_IMETHOD NoteGCedObject(uint64_t aAddress, bool aMarked,
-                              const char *aObjectDescription,
-                              uint64_t aCompartmentAddress)
-    {
-        if (!mDisableLog) {
-            fprintf(mStream, "%p [gc%s] %s\n", (void*)aAddress,
-                    aMarked ? ".marked" : "", aObjectDescription);
-        }
-        if (mWantAfterProcessing) {
-            CCGraphDescriber* d =  new CCGraphDescriber();
-            mDescribers.insertBack(d);
-            mCurrentAddress.AssignLiteral("0x");
-            mCurrentAddress.AppendInt(aAddress, 16);
-            d->mType = aMarked ? CCGraphDescriber::eGCMarkedObject :
-                                 CCGraphDescriber::eGCedObject;
-            d->mAddress = mCurrentAddress;
-            d->mName.Append(aObjectDescription);
-            if (aCompartmentAddress) {
-                d->mCompartmentOrToAddress.AssignLiteral("0x");
-                d->mCompartmentOrToAddress.AppendInt(aCompartmentAddress, 16);
-            } else {
-                d->mCompartmentOrToAddress.SetIsVoid(true);
-            }
-        }
-        return NS_OK;
-    }
-    NS_IMETHOD NoteEdge(uint64_t aToAddress, const char *aEdgeName)
-    {
-        if (!mDisableLog) {
-            fprintf(mStream, "> %p %s\n", (void*)aToAddress, aEdgeName);
-        }
-        if (mWantAfterProcessing) {
-            CCGraphDescriber* d =  new CCGraphDescriber();
-            mDescribers.insertBack(d);
-            d->mType = CCGraphDescriber::eEdge;
-            d->mAddress = mCurrentAddress;
-            d->mCompartmentOrToAddress.AssignLiteral("0x");
-            d->mCompartmentOrToAddress.AppendInt(aToAddress, 16);
-            d->mName.Append(aEdgeName);
-        }
-        return NS_OK;
-    }
-    NS_IMETHOD NoteWeakMapEntry(uint64_t aMap, uint64_t aKey,
-                                uint64_t aKeyDelegate, uint64_t aValue)
-    {
-        if (!mDisableLog) {
-            fprintf(mStream, "WeakMapEntry map=%p key=%p keyDelegate=%p value=%p\n",
-                    (void*)aMap, (void*)aKey, (void*)aKeyDelegate, (void*)aValue);
-        }
-        // We don't support after-processing for weak map entries.
-        return NS_OK;
-    }
-    NS_IMETHOD NoteIncrementalRoot(uint64_t aAddress)
-    {
-        if (!mDisableLog) {
-            fprintf(mStream, "IncrementalRoot %p\n", (void*)aAddress);
-        }
-        // We don't support after-processing for incremental roots.
-        return NS_OK;
-    }
-    NS_IMETHOD BeginResults()
-    {
-        if (!mDisableLog) {
-            fputs("==========\n", mStream);
-        }
-        return NS_OK;
+    // Initially create the log in a file starting with
+    // "incomplete-gc-edges".  We'll move the file and strip off the
+    // "incomplete-" once the dump completes.  (We do this because we don't
+    // want scripts which poll the filesystem looking for gc/cc dumps to
+    // grab a file before we're finished writing to it.)
+    nsCOMPtr<nsIFile> gcLogFile = CreateTempFile("incomplete-gc-edges");
+    if (NS_WARN_IF(!gcLogFile))
+      return NS_ERROR_UNEXPECTED;
+
+    // Dump the JS heap.
+    FILE* gcLogANSIFile = nullptr;
+    gcLogFile->OpenANSIFileDesc("w", &gcLogANSIFile);
+    if (NS_WARN_IF(!gcLogANSIFile))
+      return NS_ERROR_UNEXPECTED;
+    MozillaRegisterDebugFILE(gcLogANSIFile);
+    CollectorData *data = sCollectorData.get();
+    if (data && data->mRuntime)
+      data->mRuntime->DumpJSHeap(gcLogANSIFile);
+    MozillaUnRegisterDebugFILE(gcLogANSIFile);
+    fclose(gcLogANSIFile);
+
+    // Strip off "incomplete-".
+    nsCOMPtr<nsIFile> gcLogFileFinalDestination =
+      CreateTempFile("gc-edges");
+    if (NS_WARN_IF(!gcLogFileFinalDestination))
+      return NS_ERROR_UNEXPECTED;
+
+    nsAutoString gcLogFileFinalDestinationName;
+    gcLogFileFinalDestination->GetLeafName(gcLogFileFinalDestinationName);
+    if (NS_WARN_IF(gcLogFileFinalDestinationName.IsEmpty()))
+      return NS_ERROR_UNEXPECTED;
+
+    gcLogFile->MoveTo(/* directory */ nullptr, gcLogFileFinalDestinationName);
+
+    // Log to the error console.
+    nsCOMPtr<nsIConsoleService> cs =
+      do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+    if (cs) {
+      nsAutoString gcLogPath;
+      gcLogFileFinalDestination->GetPath(gcLogPath);
+
+      nsString msg = NS_LITERAL_STRING("Garbage Collector log dumped to ") +
+                     gcLogPath;
+      cs->LogStringMessage(msg.get());
+
+      mGCLogPath = gcLogPath;
     }
-    NS_IMETHOD DescribeRoot(uint64_t aAddress, uint32_t aKnownEdges)
-    {
-        if (!mDisableLog) {
-            fprintf(mStream, "%p [known=%u]\n", (void*)aAddress, aKnownEdges);
-        }
-        if (mWantAfterProcessing) {
-            CCGraphDescriber* d =  new CCGraphDescriber();
-            mDescribers.insertBack(d);
-            d->mType = CCGraphDescriber::eRoot;
-            d->mAddress.AppendInt(aAddress, 16);
-            d->mCnt = aKnownEdges;
-        }
-        return NS_OK;
-    }
-    NS_IMETHOD DescribeGarbage(uint64_t aAddress)
-    {
-        if (!mDisableLog) {
-            fprintf(mStream, "%p [garbage]\n", (void*)aAddress);
-        }
-        if (mWantAfterProcessing) {
-            CCGraphDescriber* d =  new CCGraphDescriber();
-            mDescribers.insertBack(d);
-            d->mType = CCGraphDescriber::eGarbage;
-            d->mAddress.AppendInt(aAddress, 16);
-        }
-        return NS_OK;
-    }
-    NS_IMETHOD End()
-    {
-        if (!mDisableLog) {
-            MOZ_ASSERT(mStream);
-            MOZ_ASSERT(mOutFile);
-
-            MozillaUnRegisterDebugFILE(mStream);
-            fclose(mStream);
-            mStream = nullptr;
-
-            // Strip off "incomplete-" from the log file's name.
-            nsCOMPtr<nsIFile> logFileFinalDestination =
-                CreateTempFile("cc-edges");
-            if (NS_WARN_IF(!logFileFinalDestination))
-                return NS_ERROR_UNEXPECTED;
-
-            nsAutoString logFileFinalDestinationName;
-            logFileFinalDestination->GetLeafName(logFileFinalDestinationName);
-            if (NS_WARN_IF(logFileFinalDestinationName.IsEmpty()))
-                return NS_ERROR_UNEXPECTED;
-
-            mOutFile->MoveTo(/* directory = */ nullptr,
-                             logFileFinalDestinationName);
-            mOutFile = nullptr;
-
-            // Log to the error console.
-            nsCOMPtr<nsIConsoleService> cs =
-                do_GetService(NS_CONSOLESERVICE_CONTRACTID);
-            if (cs) {
-                nsAutoString ccLogPath;
-                logFileFinalDestination->GetPath(ccLogPath);
-
-                nsString msg = NS_LITERAL_STRING("Cycle Collector log dumped to ") +
-                               ccLogPath;
-                cs->LogStringMessage(msg.get());
-
-                mCCLogPath = ccLogPath;
-            }
-        }
-        return NS_OK;
+
+    // Open a file for dumping the CC graph.  We again prefix with
+    // "incomplete-".
+    mOutFile = CreateTempFile("incomplete-cc-edges");
+    if (NS_WARN_IF(!mOutFile))
+      return NS_ERROR_UNEXPECTED;
+    MOZ_ASSERT(!mStream);
+    mOutFile->OpenANSIFileDesc("w", &mStream);
+    if (NS_WARN_IF(!mStream))
+      return NS_ERROR_UNEXPECTED;
+    MozillaRegisterDebugFILE(mStream);
+
+    fprintf(mStream, "# WantAllTraces=%s\n", mWantAllTraces ? "true" : "false");
+
+    return NS_OK;
+  }
+  NS_IMETHOD NoteRefCountedObject(uint64_t aAddress, uint32_t refCount,
+                                  const char *aObjectDescription)
+  {
+    if (!mDisableLog) {
+      fprintf(mStream, "%p [rc=%u] %s\n", (void*)aAddress, refCount,
+              aObjectDescription);
     }
-    NS_IMETHOD ProcessNext(nsICycleCollectorHandler* aHandler,
-                           bool* aCanContinue)
-    {
-        if (NS_WARN_IF(!aHandler) || NS_WARN_IF(!mWantAfterProcessing))
-            return NS_ERROR_UNEXPECTED;
-        CCGraphDescriber* d = mDescribers.popFirst();
-        if (d) {
-            switch (d->mType) {
-                case CCGraphDescriber::eRefCountedObject:
-                    aHandler->NoteRefCountedObject(d->mAddress,
-                                                   d->mCnt,
-                                                   d->mName);
-                    break;
-                case CCGraphDescriber::eGCedObject:
-                case CCGraphDescriber::eGCMarkedObject:
-                    aHandler->NoteGCedObject(d->mAddress,
-                                             d->mType ==
-                                               CCGraphDescriber::eGCMarkedObject,
-                                             d->mName,
-                                             d->mCompartmentOrToAddress);
-                    break;
-                case CCGraphDescriber::eEdge:
-                    aHandler->NoteEdge(d->mAddress,
-                                       d->mCompartmentOrToAddress,
-                                       d->mName);
-                    break;
-                case CCGraphDescriber::eRoot:
-                    aHandler->DescribeRoot(d->mAddress,
-                                           d->mCnt);
-                    break;
-                case CCGraphDescriber::eGarbage:
-                    aHandler->DescribeGarbage(d->mAddress);
-                    break;
-                case CCGraphDescriber::eUnknown:
-                    NS_NOTREACHED("CCGraphDescriber::eUnknown");
-                    break;
-            }
-            delete d;
-        }
-        if (!(*aCanContinue = !mDescribers.isEmpty())) {
-            mCurrentAddress.AssignLiteral("0x");
-        }
-        return NS_OK;
+    if (mWantAfterProcessing) {
+      CCGraphDescriber* d =  new CCGraphDescriber();
+      mDescribers.insertBack(d);
+      mCurrentAddress.AssignLiteral("0x");
+      mCurrentAddress.AppendInt(aAddress, 16);
+      d->mType = CCGraphDescriber::eRefCountedObject;
+      d->mAddress = mCurrentAddress;
+      d->mCnt = refCount;
+      d->mName.Append(aObjectDescription);
     }
-private:
-    /**
-     * Create a new file named something like aPrefix.$PID.$IDENTIFIER.log in
-     * $MOZ_CC_LOG_DIRECTORY or in the system's temp directory.  No existing
-     * file will be overwritten; if aPrefix.$PID.$IDENTIFIER.log exists, we'll
-     * try a file named something like aPrefix.$PID.$IDENTIFIER-1.log, and so
-     * on.
-     */
-    already_AddRefed<nsIFile>
-    CreateTempFile(const char* aPrefix)
-    {
-        nsPrintfCString filename("%s.%d%s%s.log",
-            aPrefix,
-            base::GetCurrentProcId(),
-            mFilenameIdentifier.IsEmpty() ? "" : ".",
-            NS_ConvertUTF16toUTF8(mFilenameIdentifier).get());
-
-        // Get the log directory either from $MOZ_CC_LOG_DIRECTORY or from
-        // the fallback directories in OpenTempFile.  We don't use an nsCOMPtr
-        // here because OpenTempFile uses an in/out param and getter_AddRefs
-        // wouldn't work.
-        nsIFile* logFile = nullptr;
-        if (char* env = PR_GetEnv("MOZ_CC_LOG_DIRECTORY")) {
-            NS_NewNativeLocalFile(nsCString(env), /* followLinks = */ true,
-                                  &logFile);
-        }
-
-        // In Android case, this function will open a file named aFilename under
-        // specific folder (/data/local/tmp/memory-reports). Otherwise, it will
-        // open a file named aFilename under "NS_OS_TEMP_DIR".
-        nsresult rv = nsDumpUtils::OpenTempFile(
-                                     filename,
-                                     &logFile,
-                                     NS_LITERAL_CSTRING("memory-reports"));
-        if (NS_FAILED(rv)) {
-          NS_IF_RELEASE(logFile);
-          return nullptr;
-        }
-
-        return dont_AddRef(logFile);
+    return NS_OK;
+  }
+  NS_IMETHOD NoteGCedObject(uint64_t aAddress, bool aMarked,
+                            const char *aObjectDescription,
+                            uint64_t aCompartmentAddress)
+  {
+    if (!mDisableLog) {
+      fprintf(mStream, "%p [gc%s] %s\n", (void*)aAddress,
+              aMarked ? ".marked" : "", aObjectDescription);
     }
-
-    void ClearDescribers()
-    {
-      CCGraphDescriber* d;
-      while((d = mDescribers.popFirst())) {
-        delete d;
+    if (mWantAfterProcessing) {
+      CCGraphDescriber* d =  new CCGraphDescriber();
+      mDescribers.insertBack(d);
+      mCurrentAddress.AssignLiteral("0x");
+      mCurrentAddress.AppendInt(aAddress, 16);
+      d->mType = aMarked ? CCGraphDescriber::eGCMarkedObject :
+                           CCGraphDescriber::eGCedObject;
+      d->mAddress = mCurrentAddress;
+      d->mName.Append(aObjectDescription);
+      if (aCompartmentAddress) {
+        d->mCompartmentOrToAddress.AssignLiteral("0x");
+        d->mCompartmentOrToAddress.AppendInt(aCompartmentAddress, 16);
+      } else {
+        d->mCompartmentOrToAddress.SetIsVoid(true);
       }
     }
-
-    FILE *mStream;
-    nsCOMPtr<nsIFile> mOutFile;
-    bool mWantAllTraces;
-    bool mDisableLog;
-    bool mWantAfterProcessing;
-    nsString mFilenameIdentifier;
-    nsString mGCLogPath;
-    nsString mCCLogPath;
-    nsCString mCurrentAddress;
-    mozilla::LinkedList<CCGraphDescriber> mDescribers;
+    return NS_OK;
+  }
+  NS_IMETHOD NoteEdge(uint64_t aToAddress, const char *aEdgeName)
+  {
+    if (!mDisableLog) {
+      fprintf(mStream, "> %p %s\n", (void*)aToAddress, aEdgeName);
+    }
+    if (mWantAfterProcessing) {
+      CCGraphDescriber* d =  new CCGraphDescriber();
+      mDescribers.insertBack(d);
+      d->mType = CCGraphDescriber::eEdge;
+      d->mAddress = mCurrentAddress;
+      d->mCompartmentOrToAddress.AssignLiteral("0x");
+      d->mCompartmentOrToAddress.AppendInt(aToAddress, 16);
+      d->mName.Append(aEdgeName);
+    }
+    return NS_OK;
+  }
+  NS_IMETHOD NoteWeakMapEntry(uint64_t aMap, uint64_t aKey,
+                              uint64_t aKeyDelegate, uint64_t aValue)
+  {
+    if (!mDisableLog) {
+      fprintf(mStream, "WeakMapEntry map=%p key=%p keyDelegate=%p value=%p\n",
+              (void*)aMap, (void*)aKey, (void*)aKeyDelegate, (void*)aValue);
+    }
+    // We don't support after-processing for weak map entries.
+    return NS_OK;
+  }
+  NS_IMETHOD NoteIncrementalRoot(uint64_t aAddress)
+  {
+    if (!mDisableLog) {
+      fprintf(mStream, "IncrementalRoot %p\n", (void*)aAddress);
+    }
+    // We don't support after-processing for incremental roots.
+    return NS_OK;
+  }
+  NS_IMETHOD BeginResults()
+  {
+    if (!mDisableLog) {
+      fputs("==========\n", mStream);
+    }
+    return NS_OK;
+  }
+  NS_IMETHOD DescribeRoot(uint64_t aAddress, uint32_t aKnownEdges)
+  {
+    if (!mDisableLog) {
+      fprintf(mStream, "%p [known=%u]\n", (void*)aAddress, aKnownEdges);
+    }
+    if (mWantAfterProcessing) {
+      CCGraphDescriber* d =  new CCGraphDescriber();
+      mDescribers.insertBack(d);
+      d->mType = CCGraphDescriber::eRoot;
+      d->mAddress.AppendInt(aAddress, 16);
+      d->mCnt = aKnownEdges;
+    }
+    return NS_OK;
+  }
+  NS_IMETHOD DescribeGarbage(uint64_t aAddress)
+  {
+    if (!mDisableLog) {
+      fprintf(mStream, "%p [garbage]\n", (void*)aAddress);
+    }
+    if (mWantAfterProcessing) {
+      CCGraphDescriber* d =  new CCGraphDescriber();
+      mDescribers.insertBack(d);
+      d->mType = CCGraphDescriber::eGarbage;
+      d->mAddress.AppendInt(aAddress, 16);
+    }
+    return NS_OK;
+  }
+  NS_IMETHOD End()
+  {
+    if (!mDisableLog) {
+      MOZ_ASSERT(mStream);
+      MOZ_ASSERT(mOutFile);
+
+      MozillaUnRegisterDebugFILE(mStream);
+      fclose(mStream);
+      mStream = nullptr;
+
+      // Strip off "incomplete-" from the log file's name.
+      nsCOMPtr<nsIFile> logFileFinalDestination =
+        CreateTempFile("cc-edges");
+      if (NS_WARN_IF(!logFileFinalDestination))
+        return NS_ERROR_UNEXPECTED;
+
+      nsAutoString logFileFinalDestinationName;
+      logFileFinalDestination->GetLeafName(logFileFinalDestinationName);
+      if (NS_WARN_IF(logFileFinalDestinationName.IsEmpty()))
+        return NS_ERROR_UNEXPECTED;
+
+      mOutFile->MoveTo(/* directory = */ nullptr,
+                       logFileFinalDestinationName);
+      mOutFile = nullptr;
+
+      // Log to the error console.
+      nsCOMPtr<nsIConsoleService> cs =
+        do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+      if (cs) {
+        nsAutoString ccLogPath;
+        logFileFinalDestination->GetPath(ccLogPath);
+
+        nsString msg = NS_LITERAL_STRING("Cycle Collector log dumped to ") +
+                       ccLogPath;
+        cs->LogStringMessage(msg.get());
+
+        mCCLogPath = ccLogPath;
+      }
+    }
+    return NS_OK;
+  }
+  NS_IMETHOD ProcessNext(nsICycleCollectorHandler* aHandler,
+                         bool* aCanContinue)
+  {
+    if (NS_WARN_IF(!aHandler) || NS_WARN_IF(!mWantAfterProcessing))
+      return NS_ERROR_UNEXPECTED;
+    CCGraphDescriber* d = mDescribers.popFirst();
+    if (d) {
+      switch (d->mType) {
+        case CCGraphDescriber::eRefCountedObject:
+          aHandler->NoteRefCountedObject(d->mAddress,
+                                         d->mCnt,
+                                         d->mName);
+          break;
+        case CCGraphDescriber::eGCedObject:
+        case CCGraphDescriber::eGCMarkedObject:
+          aHandler->NoteGCedObject(d->mAddress,
+                                   d->mType ==
+                                     CCGraphDescriber::eGCMarkedObject,
+                                   d->mName,
+                                   d->mCompartmentOrToAddress);
+          break;
+        case CCGraphDescriber::eEdge:
+          aHandler->NoteEdge(d->mAddress,
+                             d->mCompartmentOrToAddress,
+                             d->mName);
+          break;
+        case CCGraphDescriber::eRoot:
+          aHandler->DescribeRoot(d->mAddress,
+                                 d->mCnt);
+          break;
+        case CCGraphDescriber::eGarbage:
+          aHandler->DescribeGarbage(d->mAddress);
+          break;
+        case CCGraphDescriber::eUnknown:
+          NS_NOTREACHED("CCGraphDescriber::eUnknown");
+          break;
+      }
+      delete d;
+    }
+    if (!(*aCanContinue = !mDescribers.isEmpty())) {
+      mCurrentAddress.AssignLiteral("0x");
+    }
+    return NS_OK;
+  }
+private:
+  /**
+   * Create a new file named something like aPrefix.$PID.$IDENTIFIER.log in
+   * $MOZ_CC_LOG_DIRECTORY or in the system's temp directory.  No existing
+   * file will be overwritten; if aPrefix.$PID.$IDENTIFIER.log exists, we'll
+   * try a file named something like aPrefix.$PID.$IDENTIFIER-1.log, and so
+   * on.
+   */
+  already_AddRefed<nsIFile>
+  CreateTempFile(const char* aPrefix)
+  {
+    nsPrintfCString filename("%s.%d%s%s.log",
+                             aPrefix,
+                             base::GetCurrentProcId(),
+                             mFilenameIdentifier.IsEmpty() ? "" : ".",
+                             NS_ConvertUTF16toUTF8(mFilenameIdentifier).get());
+
+    // Get the log directory either from $MOZ_CC_LOG_DIRECTORY or from
+    // the fallback directories in OpenTempFile.  We don't use an nsCOMPtr
+    // here because OpenTempFile uses an in/out param and getter_AddRefs
+    // wouldn't work.
+    nsIFile* logFile = nullptr;
+    if (char* env = PR_GetEnv("MOZ_CC_LOG_DIRECTORY")) {
+      NS_NewNativeLocalFile(nsCString(env), /* followLinks = */ true,
+                            &logFile);
+    }
+
+    // In Android case, this function will open a file named aFilename under
+    // specific folder (/data/local/tmp/memory-reports). Otherwise, it will
+    // open a file named aFilename under "NS_OS_TEMP_DIR".
+    nsresult rv = nsDumpUtils::OpenTempFile(
+      filename,
+      &logFile,
+      NS_LITERAL_CSTRING("memory-reports"));
+    if (NS_FAILED(rv)) {
+      NS_IF_RELEASE(logFile);
+      return nullptr;
+    }
+
+    return dont_AddRef(logFile);
+  }
+
+  void ClearDescribers()
+  {
+    CCGraphDescriber* d;
+    while((d = mDescribers.popFirst())) {
+      delete d;
+    }
+  }
+
+  FILE *mStream;
+  nsCOMPtr<nsIFile> mOutFile;
+  bool mWantAllTraces;
+  bool mDisableLog;
+  bool mWantAfterProcessing;
+  nsString mFilenameIdentifier;
+  nsString mGCLogPath;
+  nsString mCCLogPath;
+  nsCString mCurrentAddress;
+  mozilla::LinkedList<CCGraphDescriber> mDescribers;
 };
 
 NS_IMPL_ISUPPORTS(nsCycleCollectorLogger, nsICycleCollectorListener)
 
 nsresult
 nsCycleCollectorLoggerConstructor(nsISupports* aOuter,
                                   const nsIID& aIID,
                                   void* *aInstancePtr)
 {
-    if (NS_WARN_IF(aOuter))
-        return NS_ERROR_NO_AGGREGATION;
-
-    nsISupports *logger = new nsCycleCollectorLogger();
-
-    return logger->QueryInterface(aIID, aInstancePtr);
+  if (NS_WARN_IF(aOuter))
+    return NS_ERROR_NO_AGGREGATION;
+
+  nsISupports *logger = new nsCycleCollectorLogger();
+
+  return logger->QueryInterface(aIID, aInstancePtr);
 }
 
 ////////////////////////////////////////////////////////////////////////
 // Bacon & Rajan's |MarkRoots| routine.
 ////////////////////////////////////////////////////////////////////////
 
 class GCGraphBuilder : public nsCycleCollectionTraversalCallback,
                        public nsCycleCollectionNoteRootCallback
 {
 private:
-    GCGraph &mGraph;
-    CycleCollectorResults &mResults;
-    NodePool::Builder mNodeBuilder;
-    EdgePool::Builder mEdgeBuilder;
-    PtrInfo *mCurrPi;
-    nsCycleCollectionParticipant *mJSParticipant;
-    nsCycleCollectionParticipant *mJSZoneParticipant;
-    nsCString mNextEdgeName;
-    nsICycleCollectorListener *mListener;
-    bool mMergeZones;
-    bool mRanOutOfMemory;
+  GCGraph &mGraph;
+  CycleCollectorResults &mResults;
+  NodePool::Builder mNodeBuilder;
+  EdgePool::Builder mEdgeBuilder;
+  PtrInfo *mCurrPi;
+  nsCycleCollectionParticipant *mJSParticipant;
+  nsCycleCollectionParticipant *mJSZoneParticipant;
+  nsCString mNextEdgeName;
+  nsICycleCollectorListener *mListener;
+  bool mMergeZones;
+  bool mRanOutOfMemory;
 
 public:
-    GCGraphBuilder(GCGraph &aGraph,
-                   CycleCollectorResults &aResults,
-                   CycleCollectedJSRuntime *aJSRuntime,
-                   nsICycleCollectorListener *aListener,
-                   bool aMergeZones);
-    virtual ~GCGraphBuilder();
-
-    bool WantAllTraces() const
-    {
-        return nsCycleCollectionNoteRootCallback::WantAllTraces();
-    }
-
-    PtrInfo* AddNode(void *aPtr, nsCycleCollectionParticipant *aParticipant);
-    PtrInfo* AddWeakMapNode(void* node);
-    void Traverse(PtrInfo* aPtrInfo);
-    void SetLastChild();
-
-    bool RanOutOfMemory() const { return mRanOutOfMemory; }
+  GCGraphBuilder(GCGraph &aGraph,
+                 CycleCollectorResults &aResults,
+                 CycleCollectedJSRuntime *aJSRuntime,
+                 nsICycleCollectorListener *aListener,
+                 bool aMergeZones);
+  virtual ~GCGraphBuilder();
+
+  bool WantAllTraces() const
+  {
+    return nsCycleCollectionNoteRootCallback::WantAllTraces();
+  }
+
+  PtrInfo* AddNode(void *aPtr, nsCycleCollectionParticipant *aParticipant);
+  PtrInfo* AddWeakMapNode(void* node);
+  void Traverse(PtrInfo* aPtrInfo);
+  void SetLastChild();
+
+  bool RanOutOfMemory() const { return mRanOutOfMemory; }
 
 private:
-    void DescribeNode(uint32_t refCount, const char *objName)
-    {
-        mCurrPi->mRefCount = refCount;
-    }
+  void DescribeNode(uint32_t refCount, const char *objName)
+  {
+    mCurrPi->mRefCount = refCount;
+  }
 
 public:
-    // nsCycleCollectionNoteRootCallback methods.
-    NS_IMETHOD_(void) NoteXPCOMRoot(nsISupports *root);
-    NS_IMETHOD_(void) NoteJSRoot(void *root);
-    NS_IMETHOD_(void) NoteNativeRoot(void *root, nsCycleCollectionParticipant *participant);
-    NS_IMETHOD_(void) NoteWeakMapping(void *map, void *key, void *kdelegate, void *val);
-
-    // nsCycleCollectionTraversalCallback methods.
-    NS_IMETHOD_(void) DescribeRefCountedNode(nsrefcnt refCount,
-                                             const char *objName);
-    NS_IMETHOD_(void) DescribeGCedNode(bool isMarked, const char *objName,
-                                       uint64_t aCompartmentAddress);
-
-    NS_IMETHOD_(void) NoteXPCOMChild(nsISupports *child);
-    NS_IMETHOD_(void) NoteJSChild(void *child);
-    NS_IMETHOD_(void) NoteNativeChild(void *child,
-                                      nsCycleCollectionParticipant *participant);
-    NS_IMETHOD_(void) NoteNextEdgeName(const char* name);
+  // nsCycleCollectionNoteRootCallback methods.
+  NS_IMETHOD_(void) NoteXPCOMRoot(nsISupports *root);
+  NS_IMETHOD_(void) NoteJSRoot(void *root);
+  NS_IMETHOD_(void) NoteNativeRoot(void *root, nsCycleCollectionParticipant *participant);
+  NS_IMETHOD_(void) NoteWeakMapping(void *map, void *key, void *kdelegate, void *val);
+
+  // nsCycleCollectionTraversalCallback methods.
+  NS_IMETHOD_(void) DescribeRefCountedNode(nsrefcnt refCount,
+                                           const char *objName);
+  NS_IMETHOD_(void) DescribeGCedNode(bool isMarked, const char *objName,
+                                     uint64_t aCompartmentAddress);
+
+  NS_IMETHOD_(void) NoteXPCOMChild(nsISupports *child);
+  NS_IMETHOD_(void) NoteJSChild(void *child);
+  NS_IMETHOD_(void) NoteNativeChild(void *child,
+                                    nsCycleCollectionParticipant *participant);
+  NS_IMETHOD_(void) NoteNextEdgeName(const char* name);
 
 private:
-    NS_IMETHOD_(void) NoteRoot(void *root,
-                               nsCycleCollectionParticipant *participant)
-    {
-        MOZ_ASSERT(root);
-        MOZ_ASSERT(participant);
-
-        if (!participant->CanSkipInCC(root) || MOZ_UNLIKELY(WantAllTraces())) {
-            AddNode(root, participant);
-        }
+  NS_IMETHOD_(void) NoteRoot(void *root,
+                             nsCycleCollectionParticipant *participant)
+  {
+    MOZ_ASSERT(root);
+    MOZ_ASSERT(participant);
+
+    if (!participant->CanSkipInCC(root) || MOZ_UNLIKELY(WantAllTraces())) {
+      AddNode(root, participant);
     }
-
-    NS_IMETHOD_(void) NoteChild(void *child, nsCycleCollectionParticipant *cp,
-                                nsCString edgeName)
-    {
-        PtrInfo *childPi = AddNode(child, cp);
-        if (!childPi)
-            return;
-        mEdgeBuilder.Add(childPi);
-        if (mListener) {
-            mListener->NoteEdge((uint64_t)child, edgeName.get());
-        }
-        ++childPi->mInternalRefs;
+  }
+
+  NS_IMETHOD_(void) NoteChild(void *child, nsCycleCollectionParticipant *cp,
+                              nsCString edgeName)
+  {
+    PtrInfo *childPi = AddNode(child, cp);
+    if (!childPi)
+      return;
+    mEdgeBuilder.Add(childPi);
+    if (mListener) {
+      mListener->NoteEdge((uint64_t)child, edgeName.get());
     }
-
-    JS::Zone *MergeZone(void *gcthing) {
-        if (!mMergeZones) {
-            return nullptr;
-        }
-        JS::Zone *zone = JS::GetGCThingZone(gcthing);
-        if (js::IsSystemZone(zone)) {
-            return nullptr;
-        }
-        return zone;
+    ++childPi->mInternalRefs;
+  }
+
+  JS::Zone *MergeZone(void *gcthing) {
+    if (!mMergeZones) {
+      return nullptr;
     }
+    JS::Zone *zone = JS::GetGCThingZone(gcthing);
+    if (js::IsSystemZone(zone)) {
+      return nullptr;
+    }
+    return zone;
+  }
 };
 
 GCGraphBuilder::GCGraphBuilder(GCGraph &aGraph,
                                CycleCollectorResults &aResults,
                                CycleCollectedJSRuntime *aJSRuntime,
                                nsICycleCollectorListener *aListener,
                                bool aMergeZones)
-    : mGraph(aGraph),
-      mResults(aResults),
-      mNodeBuilder(aGraph.mNodes),
-      mEdgeBuilder(aGraph.mEdges),
-      mJSParticipant(nullptr),
-      mJSZoneParticipant(nullptr),
-      mListener(aListener),
-      mMergeZones(aMergeZones),
-      mRanOutOfMemory(false)
+  : mGraph(aGraph),
+    mResults(aResults),
+    mNodeBuilder(aGraph.mNodes),
+    mEdgeBuilder(aGraph.mEdges),
+    mJSParticipant(nullptr),
+    mJSZoneParticipant(nullptr),
+    mListener(aListener),
+    mMergeZones(aMergeZones),
+    mRanOutOfMemory(false)
 {
-    if (aJSRuntime) {
-        mJSParticipant = aJSRuntime->GCThingParticipant();
-        mJSZoneParticipant = aJSRuntime->ZoneParticipant();
+  if (aJSRuntime) {
+    mJSParticipant = aJSRuntime->GCThingParticipant();
+    mJSZoneParticipant = aJSRuntime->ZoneParticipant();
+  }
+
+  uint32_t flags = 0;
+  if (!flags && mListener) {
+    flags = nsCycleCollectionTraversalCallback::WANT_DEBUG_INFO;
+    bool all = false;
+    mListener->GetWantAllTraces(&all);
+    if (all) {
+      flags |= nsCycleCollectionTraversalCallback::WANT_ALL_TRACES;
+      mWantAllTraces = true; // for nsCycleCollectionNoteRootCallback
     }
-
-    uint32_t flags = 0;
-    if (!flags && mListener) {
-        flags = nsCycleCollectionTraversalCallback::WANT_DEBUG_INFO;
-        bool all = false;
-        mListener->GetWantAllTraces(&all);
-        if (all) {
-            flags |= nsCycleCollectionTraversalCallback::WANT_ALL_TRACES;
-            mWantAllTraces = true; // for nsCycleCollectionNoteRootCallback
-        }
-    }
-
-    mFlags |= flags;
-
-    mMergeZones = mMergeZones && MOZ_LIKELY(!WantAllTraces());
-
-    MOZ_ASSERT(nsCycleCollectionNoteRootCallback::WantAllTraces() ==
-               nsCycleCollectionTraversalCallback::WantAllTraces());
+  }
+
+  mFlags |= flags;
+
+  mMergeZones = mMergeZones && MOZ_LIKELY(!WantAllTraces());
+
+  MOZ_ASSERT(nsCycleCollectionNoteRootCallback::WantAllTraces() ==
+             nsCycleCollectionTraversalCallback::WantAllTraces());
 }
 
 GCGraphBuilder::~GCGraphBuilder()
 {
 }
 
 PtrInfo*
 GCGraphBuilder::AddNode(void *aPtr, nsCycleCollectionParticipant *aParticipant)
 {
-    PtrToNodeEntry *e = mGraph.AddNodeToMap(aPtr);
-    if (!e) {
-        mRanOutOfMemory = true;
-        return nullptr;
-    }
-
-    PtrInfo *result;
-    if (!e->mNode) {
-        // New entry.
-        result = mNodeBuilder.Add(aPtr, aParticipant);
-        e->mNode = result;
-        NS_ASSERTION(result, "mNodeBuilder.Add returned null");
-    } else {
-        result = e->mNode;
-        MOZ_ASSERT(result->mParticipant == aParticipant,
-                   "nsCycleCollectionParticipant shouldn't change!");
-    }
-    return result;
+  PtrToNodeEntry *e = mGraph.AddNodeToMap(aPtr);
+  if (!e) {
+    mRanOutOfMemory = true;
+    return nullptr;
+  }
+
+  PtrInfo *result;
+  if (!e->mNode) {
+    // New entry.
+    result = mNodeBuilder.Add(aPtr, aParticipant);
+    e->mNode = result;
+    NS_ASSERTION(result, "mNodeBuilder.Add returned null");
+  } else {
+    result = e->mNode;
+    MOZ_ASSERT(result->mParticipant == aParticipant,
+               "nsCycleCollectionParticipant shouldn't change!");
+  }
+  return result;
 }
 
 MOZ_NEVER_INLINE void
 GCGraphBuilder::Traverse(PtrInfo* aPtrInfo)
 {
-    mCurrPi = aPtrInfo;
-
-    mCurrPi->SetFirstChild(mEdgeBuilder.Mark());
-
-    if (!aPtrInfo->mParticipant) {
-        return;
-    }
-
-    nsresult rv = aPtrInfo->mParticipant->Traverse(aPtrInfo->mPointer, *this);
-    if (NS_FAILED(rv)) {
-        Fault("script pointer traversal failed", aPtrInfo);
-    }
+  mCurrPi = aPtrInfo;
+
+  mCurrPi->SetFirstChild(mEdgeBuilder.Mark());
+
+  if (!aPtrInfo->mParticipant) {
+    return;
+  }
+
+  nsresult rv = aPtrInfo->mParticipant->Traverse(aPtrInfo->mPointer, *this);
+  if (NS_FAILED(rv)) {
+    Fault("script pointer traversal failed", aPtrInfo);
+  }
 }
 
 void
 GCGraphBuilder::SetLastChild()
 {
-    mCurrPi->SetLastChild(mEdgeBuilder.Mark());
+  mCurrPi->SetLastChild(mEdgeBuilder.Mark());
 }
 
 NS_IMETHODIMP_(void)
 GCGraphBuilder::NoteXPCOMRoot(nsISupports *root)
 {
-    root = CanonicalizeXPCOMParticipant(root);
-    NS_ASSERTION(root,
-                 "Don't add objects that don't participate in collection!");
-
-    nsXPCOMCycleCollectionParticipant *cp;
-    ToParticipant(root, &cp);
-
-    NoteRoot(root, cp);
+  root = CanonicalizeXPCOMParticipant(root);
+  NS_ASSERTION(root,
+               "Don't add objects that don't participate in collection!");
+
+  nsXPCOMCycleCollectionParticipant *cp;
+  ToParticipant(root, &cp);
+
+  NoteRoot(root, cp);
 }
 
 NS_IMETHODIMP_(void)
 GCGraphBuilder::NoteJSRoot(void *root)
 {
-    if (JS::Zone *zone = MergeZone(root)) {
-        NoteRoot(zone, mJSZoneParticipant);
-    } else {
-        NoteRoot(root, mJSParticipant);
-    }
+  if (JS::Zone *zone = MergeZone(root)) {
+    NoteRoot(zone, mJSZoneParticipant);
+  } else {
+    NoteRoot(root, mJSParticipant);
+  }
 }
 
 NS_IMETHODIMP_(void)
 GCGraphBuilder::NoteNativeRoot(void *root, nsCycleCollectionParticipant *participant)
 {
-    NoteRoot(root, participant);
+  NoteRoot(root, participant);
 }
 
 NS_IMETHODIMP_(void)
 GCGraphBuilder::DescribeRefCountedNode(nsrefcnt refCount, const char *objName)
 {
-    if (refCount == 0)
-        Fault("zero refcount", mCurrPi);
-    if (refCount == UINT32_MAX)
-        Fault("overflowing refcount", mCurrPi);
-    mResults.mVisitedRefCounted++;
-
-    if (mListener) {
-        mListener->NoteRefCountedObject((uint64_t)mCurrPi->mPointer, refCount,
-                                        objName);
-    }
-
-    DescribeNode(refCount, objName);
+  if (refCount == 0)
+    Fault("zero refcount", mCurrPi);
+  if (refCount == UINT32_MAX)
+    Fault("overflowing refcount", mCurrPi);
+  mResults.mVisitedRefCounted++;
+
+  if (mListener) {
+    mListener->NoteRefCountedObject((uint64_t)mCurrPi->mPointer, refCount,
+                                    objName);
+  }
+
+  DescribeNode(refCount, objName);
 }
 
 NS_IMETHODIMP_(void)
 GCGraphBuilder::DescribeGCedNode(bool isMarked, const char *objName,
                                  uint64_t aCompartmentAddress)
 {
-    uint32_t refCount = isMarked ? UINT32_MAX : 0;
-    mResults.mVisitedGCed++;
-
-    if (mListener) {
-        mListener->NoteGCedObject((uint64_t)mCurrPi->mPointer, isMarked,
-                                  objName, aCompartmentAddress);
-    }
-
-    DescribeNode(refCount, objName);
+  uint32_t refCount = isMarked ? UINT32_MAX : 0;
+  mResults.mVisitedGCed++;
+
+  if (mListener) {
+    mListener->NoteGCedObject((uint64_t)mCurrPi->mPointer, isMarked,
+                              objName, aCompartmentAddress);
+  }
+
+  DescribeNode(refCount, objName);
 }
 
 NS_IMETHODIMP_(void)
 GCGraphBuilder::NoteXPCOMChild(nsISupports *child)
 {
-    nsCString edgeName;
-    if (WantDebugInfo()) {
-        edgeName.Assign(mNextEdgeName);
-        mNextEdgeName.Truncate();
-    }
-    if (!child || !(child = CanonicalizeXPCOMParticipant(child)))
-        return;
-
-    nsXPCOMCycleCollectionParticipant *cp;
-    ToParticipant(child, &cp);
-    if (cp && (!cp->CanSkipThis(child) || WantAllTraces())) {
-        NoteChild(child, cp, edgeName);
-    }
+  nsCString edgeName;
+  if (WantDebugInfo()) {
+    edgeName.Assign(mNextEdgeName);
+    mNextEdgeName.Truncate();
+  }
+  if (!child || !(child = CanonicalizeXPCOMParticipant(child)))
+    return;
+
+  nsXPCOMCycleCollectionParticipant *cp;
+  ToParticipant(child, &cp);
+  if (cp && (!cp->CanSkipThis(child) || WantAllTraces())) {
+    NoteChild(child, cp, edgeName);
+  }
 }
 
 NS_IMETHODIMP_(void)
 GCGraphBuilder::NoteNativeChild(void *child,
                                 nsCycleCollectionParticipant *participant)
 {
-    nsCString edgeName;
-    if (WantDebugInfo()) {
-        edgeName.Assign(mNextEdgeName);
-        mNextEdgeName.Truncate();
-    }
-    if (!child)
-        return;
-
-    MOZ_ASSERT(participant, "Need a nsCycleCollectionParticipant!");
-    NoteChild(child, participant, edgeName);
+  nsCString edgeName;
+  if (WantDebugInfo()) {
+    edgeName.Assign(mNextEdgeName);
+    mNextEdgeName.Truncate();
+  }
+  if (!child)
+    return;
+
+  MOZ_ASSERT(participant, "Need a nsCycleCollectionParticipant!");
+  NoteChild(child, participant, edgeName);
 }
 
 NS_IMETHODIMP_(void)
 GCGraphBuilder::NoteJSChild(void *child)
 {
-    if (!child) {
-        return;
-    }
-
-    nsCString edgeName;
-    if (MOZ_UNLIKELY(WantDebugInfo())) {
-        edgeName.Assign(mNextEdgeName);
-        mNextEdgeName.Truncate();
+  if (!child) {
+    return;
+  }
+
+  nsCString edgeName;
+  if (MOZ_UNLIKELY(WantDebugInfo())) {
+    edgeName.Assign(mNextEdgeName);
+    mNextEdgeName.Truncate();
+  }
+
+  if (xpc_GCThingIsGrayCCThing(child) || MOZ_UNLIKELY(WantAllTraces())) {
+    if (JS::Zone *zone = MergeZone(child)) {
+      NoteChild(zone, mJSZoneParticipant, edgeName);
+    } else {
+      NoteChild(child, mJSParticipant, edgeName);
     }
-
-    if (xpc_GCThingIsGrayCCThing(child) || MOZ_UNLIKELY(WantAllTraces())) {
-        if (JS::Zone *zone = MergeZone(child)) {
-            NoteChild(zone, mJSZoneParticipant, edgeName);
-        } else {
-            NoteChild(child, mJSParticipant, edgeName);
-        }
-    }
+  }
 }
 
 NS_IMETHODIMP_(void)
 GCGraphBuilder::NoteNextEdgeName(const char* name)
 {
-    if (WantDebugInfo()) {
-        mNextEdgeName = name;
-    }
+  if (WantDebugInfo()) {
+    mNextEdgeName = name;
+  }
 }
 
 PtrInfo*
 GCGraphBuilder::AddWeakMapNode(void *node)
 {
-    MOZ_ASSERT(node, "Weak map node should be non-null.");
-
-    if (!xpc_GCThingIsGrayCCThing(node) && !WantAllTraces())
-        return nullptr;
-
-    if (JS::Zone *zone = MergeZone(node)) {
-        return AddNode(zone, mJSZoneParticipant);
-    } else {
-        return AddNode(node, mJSParticipant);
-    }
+  MOZ_ASSERT(node, "Weak map node should be non-null.");
+
+  if (!xpc_GCThingIsGrayCCThing(node) && !WantAllTraces())
+    return nullptr;
+
+  if (JS::Zone *zone = MergeZone(node)) {
+    return AddNode(zone, mJSZoneParticipant);
+  } else {
+    return AddNode(node, mJSParticipant);
+  }
 }
 
 NS_IMETHODIMP_(void)
 GCGraphBuilder::NoteWeakMapping(void *map, void *key, void *kdelegate, void *val)
 {
-    // Don't try to optimize away the entry here, as we've already attempted to
-    // do that in TraceWeakMapping in nsXPConnect.
-    WeakMapping *mapping = mGraph.mWeakMaps.AppendElement();
-    mapping->mMap = map ? AddWeakMapNode(map) : nullptr;
-    mapping->mKey = key ? AddWeakMapNode(key) : nullptr;
-    mapping->mKeyDelegate = kdelegate ? AddWeakMapNode(kdelegate) : mapping->mKey;
-    mapping->mVal = val ? AddWeakMapNode(val) : nullptr;
-
-    if (mListener) {
-        mListener->NoteWeakMapEntry((uint64_t)map, (uint64_t)key,
-                                    (uint64_t)kdelegate, (uint64_t)val);
-    }
+  // Don't try to optimize away the entry here, as we've already attempted to
+  // do that in TraceWeakMapping in nsXPConnect.
+  WeakMapping *mapping = mGraph.mWeakMaps.AppendElement();
+  mapping->mMap = map ? AddWeakMapNode(map) : nullptr;
+  mapping->mKey = key ? AddWeakMapNode(key) : nullptr;
+  mapping->mKeyDelegate = kdelegate ? AddWeakMapNode(kdelegate) : mapping->mKey;
+  mapping->mVal = val ? AddWeakMapNode(val) : nullptr;
+
+  if (mListener) {
+    mListener->NoteWeakMapEntry((uint64_t)map, (uint64_t)key,
+                                (uint64_t)kdelegate, (uint64_t)val);
+  }
 }
 
 static bool
 AddPurpleRoot(GCGraphBuilder &aBuilder, void *aRoot, nsCycleCollectionParticipant *aParti)
 {
-    CanonicalizeParticipant(&aRoot, &aParti);
-
-    if (aBuilder.WantAllTraces() || !aParti->CanSkipInCC(aRoot)) {
-        PtrInfo *pinfo = aBuilder.AddNode(aRoot, aParti);
-        if (!pinfo) {
-            return false;
-        }
+  CanonicalizeParticipant(&aRoot, &aParti);
+
+  if (aBuilder.WantAllTraces() || !aParti->CanSkipInCC(aRoot)) {
+    PtrInfo *pinfo = aBuilder.AddNode(aRoot, aParti);
+    if (!pinfo) {
+      return false;
     }
-
-    return true;
+  }
+
+  return true;
 }
 
 // MayHaveChild() will be false after a Traverse if the object does
 // not have any children the CC will visit.
 class ChildFinder : public nsCycleCollectionTraversalCallback
 {
 public:
-    ChildFinder() : mMayHaveChild(false) {}
-
-    // The logic of the Note*Child functions must mirror that of their
-    // respective functions in GCGraphBuilder.
-    NS_IMETHOD_(void) NoteXPCOMChild(nsISupports *child);
-    NS_IMETHOD_(void) NoteNativeChild(void *child,
-                                      nsCycleCollectionParticipant *helper);
-    NS_IMETHOD_(void) NoteJSChild(void *child);
-
-    NS_IMETHOD_(void) DescribeRefCountedNode(nsrefcnt refcount,
-                                             const char *objname) {}
-    NS_IMETHOD_(void) DescribeGCedNode(bool ismarked,
-                                       const char *objname,
-                                       uint64_t aCompartmentAddress) {}
-    NS_IMETHOD_(void) NoteNextEdgeName(const char* name) {}
-    bool MayHaveChild() {
-        return mMayHaveChild;
-    }
+  ChildFinder() : mMayHaveChild(false) {}
+
+  // The logic of the Note*Child functions must mirror that of their
+  // respective functions in GCGraphBuilder.
+  NS_IMETHOD_(void) NoteXPCOMChild(nsISupports *child);
+  NS_IMETHOD_(void) NoteNativeChild(void *child,
+                                    nsCycleCollectionParticipant *helper);
+  NS_IMETHOD_(void) NoteJSChild(void *child);
+
+  NS_IMETHOD_(void) DescribeRefCountedNode(nsrefcnt refcount,
+                                           const char *objname) {}
+  NS_IMETHOD_(void) DescribeGCedNode(bool ismarked,
+                                     const char *objname,
+                                     uint64_t aCompartmentAddress) {}
+  NS_IMETHOD_(void) NoteNextEdgeName(const char* name) {}
+  bool MayHaveChild() {
+    return mMayHaveChild;
+  }
 private:
-    bool mMayHaveChild;
+  bool mMayHaveChild;
 };
 
 NS_IMETHODIMP_(void)
 ChildFinder::NoteXPCOMChild(nsISupports *child)
 {
-    if (!child || !(child = CanonicalizeXPCOMParticipant(child)))
-        return;
-    nsXPCOMCycleCollectionParticipant *cp;
-    ToParticipant(child, &cp);
-    if (cp && !cp->CanSkip(child, true))
-        mMayHaveChild = true;
+  if (!child || !(child = CanonicalizeXPCOMParticipant(child)))
+    return;
+  nsXPCOMCycleCollectionParticipant *cp;
+  ToParticipant(child, &cp);
+  if (cp && !cp->CanSkip(child, true))
+    mMayHaveChild = true;
 }
 
 NS_IMETHODIMP_(void)
 ChildFinder::NoteNativeChild(void *child,
                              nsCycleCollectionParticipant *helper)
 {
-    if (child)
-        mMayHaveChild = true;
+  if (child)
+    mMayHaveChild = true;
 }
 
 NS_IMETHODIMP_(void)
 ChildFinder::NoteJSChild(void *child)
 {
-    if (child && xpc_GCThingIsGrayCCThing(child)) {
-        mMayHaveChild = true;
-    }
+  if (child && xpc_GCThingIsGrayCCThing(child)) {
+    mMayHaveChild = true;
+  }
 }
 
 static bool
 MayHaveChild(void *o, nsCycleCollectionParticipant* cp)
 {
-    ChildFinder cf;
-    cp->Traverse(o, cf);
-    return cf.MayHaveChild();
+  ChildFinder cf;
+  cp->Traverse(o, cf);
+  return cf.MayHaveChild();
 }
 
 template<class T>
 class SegmentedArrayElement : public LinkedListElement<SegmentedArrayElement<T>>
                             , public AutoFallibleTArray<T, 60>
 {
 };
 
 template<class T>
 class SegmentedArray
 {
 public:
-    ~SegmentedArray()
-    {
-        MOZ_ASSERT(IsEmpty());
-    }
-
-    void AppendElement(T& aElement)
-    {
-        SegmentedArrayElement<T>* last = mSegments.getLast();
-        if (!last || last->Length() == last->Capacity()) {
-            last = new SegmentedArrayElement<T>();
-            mSegments.insertBack(last);
-        }
-        last->AppendElement(aElement);
+  ~SegmentedArray()
+  {
+    MOZ_ASSERT(IsEmpty());
+  }
+
+  void AppendElement(T& aElement)
+  {
+    SegmentedArrayElement<T>* last = mSegments.getLast();
+    if (!last || last->Length() == last->Capacity()) {
+      last = new SegmentedArrayElement<T>();
+      mSegments.insertBack(last);
     }
-
-    void Clear()
-    {
-        SegmentedArrayElement<T>* first;
-        while ((first = mSegments.popFirst())) {
-            delete first;
-        }
+    last->AppendElement(aElement);
+  }
+
+  void Clear()
+  {
+    SegmentedArrayElement<T>* first;
+    while ((first = mSegments.popFirst())) {
+      delete first;
     }
-
-    SegmentedArrayElement<T>* GetFirstSegment()
-    {
-        return mSegments.getFirst();
-    }
-
-    bool IsEmpty()
-    {
-        return !GetFirstSegment();
-    }
+  }
+
+  SegmentedArrayElement<T>* GetFirstSegment()
+  {
+    return mSegments.getFirst();
+  }
+
+  bool IsEmpty()
+  {
+    return !GetFirstSegment();
+  }
 
 private:
-    mozilla::LinkedList<SegmentedArrayElement<T>> mSegments;
+  mozilla::LinkedList<SegmentedArrayElement<T>> mSegments;
 };
 
 // JSPurpleBuffer keeps references to GCThings which might affect the
 // next cycle collection. It is owned only by itself and during unlink its
 // self reference is broken down and the object ends up killing itself.
 // If GC happens before CC, references to GCthings and the self reference are
 // removed.
 class JSPurpleBuffer
 {
 public:
-    JSPurpleBuffer(JSPurpleBuffer*& aReferenceToThis)
-      : mReferenceToThis(aReferenceToThis)
-    {
-        mReferenceToThis = this;
-        NS_ADDREF_THIS();
-        mozilla::HoldJSObjects(this);
-    }
-
-    ~JSPurpleBuffer()
-    {
-        MOZ_ASSERT(mValues.IsEmpty());
-        MOZ_ASSERT(mObjects.IsEmpty());
-        MOZ_ASSERT(mTenuredObjects.IsEmpty());
-    }
-
-    void Destroy()
-    {
-        mReferenceToThis = nullptr;
-        mValues.Clear();
-        mObjects.Clear();
-        mTenuredObjects.Clear();
-        mozilla::DropJSObjects(this);
-        NS_RELEASE_THIS();
-    }
-
-    NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(JSPurpleBuffer)
-    NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(JSPurpleBuffer)
-
-    JSPurpleBuffer*& mReferenceToThis;
-    SegmentedArray<JS::Heap<JS::Value>> mValues;
-    SegmentedArray<JS::Heap<JSObject*>> mObjects;
-    SegmentedArray<JS::TenuredHeap<JSObject*>> mTenuredObjects;
+  JSPurpleBuffer(JSPurpleBuffer*& aReferenceToThis)
+    : mReferenceToThis(aReferenceToThis)
+  {
+    mReferenceToThis = this;
+    NS_ADDREF_THIS();
+    mozilla::HoldJSObjects(this);
+  }
+
+  ~JSPurpleBuffer()
+  {
+    MOZ_ASSERT(mValues.IsEmpty());
+    MOZ_ASSERT(mObjects.IsEmpty());
+    MOZ_ASSERT(mTenuredObjects.IsEmpty());
+  }
+
+  void Destroy()
+  {
+    mReferenceToThis = nullptr;
+    mValues.Clear();
+    mObjects.Clear();
+    mTenuredObjects.Clear();
+    mozilla::DropJSObjects(this);
+    NS_RELEASE_THIS();
+  }
+
+  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(JSPurpleBuffer)
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(JSPurpleBuffer)
+
+  JSPurpleBuffer*& mReferenceToThis;
+  SegmentedArray<JS::Heap<JS::Value>> mValues;
+  SegmentedArray<JS::Heap<JSObject*>> mObjects;
+  SegmentedArray<JS::TenuredHeap<JSObject*>> mTenuredObjects;
 };
 
 NS_IMPL_CYCLE_COLLECTION_CLASS(JSPurpleBuffer)
 
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(JSPurpleBuffer)
-    tmp->Destroy();
+  tmp->Destroy();
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(JSPurpleBuffer)
-    CycleCollectionNoteChild(cb, tmp, "self");
-    NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
+  CycleCollectionNoteChild(cb, tmp, "self");
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
 #define NS_TRACE_SEGMENTED_ARRAY(_field)                                       \
     {                                                                          \
         auto segment = tmp->_field.GetFirstSegment();                          \
         while (segment) {                                                      \
             for (uint32_t i = segment->Length(); i > 0;) {                     \
                 aCallbacks.Trace(&segment->ElementAt(--i), #_field, aClosure); \
             }                                                                  \
             segment = segment->getNext();                                      \
         }                                                                      \
     }
 
 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(JSPurpleBuffer)
-    NS_TRACE_SEGMENTED_ARRAY(mValues)
-    NS_TRACE_SEGMENTED_ARRAY(mObjects)
-    NS_TRACE_SEGMENTED_ARRAY(mTenuredObjects)
+  NS_TRACE_SEGMENTED_ARRAY(mValues)
+  NS_TRACE_SEGMENTED_ARRAY(mObjects)
+  NS_TRACE_SEGMENTED_ARRAY(mTenuredObjects)
 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 
 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(JSPurpleBuffer, AddRef)
 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(JSPurpleBuffer, Release)
 
 struct SnowWhiteObject
 {
   void* mPointer;
   nsCycleCollectionParticipant* mParticipant;
   nsCycleCollectingAutoRefCnt* mRefCnt;
 };
 
 class SnowWhiteKiller : public TraceCallbacks
 {
 public:
-    SnowWhiteKiller(nsCycleCollector *aCollector, uint32_t aMaxCount)
-        : mCollector(aCollector)
-    {
-        MOZ_ASSERT(mCollector, "Calling SnowWhiteKiller after nsCC went away");
-        while (true) {
-            if (mObjects.SetCapacity(aMaxCount)) {
-                break;
-            }
-            if (aMaxCount == 1) {
-                NS_RUNTIMEABORT("Not enough memory to even delete objects!");
-            }
-            aMaxCount /= 2;
-        }
+  SnowWhiteKiller(nsCycleCollector *aCollector, uint32_t aMaxCount)
+    : mCollector(aCollector)
+  {
+    MOZ_ASSERT(mCollector, "Calling SnowWhiteKiller after nsCC went away");
+    while (true) {
+      if (mObjects.SetCapacity(aMaxCount)) {
+        break;
+      }
+      if (aMaxCount == 1) {
+        NS_RUNTIMEABORT("Not enough memory to even delete objects!");
+      }
+      aMaxCount /= 2;
     }
-
-    ~SnowWhiteKiller()
-    {
-        for (uint32_t i = 0; i < mObjects.Length(); ++i) {
-            SnowWhiteObject& o = mObjects[i];
-            if (!o.mRefCnt->get() && !o.mRefCnt->IsInPurpleBuffer()) {
-                mCollector->RemoveObjectFromGraph(o.mPointer);
-                o.mRefCnt->stabilizeForDeletion();
-                o.mParticipant->Trace(o.mPointer, *this, nullptr);
-                o.mParticipant->DeleteCycleCollectable(o.mPointer);
-            }
-        }
+  }
+
+  ~SnowWhiteKiller()
+  {
+    for (uint32_t i = 0; i < mObjects.Length(); ++i) {
+      SnowWhiteObject& o = mObjects[i];
+      if (!o.mRefCnt->get() && !o.mRefCnt->IsInPurpleBuffer()) {
+        mCollector->RemoveObjectFromGraph(o.mPointer);
+        o.mRefCnt->stabilizeForDeletion();
+        o.mParticipant->Trace(o.mPointer, *this, nullptr);
+        o.mParticipant->DeleteCycleCollectable(o.mPointer);
+      }
     }
-
-    void
-    Visit(nsPurpleBuffer& aBuffer, nsPurpleBufferEntry* aEntry)
-    {
-        MOZ_ASSERT(aEntry->mObject, "Null object in purple buffer");
-        if (!aEntry->mRefCnt->get()) {
-            void *o = aEntry->mObject;
-            nsCycleCollectionParticipant *cp = aEntry->mParticipant;
-            CanonicalizeParticipant(&o, &cp);
-            SnowWhiteObject swo = { o, cp, aEntry->mRefCnt };
-            if (mObjects.AppendElement(swo)) {
-                aBuffer.Remove(aEntry);
-            }
-        }
-    }
-
-    bool HasSnowWhiteObjects() const
-    {
-      return mObjects.Length() > 0;
+  }
+
+  void
+  Visit(nsPurpleBuffer& aBuffer, nsPurpleBufferEntry* aEntry)
+  {
+    MOZ_ASSERT(aEntry->mObject, "Null object in purple buffer");
+    if (!aEntry->mRefCnt->get()) {
+      void *o = aEntry->mObject;
+      nsCycleCollectionParticipant *cp = aEntry->mParticipant;
+      CanonicalizeParticipant(&o, &cp);
+      SnowWhiteObject swo = { o, cp, aEntry->mRefCnt };
+      if (mObjects.AppendElement(swo)) {
+        aBuffer.Remove(aEntry);
+      }
     }
-
-    virtual void Trace(JS::Heap<JS::Value>* aValue, const char* aName,
-                       void* aClosure) const
-    {
-        if (aValue->isMarkable()) {
-            void* thing = aValue->toGCThing();
-            if (thing && xpc_GCThingIsGrayCCThing(thing)) {
-                mCollector->GetJSPurpleBuffer()->mValues.AppendElement(*aValue);
-            }
-        }
-    }
-
-    virtual void Trace(JS::Heap<jsid>* aId, const char* aName,
-                       void* aClosure) const
-    {
-    }
-
-    virtual void Trace(JS::Heap<JSObject*>* aObject, const char* aName,
-                       void* aClosure) const
-    {
-        if (*aObject && xpc_GCThingIsGrayCCThing(*aObject)) {
-            mCollector->GetJSPurpleBuffer()->mObjects.AppendElement(*aObject);
-        }
+  }
+
+  bool HasSnowWhiteObjects() const
+  {
+    return mObjects.Length() > 0;
+  }
+
+  virtual void Trace(JS::Heap<JS::Value>* aValue, const char* aName,
+                     void* aClosure) const
+  {
+    if (aValue->isMarkable()) {
+      void* thing = aValue->toGCThing();
+      if (thing && xpc_GCThingIsGrayCCThing(thing)) {
+        mCollector->GetJSPurpleBuffer()->mValues.AppendElement(*aValue);
+      }
     }
-
-    virtual void Trace(JS::TenuredHeap<JSObject*>* aObject, const char* aName,
-                       void* aClosure) const
-    {
-        if (*aObject && xpc_GCThingIsGrayCCThing(*aObject)) {
-            mCollector->GetJSPurpleBuffer()->mTenuredObjects.AppendElement(*aObject);
-        }
+  }
+
+  virtual void Trace(JS::Heap<jsid>* aId, const char* aName,
+                     void* aClosure) const
+  {
+  }
+
+  virtual void Trace(JS::Heap<JSObject*>* aObject, const char* aName,
+                     void* aClosure) const
+  {
+    if (*aObject && xpc_GCThingIsGrayCCThing(*aObject)) {
+      mCollector->GetJSPurpleBuffer()->mObjects.AppendElement(*aObject);
     }
-
-    virtual void Trace(JS::Heap<JSString*>* aString, const char* aName,
-                       void* aClosure) const
-    {
+  }
+
+  virtual void Trace(JS::TenuredHeap<JSObject*>* aObject, const char* aName,
+                     void* aClosure) const
+  {
+    if (*aObject && xpc_GCThingIsGrayCCThing(*aObject)) {
+      mCollector->GetJSPurpleBuffer()->mTenuredObjects.AppendElement(*aObject);
     }
-
-    virtual void Trace(JS::Heap<JSScript*>* aScript, const char* aName,
-                       void* aClosure) const
-    {
-    }
-
-    virtual void Trace(JS::Heap<JSFunction*>* aFunction, const char* aName,
-                       void* aClosure) const
-    {
-    }
+  }
+
+  virtual void Trace(JS::Heap<JSString*>* aString, const char* aName,
+                     void* aClosure) const
+  {
+  }
+
+  virtual void Trace(JS::Heap<JSScript*>* aScript, const char* aName,
+                     void* aClosure) const
+  {
+  }
+
+  virtual void Trace(JS::Heap<JSFunction*>* aFunction, const char* aName,
+                     void* aClosure) const
+  {
+  }
 
 private:
-    nsCycleCollector *mCollector;
-    FallibleTArray<SnowWhiteObject> mObjects;
+  nsCycleCollector *mCollector;
+  FallibleTArray<SnowWhiteObject> mObjects;
 };
 
 class RemoveSkippableVisitor : public SnowWhiteKiller
 {
 public:
-    RemoveSkippableVisitor(nsCycleCollector* aCollector,
-                           uint32_t aMaxCount, bool aRemoveChildlessNodes,
-                           bool aAsyncSnowWhiteFreeing,
-                           CC_ForgetSkippableCallback aCb)
-        : SnowWhiteKiller(aCollector, aAsyncSnowWhiteFreeing ? 0 : aMaxCount),
-          mRemoveChildlessNodes(aRemoveChildlessNodes),
-          mAsyncSnowWhiteFreeing(aAsyncSnowWhiteFreeing),
-          mDispatchedDeferredDeletion(false),
-          mCallback(aCb)
-    {}
-
-    ~RemoveSkippableVisitor()
-    {
-        // Note, we must call the callback before SnowWhiteKiller calls
-        // DeleteCycleCollectable!
-        if (mCallback) {
-            mCallback();
-        }
-        if (HasSnowWhiteObjects()) {
-            // Effectively a continuation.
-            nsCycleCollector_dispatchDeferredDeletion(true);
-        }
+  RemoveSkippableVisitor(nsCycleCollector* aCollector,
+                         uint32_t aMaxCount, bool aRemoveChildlessNodes,
+                         bool aAsyncSnowWhiteFreeing,
+                         CC_ForgetSkippableCallback aCb)
+    : SnowWhiteKiller(aCollector, aAsyncSnowWhiteFreeing ? 0 : aMaxCount),
+      mRemoveChildlessNodes(aRemoveChildlessNodes),
+      mAsyncSnowWhiteFreeing(aAsyncSnowWhiteFreeing),
+      mDispatchedDeferredDeletion(false),
+      mCallback(aCb)
+  {}
+
+  ~RemoveSkippableVisitor()
+  {
+    // Note, we must call the callback before SnowWhiteKiller calls
+    // DeleteCycleCollectable!
+    if (mCallback) {
+      mCallback();
+    }
+    if (HasSnowWhiteObjects()) {
+      // Effectively a continuation.
+      nsCycleCollector_dispatchDeferredDeletion(true);
     }
-
-    void
-    Visit(nsPurpleBuffer &aBuffer, nsPurpleBufferEntry *aEntry)
-    {
-        MOZ_ASSERT(aEntry->mObject, "null mObject in purple buffer");
-        if (!aEntry->mRefCnt->get()) {
-            if (!mAsyncSnowWhiteFreeing) {
-                SnowWhiteKiller::Visit(aBuffer, aEntry);
-            } else if (!mDispatchedDeferredDeletion) {
-                mDispatchedDeferredDeletion = true;
-                nsCycleCollector_dispatchDeferredDeletion(false);
-            }
-            return;
-        }
-        void *o = aEntry->mObject;
-        nsCycleCollectionParticipant *cp = aEntry->mParticipant;
-        CanonicalizeParticipant(&o, &cp);
-        if (aEntry->mRefCnt->IsPurple() && !cp->CanSkip(o, false) &&
-            (!mRemoveChildlessNodes || MayHaveChild(o, cp))) {
-            return;
-        }
-        aBuffer.Remove(aEntry);
+  }
+
+  void
+  Visit(nsPurpleBuffer &aBuffer, nsPurpleBufferEntry *aEntry)
+  {
+    MOZ_ASSERT(aEntry->mObject, "null mObject in purple buffer");
+    if (!aEntry->mRefCnt->get()) {
+      if (!mAsyncSnowWhiteFreeing) {
+        SnowWhiteKiller::Visit(aBuffer, aEntry);
+      } else if (!mDispatchedDeferredDeletion) {
+        mDispatchedDeferredDeletion = true;
+        nsCycleCollector_dispatchDeferredDeletion(false);
+      }
+      return;
     }
+    void *o = aEntry->mObject;
+    nsCycleCollectionParticipant *cp = aEntry->mParticipant;
+    CanonicalizeParticipant(&o, &cp);
+    if (aEntry->mRefCnt->IsPurple() && !cp->CanSkip(o, false) &&
+        (!mRemoveChildlessNodes || MayHaveChild(o, cp))) {
+      return;
+    }
+    aBuffer.Remove(aEntry);
+  }
 
 private:
-    bool mRemoveChildlessNodes;
-    bool mAsyncSnowWhiteFreeing;
-    bool mDispatchedDeferredDeletion;
-    CC_ForgetSkippableCallback mCallback;
+  bool mRemoveChildlessNodes;
+  bool mAsyncSnowWhiteFreeing;
+  bool mDispatchedDeferredDeletion;
+  CC_ForgetSkippableCallback mCallback;
 };
 
 void
 nsPurpleBuffer::RemoveSkippable(nsCycleCollector* aCollector,
                                 bool aRemoveChildlessNodes,
                                 bool aAsyncSnowWhiteFreeing,
                                 CC_ForgetSkippableCallback aCb)
 {
-    RemoveSkippableVisitor visitor(aCollector, Count(), aRemoveChildlessNodes,
-                                   aAsyncSnowWhiteFreeing, aCb);
-    VisitEntries(visitor);
+  RemoveSkippableVisitor visitor(aCollector, Count(), aRemoveChildlessNodes,
+                                 aAsyncSnowWhiteFreeing, aCb);
+  VisitEntries(visitor);
 }
 
 bool
 nsCycleCollector::FreeSnowWhite(bool aUntilNoSWInPurpleBuffer)
 {
-    CheckThreadSafety();
-
-    if (mFreeingSnowWhite) {
-        return false;
+  CheckThreadSafety();
+
+  if (mFreeingSnowWhite) {
+    return false;
+  }
+
+  AutoRestore<bool> ar(mFreeingSnowWhite);
+  mFreeingSnowWhite = true;
+
+  bool hadSnowWhiteObjects = false;
+  do {
+    SnowWhiteKiller visitor(this, mPurpleBuf.Count());
+    mPurpleBuf.VisitEntries(visitor);
+    hadSnowWhiteObjects = hadSnowWhiteObjects ||
+                          visitor.HasSnowWhiteObjects();
+    if (!visitor.HasSnowWhiteObjects()) {
+      break;
     }
-
-    AutoRestore<bool> ar(mFreeingSnowWhite);
-    mFreeingSnowWhite = true;
-
-    bool hadSnowWhiteObjects = false;
-    do {
-        SnowWhiteKiller visitor(this, mPurpleBuf.Count());
-        mPurpleBuf.VisitEntries(visitor);
-        hadSnowWhiteObjects = hadSnowWhiteObjects ||
-                              visitor.HasSnowWhiteObjects();
-        if (!visitor.HasSnowWhiteObjects()) {
-            break;
-        }
-    } while (aUntilNoSWInPurpleBuffer);
-    return hadSnowWhiteObjects;
+  } while (aUntilNoSWInPurpleBuffer);
+  return hadSnowWhiteObjects;
 }
 
 void
 nsCycleCollector::ForgetSkippable(bool aRemoveChildlessNodes,
                                   bool aAsyncSnowWhiteFreeing)
 {
-    CheckThreadSafety();
-
-    // If we remove things from the purple buffer during graph building, we may
-    // lose track of an object that was mutated during graph building.
-    MOZ_ASSERT(mIncrementalPhase == IdlePhase);
-
-    if (mJSRuntime) {
-        mJSRuntime->PrepareForForgetSkippable();
-    }
-    MOZ_ASSERT(!mScanInProgress, "Don't forget skippable or free snow-white while scan is in progress.");
-    mPurpleBuf.RemoveSkippable(this, aRemoveChildlessNodes,
-                               aAsyncSnowWhiteFreeing, mForgetSkippableCB);
+  CheckThreadSafety();
+
+  // If we remove things from the purple buffer during graph building, we may
+  // lose track of an object that was mutated during graph building.
+  MOZ_ASSERT(mIncrementalPhase == IdlePhase);
+
+  if (mJSRuntime) {
+    mJSRuntime->PrepareForForgetSkippable();
+  }
+  MOZ_ASSERT(!mScanInProgress, "Don't forget skippable or free snow-white while scan is in progress.");
+  mPurpleBuf.RemoveSkippable(this, aRemoveChildlessNodes,
+                             aAsyncSnowWhiteFreeing, mForgetSkippableCB);
 }
 
 MOZ_NEVER_INLINE void
 nsCycleCollector::MarkRoots(SliceBudget &aBudget)
 {
-    const intptr_t kNumNodesBetweenTimeChecks = 1000;
-    const intptr_t kStep = SliceBudget::CounterReset / kNumNodesBetweenTimeChecks;
-
-    TimeLog timeLog;
-    AutoRestore<bool> ar(mScanInProgress);
-    MOZ_ASSERT(!mScanInProgress);
-    mScanInProgress = true;
-    MOZ_ASSERT(mIncrementalPhase == GraphBuildingPhase);
-    MOZ_ASSERT(mCurrNode);
-
-    while (!aBudget.isOverBudget() && !mCurrNode->IsDone()) {
-        PtrInfo *pi = mCurrNode->GetNext();
-        if (!pi) {
-            MOZ_CRASH();
-        }
-
-        // We need to call the builder's Traverse() method on deleted nodes, to
-        // set their firstChild() that may be read by a prior non-deleted
-        // neighbor.
-        mBuilder->Traverse(pi);
-        if (mCurrNode->AtBlockEnd()) {
-            mBuilder->SetLastChild();
-        }
-        aBudget.step(kStep);
+  const intptr_t kNumNodesBetweenTimeChecks = 1000;
+  const intptr_t kStep = SliceBudget::CounterReset / kNumNodesBetweenTimeChecks;
+
+  TimeLog timeLog;
+  AutoRestore<bool> ar(mScanInProgress);
+  MOZ_ASSERT(!mScanInProgress);
+  mScanInProgress = true;
+  MOZ_ASSERT(mIncrementalPhase == GraphBuildingPhase);
+  MOZ_ASSERT(mCurrNode);
+
+  while (!aBudget.isOverBudget() && !mCurrNode->IsDone()) {
+    PtrInfo *pi = mCurrNode->GetNext();
+    if (!pi) {
+      MOZ_CRASH();
     }
 
-    if (!mCurrNode->IsDone()) {
-        timeLog.Checkpoint("MarkRoots()");
-        return;
-    }
-
-    if (mGraph.mRootCount > 0) {
-        mBuilder->SetLastChild();
+    // We need to call the builder's Traverse() method on deleted nodes, to
+    // set their firstChild() that may be read by a prior non-deleted
+    // neighbor.
+    mBuilder->Traverse(pi);
+    if (mCurrNode->AtBlockEnd()) {
+      mBuilder->SetLastChild();
     }
-
-    if (mBuilder->RanOutOfMemory()) {
-        MOZ_ASSERT(false, "Ran out of memory while building cycle collector graph");
-        CC_TELEMETRY(_OOM, true);
-    }
-
-    mBuilder = nullptr;
-    mCurrNode = nullptr;
-    mIncrementalPhase = ScanAndCollectWhitePhase;
+    aBudget.step(kStep);
+  }
+
+  if (!mCurrNode->IsDone()) {
     timeLog.Checkpoint("MarkRoots()");
+    return;
+  }
+
+  if (mGraph.mRootCount > 0) {
+    mBuilder->SetLastChild();
+  }
+
+  if (mBuilder->RanOutOfMemory()) {
+    MOZ_ASSERT(false, "Ran out of memory while building cycle collector graph");
+    CC_TELEMETRY(_OOM, true);
+  }
+
+  mBuilder = nullptr;
+  mCurrNode = nullptr;
+  mIncrementalPhase = ScanAndCollectWhitePhase;
+  timeLog.Checkpoint("MarkRoots()");
 }
 
 
 ////////////////////////////////////////////////////////////////////////
 // Bacon & Rajan's |ScanRoots| routine.
 ////////////////////////////////////////////////////////////////////////
 
 
 struct ScanBlackVisitor
 {
-    ScanBlackVisitor(uint32_t &aWhiteNodeCount, bool &aFailed)
-        : mWhiteNodeCount(aWhiteNodeCount), mFailed(aFailed)
-    {
-    }
-
-    bool ShouldVisitNode(PtrInfo const *pi)
-    {
-        return pi->mColor != black;
-    }
-
-    MOZ_NEVER_INLINE void VisitNode(PtrInfo *pi)
-    {
-        if (pi->mColor == white)
-            --mWhiteNodeCount;
-        pi->mColor = black;
-    }
-
-    void Failed()
-    {
-        mFailed = true;
-    }
+  ScanBlackVisitor(uint32_t &aWhiteNodeCount, bool &aFailed)
+    : mWhiteNodeCount(aWhiteNodeCount), mFailed(aFailed)
+  {
+  }
+
+  bool ShouldVisitNode(PtrInfo const *pi)
+  {
+    return pi->mColor != black;
+  }
+
+  MOZ_NEVER_INLINE void VisitNode(PtrInfo *pi)
+  {
+    if (pi->mColor == white)
+      --mWhiteNodeCount;
+    pi->mColor = black;
+  }
+
+  void Failed()
+  {
+    mFailed = true;
+  }
 
 private:
-    uint32_t &mWhiteNodeCount;
-    bool &mFailed;
+  uint32_t &mWhiteNodeCount;
+  bool &mFailed;
 };
 
 
 struct scanVisitor
 {
-    scanVisitor(uint32_t &aWhiteNodeCount, bool &aFailed, bool aWasIncremental)
-        : mWhiteNodeCount(aWhiteNodeCount), mFailed(aFailed),
-          mWasIncremental(aWasIncremental)
-    {
-    }
-
-    bool ShouldVisitNode(PtrInfo const *pi)
-    {
-        return pi->mColor == grey;
+  scanVisitor(uint32_t &aWhiteNodeCount, bool &aFailed, bool aWasIncremental)
+    : mWhiteNodeCount(aWhiteNodeCount), mFailed(aFailed),
+      mWasIncremental(aWasIncremental)
+  {
+  }
+
+  bool ShouldVisitNode(PtrInfo const *pi)
+  {
+    return pi->mColor == grey;
+  }
+
+  MOZ_NEVER_INLINE void VisitNode(PtrInfo *pi)
+  {
+    if (pi->mInternalRefs > pi->mRefCount && pi->mRefCount > 0) {
+      // If we found more references to an object than its ref count, then
+      // the object should have already been marked as an incremental
+      // root. Note that this is imprecise, because pi could have been
+      // marked black for other reasons. Always fault if we weren't
+      // incremental, as there were no incremental roots in that case.
+      if (!mWasIncremental || pi->mColor != black) {
+        Fault("traversed refs exceed refcount", pi);
+      }
     }
 
-    MOZ_NEVER_INLINE void VisitNode(PtrInfo *pi)
-    {
-        if (pi->mInternalRefs > pi->mRefCount && pi->mRefCount > 0) {
-            // If we found more references to an object than its ref count, then
-            // the object should have already been marked as an incremental
-            // root. Note that this is imprecise, because pi could have been
-            // marked black for other reasons. Always fault if we weren't
-            // incremental, as there were no incremental roots in that case.
-            if (!mWasIncremental || pi->mColor != black) {
-                Fault("traversed refs exceed refcount", pi);
-            }
-        }
-
-        if (pi->mInternalRefs == pi->mRefCount || pi->mRefCount == 0) {
-            pi->mColor = white;
-            ++mWhiteNodeCount;
-        } else {
-            GraphWalker<ScanBlackVisitor>(ScanBlackVisitor(mWhiteNodeCount, mFailed)).Walk(pi);
-            MOZ_ASSERT(pi->mColor == black,
-                       "Why didn't ScanBlackVisitor make pi black?");
-        }
+    if (pi->mInternalRefs == pi->mRefCount || pi->mRefCount == 0) {
+      pi->mColor = white;
+      ++mWhiteNodeCount;
+    } else {
+      GraphWalker<ScanBlackVisitor>(ScanBlackVisitor(mWhiteNodeCount, mFailed)).Walk(pi);
+      MOZ_ASSERT(pi->mColor == black,
+                 "Why didn't ScanBlackVisitor make pi black?");
     }
-
-    void Failed() {
-        mFailed = true;
-    }
+  }
+
+  void Failed() {
+    mFailed = true;
+  }
 
 private:
-    uint32_t &mWhiteNodeCount;
-    bool &mFailed;
-    bool mWasIncremental;
+  uint32_t &mWhiteNodeCount;
+  bool &mFailed;
+  bool mWasIncremental;
 };
 
 // Iterate over the WeakMaps.  If we mark anything while iterating
 // over the WeakMaps, we must iterate over all of the WeakMaps again.
 void
 nsCycleCollector::ScanWeakMaps()
 {
-    bool anyChanged;
-    bool failed = false;
-    do {
-        anyChanged = false;
-        for (uint32_t i = 0; i < mGraph.mWeakMaps.Length(); i++) {
-            WeakMapping *wm = &mGraph.mWeakMaps[i];
-
-            // If any of these are null, the original object was marked black.
-            uint32_t mColor = wm->mMap ? wm->mMap->mColor : black;
-            uint32_t kColor = wm->mKey ? wm->mKey->mColor : black;
-            uint32_t kdColor = wm->mKeyDelegate ? wm->mKeyDelegate->mColor : black;
-            uint32_t vColor = wm->mVal ? wm->mVal->mColor : black;
-
-            // All non-null weak mapping maps, keys and values are
-            // roots (in the sense of WalkFromRoots) in the cycle
-            // collector graph, and thus should have been colored
-            // either black or white in ScanRoots().
-            MOZ_ASSERT(mColor != grey, "Uncolored weak map");
-            MOZ_ASSERT(kColor != grey, "Uncolored weak map key");
-            MOZ_ASSERT(kdColor != grey, "Uncolored weak map key delegate");
-            MOZ_ASSERT(vColor != grey, "Uncolored weak map value");
-
-            if (mColor == black && kColor != black && kdColor == black) {
-                GraphWalker<ScanBlackVisitor>(ScanBlackVisitor(mWhiteNodeCount, failed)).Walk(wm->mKey);
-                anyChanged = true;
-            }
-
-            if (mColor == black && kColor == black && vColor != black) {
-                GraphWalker<ScanBlackVisitor>(ScanBlackVisitor(mWhiteNodeCount, failed)).Walk(wm->mVal);
-                anyChanged = true;
-            }
-        }
-    } while (anyChanged);
-
-    if (failed) {
-        MOZ_ASSERT(false, "Ran out of memory in ScanWeakMaps");
-        CC_TELEMETRY(_OOM, true);
+  bool anyChanged;
+  bool failed = false;
+  do {
+    anyChanged = false;
+    for (uint32_t i = 0; i < mGraph.mWeakMaps.Length(); i++) {
+      WeakMapping *wm = &mGraph.mWeakMaps[i];
+
+      // If any of these are null, the original object was marked black.
+      uint32_t mColor = wm->mMap ? wm->mMap->mColor : black;
+      uint32_t kColor = wm->mKey ? wm->mKey->mColor : black;
+      uint32_t kdColor = wm->mKeyDelegate ? wm->mKeyDelegate->mColor : black;
+      uint32_t vColor = wm->mVal ? wm->mVal->mColor : black;
+
+      // All non-null weak mapping maps, keys and values are
+      // roots (in the sense of WalkFromRoots) in the cycle
+      // collector graph, and thus should have been colored
+      // either black or white in ScanRoots().
+      MOZ_ASSERT(mColor != grey, "Uncolored weak map");
+      MOZ_ASSERT(kColor != grey, "Uncolored weak map key");
+      MOZ_ASSERT(kdColor != grey, "Uncolored weak map key delegate");
+      MOZ_ASSERT(vColor != grey, "Uncolored weak map value");
+
+      if (mColor == black && kColor != black && kdColor == black) {
+        GraphWalker<ScanBlackVisitor>(ScanBlackVisitor(mWhiteNodeCount, failed)).Walk(wm->mKey);
+        anyChanged = true;
+      }
+
+      if (mColor == black && kColor == black && vColor != black) {
+        GraphWalker<ScanBlackVisitor>(ScanBlackVisitor(mWhiteNodeCount, failed)).Walk(wm->mVal);
+        anyChanged = true;
+      }
     }
+  } while (anyChanged);
+
+  if (failed) {
+    MOZ_ASSERT(false, "Ran out of memory in ScanWeakMaps");
+    CC_TELEMETRY(_OOM, true);
+  }
 }
 
 // Flood black from any objects in the purple buffer that are in the CC graph.
 class PurpleScanBlackVisitor
 {
 public:
-    PurpleScanBlackVisitor(GCGraph &aGraph, nsICycleCollectorListener *aListener,
-                           uint32_t &aCount, bool &aFailed)
-        : mGraph(aGraph), mListener(aListener), mCount(aCount), mFailed(aFailed)
-    {
+  PurpleScanBlackVisitor(GCGraph &aGraph, nsICycleCollectorListener *aListener,
+                         uint32_t &aCount, bool &aFailed)
+    : mGraph(aGraph), mListener(aListener), mCount(aCount), mFailed(aFailed)
+  {
+  }
+
+  void
+  Visit(nsPurpleBuffer &aBuffer, nsPurpleBufferEntry *aEntry)
+  {
+    MOZ_ASSERT(aEntry->mObject, "Entries with null mObject shouldn't be in the purple buffer.");
+    MOZ_ASSERT(aEntry->mRefCnt->get() != 0, "Snow-white objects shouldn't be in the purple buffer.");
+
+    void *obj = aEntry->mObject;
+    if (!aEntry->mParticipant) {
+      obj = CanonicalizeXPCOMParticipant(static_cast<nsISupports*>(obj));
+      MOZ_ASSERT(obj, "Don't add objects that don't participate in collection!");
     }
 
-    void
-    Visit(nsPurpleBuffer &aBuffer, nsPurpleBufferEntry *aEntry)
-    {
-        MOZ_ASSERT(aEntry->mObject, "Entries with null mObject shouldn't be in the purple buffer.");
-        MOZ_ASSERT(aEntry->mRefCnt->get() != 0, "Snow-white objects shouldn't be in the purple buffer.");
-
-        void *obj = aEntry->mObject;
-        if (!aEntry->mParticipant) {
-            obj = CanonicalizeXPCOMParticipant(static_cast<nsISupports*>(obj));
-            MOZ_ASSERT(obj, "Don't add objects that don't participate in collection!");
-        }
-
-        PtrInfo *pi = mGraph.FindNode(obj);
-        if (!pi) {
-            return;
-        }
-        MOZ_ASSERT(pi->mParticipant, "No dead objects should be in the purple buffer.");
-        if (MOZ_UNLIKELY(mListener)) {
-            mListener->NoteIncrementalRoot((uint64_t)pi->mPointer);
-        }
-        if (pi->mColor == black) {
-            return;
-        }
-        GraphWalker<ScanBlackVisitor>(ScanBlackVisitor(mCount, mFailed)).Walk(pi);
+    PtrInfo *pi = mGraph.FindNode(obj);
+    if (!pi) {
+      return;
     }
+    MOZ_ASSERT(pi->mParticipant, "No dead objects should be in the purple buffer.");
+    if (MOZ_UNLIKELY(mListener)) {
+      mListener->NoteIncrementalRoot((uint64_t)pi->mPointer);
+    }
+    if (pi->mColor == black) {
+      return;
+    }
+    GraphWalker<ScanBlackVisitor>(ScanBlackVisitor(mCount, mFailed)).Walk(pi);
+  }
 
 private:
-    GCGraph &mGraph;
-    nsICycleCollectorListener *mListener;
-    uint32_t &mCount;
-    bool &mFailed;
+  GCGraph &mGraph;
+  nsICycleCollectorListener *mListener;
+  uint32_t &mCount;
+  bool &mFailed;
 };
 
 // Objects that have been stored somewhere since the start of incremental graph building must
 // be treated as live for this cycle collection, because we may not have accurate information
 // about who holds references to them.
 void
 nsCycleCollector::ScanIncrementalRoots()
 {
-    TimeLog timeLog;
-
-    // Reference counted objects:
-    // We cleared the purple buffer at the start of the current ICC, so if a
-    // refcounted object is purple, it may have been AddRef'd during the current
-    // ICC. (It may also have only been released.) If that is the case, we cannot
-    // be sure that the set of things pointing to the object in the CC graph
-    // is accurate. Therefore, for safety, we treat any purple objects as being
-    // live during the current CC. We don't remove anything from the purple
-    // buffer here, so these objects will be suspected and freed in the next CC
-    // if they are garbage.
-    bool failed = false;
-    PurpleScanBlackVisitor purpleScanBlackVisitor(mGraph, mListener, mWhiteNodeCount, failed);
-    mPurpleBuf.VisitEntries(purpleScanBlackVisitor);
-    timeLog.Checkpoint("ScanIncrementalRoots::fix purple");
-
-    // Garbage collected objects:
-    // If a GCed object was added to the graph with a refcount of zero, and is
-    // now marked black by the GC, it was probably gray before and was exposed
-    // to active JS, so it may have been stored somewhere, so it needs to be
-    // treated as live.
-    if (mJSRuntime) {
-        nsCycleCollectionParticipant *jsParticipant = mJSRuntime->GCThingParticipant();
-        nsCycleCollectionParticipant *zoneParticipant = mJSRuntime->ZoneParticipant();
-        NodePool::Enumerator etor(mGraph.mNodes);
-
-        while (!etor.IsDone()) {
-            PtrInfo *pi = etor.GetNext();
-
-            // If the refcount is non-zero, pi can't have been a gray JS object.
-            if (pi->mRefCount != 0) {
-                continue;
-            }
-
-            // As an optimization, if an object has already been determined to be live,
-            // don't consider it further.  We can't do this if there is a listener,
-            // because the listener wants to know the complete set of incremental roots.
-            if (pi->mColor == black && MOZ_LIKELY(!mListener)) {
-                continue;
-            }
-
-            // If the object is still marked gray by the GC, nothing could have gotten
-            // hold of it, so it isn't an incremental root.
-            if (pi->mParticipant == jsParticipant) {
-                if (xpc_GCThingIsGrayCCThing(pi->mPointer)) {
-                    continue;
-                }
-            } else if (pi->mParticipant == zoneParticipant) {
-                JS::Zone *zone = static_cast<JS::Zone*>(pi->mPointer);
-                if (js::ZoneGlobalsAreAllGray(zone)) {
-                    continue;
-                }
-            } else {
-                MOZ_ASSERT(false, "Non-JS thing with 0 refcount? Treating as live.");
-            }
-
-            // At this point, pi must be an incremental root.
-
-            // If there's a listener, tell it about this root. We don't bother with the
-            // optimization of skipping the Walk() if pi is black: it will just return
-            // without doing anything and there's no need to make this case faster.
-            if (MOZ_UNLIKELY(mListener)) {
-                mListener->NoteIncrementalRoot((uint64_t)pi->mPointer);
-            }
-
-            GraphWalker<ScanBlackVisitor>(ScanBlackVisitor(mWhiteNodeCount, failed)).Walk(pi);
+  TimeLog timeLog;
+
+  // Reference counted objects:
+  // We cleared the purple buffer at the start of the current ICC, so if a
+  // refcounted object is purple, it may have been AddRef'd during the current
+  // ICC. (It may also have only been released.) If that is the case, we cannot
+  // be sure that the set of things pointing to the object in the CC graph
+  // is accurate. Therefore, for safety, we treat any purple objects as being
+  // live during the current CC. We don't remove anything from the purple
+  // buffer here, so these objects will be suspected and freed in the next CC
+  // if they are garbage.
+  bool failed = false;
+  PurpleScanBlackVisitor purpleScanBlackVisitor(mGraph, mListener, mWhiteNodeCount, failed);
+  mPurpleBuf.VisitEntries(purpleScanBlackVisitor);
+  timeLog.Checkpoint("ScanIncrementalRoots::fix purple");
+
+  // Garbage collected objects:
+  // If a GCed object was added to the graph with a refcount of zero, and is
+  // now marked black by the GC, it was probably gray before and was exposed
+  // to active JS, so it may have been stored somewhere, so it needs to be
+  // treated as live.
+  if (mJSRuntime) {
+    nsCycleCollectionParticipant *jsParticipant = mJSRuntime->GCThingParticipant();
+    nsCycleCollectionParticipant *zoneParticipant = mJSRuntime->ZoneParticipant();
+    NodePool::Enumerator etor(mGraph.mNodes);
+
+    while (!etor.IsDone()) {
+      PtrInfo *pi = etor.GetNext();
+
+      // If the refcount is non-zero, pi can't have been a gray JS object.
+      if (pi->mRefCount != 0) {
+        continue;
+      }
+
+      // As an optimization, if an object has already been determined to be live,
+      // don't consider it further.  We can't do this if there is a listener,
+      // because the listener wants to know the complete set of incremental roots.
+      if (pi->mColor == black && MOZ_LIKELY(!mListener)) {
+        continue;
+      }
+
+      // If the object is still marked gray by the GC, nothing could have gotten
+      // hold of it, so it isn't an incremental root.
+      if (pi->mParticipant == jsParticipant) {
+        if (xpc_GCThingIsGrayCCThing(pi->mPointer)) {
+          continue;
         }
-
-        timeLog.Checkpoint("ScanIncrementalRoots::fix JS");
+      } else if (pi->mParticipant == zoneParticipant) {
+        JS::Zone *zone = static_cast<JS::Zone*>(pi->mPointer);
+        if (js::ZoneGlobalsAreAllGray(zone)) {
+          continue;
+        }
+      } else {
+        MOZ_ASSERT(false, "Non-JS thing with 0 refcount? Treating as live.");
+      }
+
+      // At this point, pi must be an incremental root.
+
+      // If there's a listener, tell it about this root. We don't bother with the
+      // optimization of skipping the Walk() if pi is black: it will just return
+      // without doing anything and there's no need to make this case faster.
+      if (MOZ_UNLIKELY(mListener)) {
+        mListener->NoteIncrementalRoot((uint64_t)pi->mPointer);
+      }
+
+      GraphWalker<ScanBlackVisitor>(ScanBlackVisitor(mWhiteNodeCount, failed)).Walk(pi);
     }
 
-    if (failed) {
-        NS_ASSERTION(false, "Ran out of memory in ScanIncrementalRoots");
-        CC_TELEMETRY(_OOM, true);
-    }
+    timeLog.Checkpoint("ScanIncrementalRoots::fix JS");
+  }
+
+  if (failed) {
+    NS_ASSERTION(false, "Ran out of memory in ScanIncrementalRoots");
+    CC_TELEMETRY(_OOM, true);
+  }
 }
 
 void
 nsCycleCollector::ScanRoots(bool aFullySynchGraphBuild)
 {
-    AutoRestore<bool> ar(mScanInProgress);
-    MOZ_ASSERT(!mScanInProgress);
-    mScanInProgress = true;
-    mWhiteNodeCount = 0;
-    MOZ_ASSERT(mIncrementalPhase == ScanAndCollectWhitePhase);
-
-    if (!aFullySynchGraphBuild) {
-        ScanIncrementalRoots();
-    }
-
-    TimeLog timeLog;
-
-    // On the assumption that most nodes will be black, it's
-    // probably faster to use a GraphWalker than a
-    // NodePool::Enumerator.
-    bool failed = false;
-    scanVisitor sv(mWhiteNodeCount, failed, !aFullySynchGraphBuild);
-    GraphWalker<scanVisitor>(sv).WalkFromRoots(mGraph);
-    timeLog.Checkpoint("ScanRoots::WalkFromRoots");
-
-    if (failed) {
-        NS_ASSERTION(false, "Ran out of memory in ScanRoots");
-        CC_TELEMETRY(_OOM, true);
+  AutoRestore<bool> ar(mScanInProgress);
+  MOZ_ASSERT(!mScanInProgress);
+  mScanInProgress = true;
+  mWhiteNodeCount = 0;
+  MOZ_ASSERT(mIncrementalPhase == ScanAndCollectWhitePhase);
+
+  if (!aFullySynchGraphBuild) {
+    ScanIncrementalRoots();
+  }
+
+  TimeLog timeLog;
+
+  // On the assumption that most nodes will be black, it's
+  // probably faster to use a GraphWalker than a
+  // NodePool::Enumerator.
+  bool failed = false;
+  scanVisitor sv(mWhiteNodeCount, failed, !aFullySynchGraphBuild);
+  GraphWalker<scanVisitor>(sv).WalkFromRoots(mGraph);
+  timeLog.Checkpoint("ScanRoots::WalkFromRoots");
+
+  if (failed) {
+    NS_ASSERTION(false, "Ran out of memory in ScanRoots");
+    CC_TELEMETRY(_OOM, true);
+  }
+
+  // Scanning weak maps must be done last.
+  ScanWeakMaps();
+  timeLog.Checkpoint("ScanRoots::ScanWeakMaps");
+
+  if (mListener) {
+    mListener->BeginResults();
+
+    NodePool::Enumerator etor(mGraph.mNodes);
+    while (!etor.IsDone()) {
+      PtrInfo *pi = etor.GetNext();
+      if (!pi->mParticipant) {
+        continue;
+      }
+      switch (pi->mColor) {
+        case black:
+          if (pi->mRefCount > 0 && pi->mRefCount < UINT32_MAX &&
+              pi->mInternalRefs != pi->mRefCount) {
+            mListener->DescribeRoot((uint64_t)pi->mPointer,
+                                    pi->mInternalRefs);
+          }
+          break;
+        case white:
+          mListener->DescribeGarbage((uint64_t)pi->mPointer);
+          break;
+        case grey:
+          // With incremental CC, we can end up with a grey object after
+          // scanning if it is only reachable from an object that gets freed.
+          break;
+      }
     }
 
-    // Scanning weak maps must be done last.
-    ScanWeakMaps();
-    timeLog.Checkpoint("ScanRoots::ScanWeakMaps");
-
-    if (mListener) {
-        mListener->BeginResults();
-
-        NodePool::Enumerator etor(mGraph.mNodes);
-        while (!etor.IsDone()) {
-            PtrInfo *pi = etor.GetNext();
-            if (!pi->mParticipant) {
-                continue;
-            }
-            switch (pi->mColor) {
-            case black:
-                if (pi->mRefCount > 0 && pi->mRefCount < UINT32_MAX &&
-                    pi->mInternalRefs != pi->mRefCount) {
-                    mListener->DescribeRoot((uint64_t)pi->mPointer,
-                                            pi->mInternalRefs);
-                }
-                break;
-            case white:
-                mListener->DescribeGarbage((uint64_t)pi->mPointer);
-                break;
-            case grey:
-                // With incremental CC, we can end up with a grey object after
-                // scanning if it is only reachable from an object that gets freed.
-                break;
-            }
-        }
-
-        mListener->End();
-        mListener = nullptr;
-        timeLog.Checkpoint("ScanRoots::listener");
-    }
+    mListener->End();
+    mListener = nullptr;
+    timeLog.Checkpoint("ScanRoots::listener");
+  }
 }
 
 
 ////////////////////////////////////////////////////////////////////////
 // Bacon & Rajan's |CollectWhite| routine, somewhat modified.
 ////////////////////////////////////////////////////////////////////////
 
 bool
 nsCycleCollector::CollectWhite()
 {
-    // Explanation of "somewhat modified": we have no way to collect the
-    // set of whites "all at once", we have to ask each of them to drop
-    // their outgoing links and assume this will cause the garbage cycle
-    // to *mostly* self-destruct (except for the reference we continue
-    // to hold).
-    //
-    // To do this "safely" we must make sure that the white nodes we're
-    // operating on are stable for the duration of our operation. So we
-    // make 3 sets of calls to language runtimes:
-    //
-    //   - Root(whites), which should pin the whites in memory.
-    //   - Unlink(whites), which drops outgoing links on each white.
-    //   - Unroot(whites), which returns the whites to normal GC.
-
-    TimeLog timeLog;
-    nsAutoTArray<PtrInfo*, 4000> whiteNodes;
-
-    MOZ_ASSERT(mIncrementalPhase == ScanAndCollectWhitePhase);
-
-    whiteNodes.SetCapacity(mWhiteNodeCount);
-    uint32_t numWhiteGCed = 0;
-
-    NodePool::Enumerator etor(mGraph.mNodes);
-    while (!etor.IsDone())
-    {
-        PtrInfo *pinfo = etor.GetNext();
-        if (pinfo->mColor == white && pinfo->mParticipant) {
-            whiteNodes.AppendElement(pinfo);
-            pinfo->mParticipant->Root(pinfo->mPointer);
-            if (pinfo->mRefCount == 0) {
-                // only JS objects have a refcount of 0
-                ++numWhiteGCed;
-            }
-        }
+  // Explanation of "somewhat modified": we have no way to collect the
+  // set of whites "all at once", we have to ask each of them to drop
+  // their outgoing links and assume this will cause the garbage cycle
+  // to *mostly* self-destruct (except for the reference we continue
+  // to hold).
+  //
+  // To do this "safely" we must make sure that the white nodes we're
+  // operating on are stable for the duration of our operation. So we
+  // make 3 sets of calls to language runtimes:
+  //
+  //   - Root(whites), which should pin the whites in memory.
+  //   - Unlink(whites), which drops outgoing links on each white.
+  //   - Unroot(whites), which returns the whites to normal GC.
+
+  TimeLog timeLog;
+  nsAutoTArray<PtrInfo*, 4000> whiteNodes;
+
+  MOZ_ASSERT(mIncrementalPhase == ScanAndCollectWhitePhase);
+
+  whiteNodes.SetCapacity(mWhiteNodeCount);
+  uint32_t numWhiteGCed = 0;
+
+  NodePool::Enumerator etor(mGraph.mNodes);
+  while (!etor.IsDone())
+  {
+    PtrInfo *pinfo = etor.GetNext();
+    if (pinfo->mColor == white && pinfo->mParticipant) {
+      whiteNodes.AppendElement(pinfo);
+      pinfo->mParticipant->Root(pinfo->mPointer);
+      if (pinfo->mRefCount == 0) {
+        // only JS objects have a refcount of 0
+        ++numWhiteGCed;
+      }
     }
-
-    uint32_t count = whiteNodes.Length();
-    MOZ_ASSERT(numWhiteGCed <= count,
-               "More freed GCed nodes than total freed nodes.");
-    mResults.mFreedRefCounted += count - numWhiteGCed;
-    mResults.mFreedGCed += numWhiteGCed;
-
-    timeLog.Checkpoint("CollectWhite::Root");
-
-    if (mBeforeUnlinkCB) {
-        mBeforeUnlinkCB();
-        timeLog.Checkpoint("CollectWhite::BeforeUnlinkCB");
-    }
-
-    for (uint32_t i = 0; i < count; ++i) {
-        PtrInfo *pinfo = whiteNodes.ElementAt(i);
-        MOZ_ASSERT(pinfo->mParticipant, "Unlink shouldn't see objects removed from graph.");
-        pinfo->mParticipant->Unlink(pinfo->mPointer);
+  }
+
+  uint32_t count = whiteNodes.Length();
+  MOZ_ASSERT(numWhiteGCed <= count,
+             "More freed GCed nodes than total freed nodes.");
+  mResults.mFreedRefCounted += count - numWhiteGCed;
+  mResults.mFreedGCed += numWhiteGCed;
+
+  timeLog.Checkpoint("CollectWhite::Root");
+
+  if (mBeforeUnlinkCB) {
+    mBeforeUnlinkCB();
+    timeLog.Checkpoint("CollectWhite::BeforeUnlinkCB");
+  }
+
+  for (uint32_t i = 0; i < count; ++i) {
+    PtrInfo *pinfo = whiteNodes.ElementAt(i);
+    MOZ_ASSERT(pinfo->mParticipant, "Unlink shouldn't see objects removed from graph.");
+    pinfo->mParticipant->Unlink(pinfo->mPointer);
 #ifdef DEBUG
-        if (mJSRuntime) {
-            mJSRuntime->AssertNoObjectsToTrace(pinfo->mPointer);
-        }
-#endif
+    if (mJSRuntime) {
+      mJSRuntime->AssertNoObjectsToTrace(pinfo->mPointer);
     }
-    timeLog.Checkpoint("CollectWhite::Unlink");
-
-    for (uint32_t i = 0; i < count; ++i) {
-        PtrInfo *pinfo = whiteNodes.ElementAt(i);
-        MOZ_ASSERT(pinfo->mParticipant, "Unroot shouldn't see objects removed from graph.");
-        pinfo->mParticipant->Unroot(pinfo->mPointer);
-    }
-    timeLog.Checkpoint("CollectWhite::Unroot");
-
-    nsCycleCollector_dispatchDeferredDeletion(false);
-    mIncrementalPhase = CleanupPhase;
-
-    return count > 0;
+#endif
+  }
+  timeLog.Checkpoint("CollectWhite::Unlink");
+
+  for (uint32_t i = 0; i < count; ++i) {
+    PtrInfo *pinfo = whiteNodes.ElementAt(i);
+    MOZ_ASSERT(pinfo->mParticipant, "Unroot shouldn't see objects removed from graph.");
+    pinfo->mParticipant->Unroot(pinfo->mPointer);
+  }
+  timeLog.Checkpoint("CollectWhite::Unroot");
+
+  nsCycleCollector_dispatchDeferredDeletion(false);
+  mIncrementalPhase = CleanupPhase;
+
+  return count > 0;
 }
 
 
 ////////////////////////
 // Memory reporting
 ////////////////////////
 
 MOZ_DEFINE_MALLOC_SIZE_OF(CycleCollectorMallocSizeOf)
 
 NS_IMETHODIMP
 nsCycleCollector::CollectReports(nsIHandleReportCallback* aHandleReport,
                                  nsISupports* aData)
 {
-    size_t objectSize, graphNodesSize, graphEdgesSize, weakMapsSize,
-           purpleBufferSize;
-    SizeOfIncludingThis(CycleCollectorMallocSizeOf,
-                        &objectSize,
-                        &graphNodesSize, &graphEdgesSize,
-                        &weakMapsSize,
-                        &purpleBufferSize);
+  size_t objectSize, graphNodesSize, graphEdgesSize, weakMapsSize,
+         purpleBufferSize;
+  SizeOfIncludingThis(CycleCollectorMallocSizeOf,
+                      &objectSize,
+                      &graphNodesSize, &graphEdgesSize,
+                      &weakMapsSize,
+                      &purpleBufferSize);
 
 #define REPORT(_path, _amount, _desc)                                     \
     do {                                                                  \
         size_t amount = _amount;  /* evaluate |_amount| only once */      \
         if (amount > 0) {                                                 \
             nsresult rv;                                                  \
             rv = aHandleReport->Callback(EmptyCString(),                  \
                                          NS_LITERAL_CSTRING(_path),       \
                                          KIND_HEAP, UNITS_BYTES, _amount, \
                                          NS_LITERAL_CSTRING(_desc),       \
                                          aData);                          \
             if (NS_WARN_IF(NS_FAILED(rv)))                                \
                 return rv;                                                \
         }                                                                 \
     } while (0)
 
-    REPORT("explicit/cycle-collector/collector-object", objectSize,
-           "Memory used for the cycle collector object itself.");
-
-    REPORT("explicit/cycle-collector/graph-nodes", graphNodesSize,
-           "Memory used for the nodes of the cycle collector's graph. "
-           "This should be zero when the collector is idle.");
-
-    REPORT("explicit/cycle-collector/graph-edges", graphEdgesSize,
-           "Memory used for the edges of the cycle collector's graph. "
-           "This should be zero when the collector is idle.");
-
-    REPORT("explicit/cycle-collector/weak-maps", weakMapsSize,
-           "Memory used for the representation of weak maps in the "
-           "cycle collector's graph. "
-           "This should be zero when the collector is idle.");
-
-    REPORT("explicit/cycle-collector/purple-buffer", purpleBufferSize,
-           "Memory used for the cycle collector's purple buffer.");
+  REPORT("explicit/cycle-collector/collector-object", objectSize,
+         "Memory used for the cycle collector object itself.");
+
+  REPORT("explicit/cycle-collector/graph-nodes", graphNodesSize,
+         "Memory used for the nodes of the cycle collector's graph. "
+         "This should be zero when the collector is idle.");
+
+  REPORT("explicit/cycle-collector/graph-edges", graphEdgesSize,
+         "Memory used for the edges of the cycle collector's graph. "
+         "This should be zero when the collector is idle.");
+
+  REPORT("explicit/cycle-collector/weak-maps", weakMapsSize,
+         "Memory used for the representation of weak maps in the "
+         "cycle collector's graph. "
+         "This should be zero when the collector is idle.");
+
+  REPORT("explicit/cycle-collector/purple-buffer", purpleBufferSize,
+         "Memory used for the cycle collector's purple buffer.");
 
 #undef REPORT
 
-    return NS_OK;
+  return NS_OK;
 };
 
 
 ////////////////////////////////////////////////////////////////////////
 // Collector implementation
 ////////////////////////////////////////////////////////////////////////
 
 nsCycleCollector::nsCycleCollector() :
-    mActivelyCollecting(false),
-    mFreeingSnowWhite(false),
-    mScanInProgress(false),
-    mJSRuntime(nullptr),
-    mIncrementalPhase(IdlePhase),
-    mThread(NS_GetCurrentThread()),
-    mWhiteNodeCount(0),
-    mBeforeUnlinkCB(nullptr),
-    mForgetSkippableCB(nullptr),
-    mUnmergedNeeded(0),
-    mMergedInARow(0),
-    mJSPurpleBuffer(nullptr)
+  mActivelyCollecting(false),
+  mFreeingSnowWhite(false),
+  mScanInProgress(false),
+  mJSRuntime(nullptr),
+  mIncrementalPhase(IdlePhase),
+  mThread(NS_GetCurrentThread()),
+  mWhiteNodeCount(0),
+  mBeforeUnlinkCB(nullptr),
+  mForgetSkippableCB(nullptr),
+  mUnmergedNeeded(0),
+  mMergedInARow(0),
+  mJSPurpleBuffer(nullptr)
 {
 }
 
 nsCycleCollector::~nsCycleCollector()
 {
-    UnregisterWeakMemoryReporter(this);
+  UnregisterWeakMemoryReporter(this);
 }
 
 void
 nsCycleCollector::RegisterJSRuntime(CycleCollectedJSRuntime *aJSRuntime)
 {
-    if (mJSRuntime)
-        Fault("multiple registrations of cycle collector JS runtime", aJSRuntime);
-
-    mJSRuntime = aJSRuntime;
-
-    // We can't register as a reporter in nsCycleCollector() because that runs
-    // before the memory reporter manager is initialized.  So we do it here
-    // instead.
-    static bool registered = false;
-    if (!registered) {
-        RegisterWeakMemoryReporter(this);
-        registered = true;
-    }
+  if (mJSRuntime)
+    Fault("multiple registrations of cycle collector JS runtime", aJSRuntime);
+
+  mJSRuntime = aJSRuntime;
+
+  // We can't register as a reporter in nsCycleCollector() because that runs
+  // before the memory reporter manager is initialized.  So we do it here
+  // instead.
+  static bool registered = false;
+  if (!registered) {
+    RegisterWeakMemoryReporter(this);
+    registered = true;
+  }
 }
 
 void
 nsCycleCollector::ForgetJSRuntime()
 {
-    if (!mJSRuntime)
-        Fault("forgetting non-registered cycle collector JS runtime");
-
-    mJSRuntime = nullptr;
+  if (!mJSRuntime)
+    Fault("forgetting non-registered cycle collector JS runtime");
+
+  mJSRuntime = nullptr;
 }
 
 #ifdef DEBUG
 static bool
 HasParticipant(void *aPtr, nsCycleCollectionParticipant *aParti)
 {
-    if (aParti) {
-        return true;
-    }
-
-    nsXPCOMCycleCollectionParticipant *xcp;
-    ToParticipant(static_cast<nsISupports*>(aPtr), &xcp);
-    return xcp != nullptr;
+  if (aParti) {
+    return true;
+  }
+
+  nsXPCOMCycleCollectionParticipant *xcp;
+  ToParticipant(static_cast<nsISupports*>(aPtr), &xcp);
+  return xcp != nullptr;
 }
 #endif
 
 MOZ_ALWAYS_INLINE void
 nsCycleCollector::Suspect(void *aPtr, nsCycleCollectionParticipant *aParti,
                           nsCycleCollectingAutoRefCnt *aRefCnt)
 {
-    CheckThreadSafety();
-
-    // Re-entering ::Suspect during collection used to be a fault, but
-    // we are canonicalizing nsISupports pointers using QI, so we will
-    // see some spurious refcount traffic here.
-
-    if (MOZ_UNLIKELY(mScanInProgress)) {
-        return;
-    }
-
-    MOZ_ASSERT(aPtr, "Don't suspect null pointers");
-
-    MOZ_ASSERT(HasParticipant(aPtr, aParti),
-               "Suspected nsISupports pointer must QI to nsXPCOMCycleCollectionParticipant");
-
-    mPurpleBuf.Put(aPtr, aParti, aRefCnt);
+  CheckThreadSafety();
+
+  // Re-entering ::Suspect during collection used to be a fault, but
+  // we are canonicalizing nsISupports pointers using QI, so we will
+  // see some spurious refcount traffic here.
+
+  if (MOZ_UNLIKELY(mScanInProgress)) {
+    return;
+  }
+
+  MOZ_ASSERT(aPtr, "Don't suspect null pointers");
+
+  MOZ_ASSERT(HasParticipant(aPtr, aParti),
+             "Suspected nsISupports pointer must QI to nsXPCOMCycleCollectionParticipant");
+
+  mPurpleBuf.Put(aPtr, aParti, aRefCnt);
 }
 
 void
 nsCycleCollector::CheckThreadSafety()
 {
 #ifdef DEBUG
-    nsIThread* currentThread = NS_GetCurrentThread();
-    // XXXkhuey we can be called so late in shutdown that NS_GetCurrentThread
-    // returns null (after the thread manager has shut down)
-    MOZ_ASSERT(mThread == currentThread || !currentThread);
+  nsIThread* currentThread = NS_GetCurrentThread();
+  // XXXkhuey we can be called so late in shutdown that NS_GetCurrentThread
+  // returns null (after the thread manager has shut down)
+  MOZ_ASSERT(mThread == currentThread || !currentThread);
 #endif
 }
 
 // The cycle collector uses the mark bitmap to discover what JS objects
 // were reachable only from XPConnect roots that might participate in
 // cycles. We ask the JS runtime whether we need to force a GC before
 // this CC. It returns true on startup (before the mark bits have been set),
 // and also when UnmarkGray has run out of stack.  We also force GCs on shut
 // down to collect cycles involving both DOM and JS.
 void
 nsCycleCollector::FixGrayBits(bool aForceGC)
 {
-    CheckThreadSafety();
-
-    if (!mJSRuntime)
-        return;
-
-    if (!aForceGC) {
-        mJSRuntime->FixWeakMappingGrayBits();
-
-        bool needGC = mJSRuntime->NeedCollect();
-        // Only do a telemetry ping for non-shutdown CCs.
-        CC_TELEMETRY(_NEED_GC, needGC);
-        if (!needGC)
-            return;
-        mResults.mForcedGC = true;
-    }
-
-    TimeLog timeLog;
-    mJSRuntime->Collect(aForceGC ? JS::gcreason::SHUTDOWN_CC : JS::gcreason::CC_FORCED);
-    timeLog.Checkpoint("GC()");
+  CheckThreadSafety();
+
+  if (!mJSRuntime)
+    return;
+
+  if (!aForceGC) {
+    mJSRuntime->FixWeakMappingGrayBits();
+
+    bool needGC = mJSRuntime->NeedCollect();
+    // Only do a telemetry ping for non-shutdown CCs.
+    CC_TELEMETRY(_NEED_GC, needGC);
+    if (!needGC)
+      return;
+    mResults.mForcedGC = true;
+  }
+
+  TimeLog timeLog;
+  mJSRuntime->Collect(aForceGC ? JS::gcreason::SHUTDOWN_CC : JS::gcreason::CC_FORCED);
+  timeLog.Checkpoint("GC()");
 }
 
 void
 nsCycleCollector::CleanupAfterCollection()
 {
-    MOZ_ASSERT(mIncrementalPhase == CleanupPhase);
-    mGraph.Clear();
-
-    uint32_t interval = (uint32_t) ((TimeStamp::Now() - mCollectionStart).ToMilliseconds());
+  MOZ_ASSERT(mIncrementalPhase == CleanupPhase);
+  mGraph.Clear();
+
+  uint32_t interval = (uint32_t) ((TimeStamp::Now() - mCollectionStart).ToMilliseconds());
 #ifdef COLLECT_TIME_DEBUG
-    printf("cc: total cycle collector time was %ums\n", interval);
-    printf("cc: visited %u ref counted and %u GCed objects, freed %d ref counted and %d GCed objects",
-           mResults.mVisitedRefCounted, mResults.mVisitedGCed,
-           mResults.mFreedRefCounted, mResults.mFreedGCed);
-    uint32_t numVisited = mResults.mVisitedRefCounted + mResults.mVisitedGCed;
-    if (numVisited > 1000) {
-        uint32_t numFreed = mResults.mFreedRefCounted + mResults.mFreedGCed;
-        printf(" (%d%%)", 100 * numFreed / numVisited);
-    }
-    printf(".\ncc: \n");
+  printf("cc: total cycle collector time was %ums\n", interval);
+  printf("cc: visited %u ref counted and %u GCed objects, freed %d ref counted and %d GCed objects",
+         mResults.mVisitedRefCounted, mResults.mVisitedGCed,
+         mResults.mFreedRefCounted, mResults.mFreedGCed);
+  uint32_t numVisited = mResults.mVisitedRefCounted + mResults.mVisitedGCed;
+  if (numVisited > 1000) {
+    uint32_t numFreed = mResults.mFreedRefCounted + mResults.mFreedGCed;
+    printf(" (%d%%)", 100 * numFreed / numVisited);
+  }
+  printf(".\ncc: \n");
 #endif
-    CC_TELEMETRY( , interval);
-    CC_TELEMETRY(_VISITED_REF_COUNTED, mResults.mVisitedRefCounted);
-    CC_TELEMETRY(_VISITED_GCED, mResults.mVisitedGCed);
-    CC_TELEMETRY(_COLLECTED, mWhiteNodeCount);
-
-    if (mJSRuntime) {
-        mJSRuntime->EndCycleCollectionCallback(mResults);
-    }
-    mIncrementalPhase = IdlePhase;
+  CC_TELEMETRY( , interval);
+  CC_TELEMETRY(_VISITED_REF_COUNTED, mResults.mVisitedRefCounted);
+  CC_TELEMETRY(_VISITED_GCED, mResults.mVisitedGCed);
+  CC_TELEMETRY(_COLLECTED, mWhiteNodeCount);
+
+  if (mJSRuntime) {
+    mJSRuntime->EndCycleCollectionCallback(mResults);
+  }
+  mIncrementalPhase = IdlePhase;
 }
 
 void
 nsCycleCollector::ShutdownCollect()
 {
-    SliceBudget unlimitedBudget;
-    uint32_t i;
-    for (i = 0; i < DEFAULT_SHUTDOWN_COLLECTIONS; ++i) {
-        if (!Collect(ShutdownCC, unlimitedBudget, nullptr)) {
-            break;
-        }
+  SliceBudget unlimitedBudget;
+  uint32_t i;
+  for (i = 0; i < DEFAULT_SHUTDOWN_COLLECTIONS; ++i) {
+    if (!Collect(ShutdownCC, unlimitedBudget, nullptr)) {
+      break;
     }
-    NS_WARN_IF_FALSE(i < NORMAL_SHUTDOWN_COLLECTIONS, "Extra shutdown CC");
+  }
+  NS_WARN_IF_FALSE(i < NORMAL_SHUTDOWN_COLLECTIONS, "Extra shutdown CC");
 }
 
 static void
 PrintPhase(const char *aPhase)
 {
 #ifdef DEBUG_PHASES
-    printf("cc: begin %s on %s\n", aPhase,
-           NS_IsMainThread() ? "mainthread" : "worker");
+  printf("cc: begin %s on %s\n", aPhase,
+         NS_IsMainThread() ? "mainthread" : "worker");
 #endif
 }
 
 bool
 nsCycleCollector::Collect(ccType aCCType,
                           SliceBudget &aBudget,
                           nsICycleCollectorListener *aManualListener)
 {
-    CheckThreadSafety();
-
-    // This can legitimately happen in a few cases. See bug 383651.
-    if (mActivelyCollecting || mFreeingSnowWhite) {
-        return false;
-    }
-    mActivelyCollecting = true;
-
-    bool startedIdle = (mIncrementalPhase == IdlePhase);
-    bool collectedAny = false;
-
-    // If the CC started idle, it will call BeginCollection, which
-    // will do FreeSnowWhite, so it doesn't need to be done here.
-    if (!startedIdle) {
-        FreeSnowWhite(true);
+  CheckThreadSafety();
+
+  // This can legitimately happen in a few cases. See bug 383651.
+  if (mActivelyCollecting || mFreeingSnowWhite) {
+    return false;
+  }
+  mActivelyCollecting = true;
+
+  bool startedIdle = (mIncrementalPhase == IdlePhase);
+  bool collectedAny = false;
+
+  // If the CC started idle, it will call BeginCollection, which
+  // will do FreeSnowWhite, so it doesn't need to be done here.
+  if (!startedIdle) {
+    FreeSnowWhite(true);
+  }
+
+  bool finished = false;
+  do {
+    switch (mIncrementalPhase) {
+      case IdlePhase:
+        PrintPhase("BeginCollection");
+        BeginCollection(aCCType, aManualListener);
+        break;
+      case GraphBuildingPhase:
+        PrintPhase("MarkRoots");
+        MarkRoots(aBudget);
+        break;
+      case ScanAndCollectWhitePhase:
+        // We do ScanRoots and CollectWhite in a single slice to ens