--- a/mfbt/Assertions.cpp
+++ b/mfbt/Assertions.cpp
@@ -1,12 +1,10 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sw=4 et tw=99 ft=cpp:
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/Assertions.h"
 
 /* Implementations of runtime and static assertion macros for C and C++. */
 
 extern "C" {

--- a/mfbt/Assertions.h
+++ b/mfbt/Assertions.h
@@ -1,12 +1,10 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- * vim: set ts=8 sw=4 et tw=99 ft=cpp:
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* Implementations of runtime and static assertion macros for C and C++. */
 
 #ifndef mozilla_Assertions_h_
 #define mozilla_Assertions_h_
 

--- a/mfbt/Attributes.h
+++ b/mfbt/Attributes.h
@@ -1,12 +1,10 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sw=4 et tw=99 ft=cpp:
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* Implementations of various class and method modifier attributes. */
 
 #ifndef mozilla_Attributes_h_
 #define mozilla_Attributes_h_
 

--- a/mfbt/BloomFilter.h
+++ b/mfbt/BloomFilter.h
@@ -1,9 +1,9 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /*
  * A counting Bloom filter implementation.  This allows consumers to
  * do fast probabilistic "is item X in set Y?" testing which will
  * never answer "no" when the correct answer is "yes" (but might
@@ -47,17 +47,18 @@ namespace mozilla {
  * 4*(N/M)**2 for this filter.  In practice, if Y has a few hundred
  * elements then using a KeySize of 12 gives a reasonably low
  * incorrect answer rate.  A KeySize of 12 has the additional benefit
  * of using exactly one page for the filter in typical hardware
  * configurations.
  */
 
 template<unsigned KeySize, class T>
-class BloomFilter {
+class BloomFilter
+{
     /*
      * A counting Bloom filter with 8-bit counters.  For now we assume
      * that having two hash functions is enough, but we may revisit that
      * decision later.
      *
      * The filter uses an array with 2**KeySize entries.
      *
      * Assuming a well-distributed hash function, a Bloom filter with
@@ -96,17 +97,17 @@ class BloomFilter {
      *
      * What this means in practice is that for a few hundred keys using a
      * KeySize of 12 gives false positive rates on the order of 0.25-4%.
      *
      * Similarly, using a KeySize of 10 would lead to a 4% false
      * positive rate for N == 100 and to quite bad false positive
      * rates for larger N.
      */
-public:
+  public:
     BloomFilter() {
         MOZ_STATIC_ASSERT(KeySize <= keyShift, "KeySize too big");
 
         // Should we have a custom operator new using calloc instead and
         // require that we're allocated via the operator?
         clear();
     }
 
@@ -137,17 +138,17 @@ public:
 
     /*
      * Methods for add/remove/contain when we already have a hash computed
      */
     void add(uint32_t hash);
     void remove(uint32_t hash);
     bool mightContain(uint32_t hash) const;
 
-private:
+  private:
     static const size_t arraySize = (1 << KeySize);
     static const uint32_t keyMask = (1 << KeySize) - 1;
     static const uint32_t keyShift = 16;
 
     static uint32_t hash1(uint32_t hash) { return hash & keyMask; }
     static uint32_t hash2(uint32_t hash) { return (hash >> keyShift) & keyMask; }
 
     uint8_t& firstSlot(uint32_t hash) { return counters[hash1(hash)]; }
@@ -159,74 +160,74 @@ private:
 
     uint8_t counters[arraySize];
 };
 
 template<unsigned KeySize, class T>
 inline void
 BloomFilter<KeySize, T>::clear()
 {
-    memset(counters, 0, arraySize);
+  memset(counters, 0, arraySize);
 }
 
 template<unsigned KeySize, class T>
 inline void
 BloomFilter<KeySize, T>::add(uint32_t hash)
 {
-    uint8_t& slot1 = firstSlot(hash);
-    if (MOZ_LIKELY(!full(slot1)))
-        ++slot1;
+  uint8_t& slot1 = firstSlot(hash);
+  if (MOZ_LIKELY(!full(slot1)))
+    ++slot1;
 
-    uint8_t& slot2 = secondSlot(hash);
-    if (MOZ_LIKELY(!full(slot2)))
-        ++slot2;
+  uint8_t& slot2 = secondSlot(hash);
+  if (MOZ_LIKELY(!full(slot2)))
+    ++slot2;
 }
 
 template<unsigned KeySize, class T>
 MOZ_ALWAYS_INLINE void
 BloomFilter<KeySize, T>::add(const T* t)
 {
-    uint32_t hash = t->hash();
-    return add(hash);
+  uint32_t hash = t->hash();
+  return add(hash);
 }
 
 template<unsigned KeySize, class T>
 inline void
 BloomFilter<KeySize, T>::remove(uint32_t hash)
 {
-    // If the slots are full, we don't know whether we bumped them to be
-    // there when we added or not, so just leave them full.
-    uint8_t& slot1 = firstSlot(hash);
-    if (MOZ_LIKELY(!full(slot1)))
-        --slot1;
+  // If the slots are full, we don't know whether we bumped them to be
+  // there when we added or not, so just leave them full.
+  uint8_t& slot1 = firstSlot(hash);
+  if (MOZ_LIKELY(!full(slot1)))
+    --slot1;
 
-    uint8_t& slot2 = secondSlot(hash);
-    if (MOZ_LIKELY(!full(slot2)))
-        --slot2;
+  uint8_t& slot2 = secondSlot(hash);
+  if (MOZ_LIKELY(!full(slot2)))
+    --slot2;
 }
 
 template<unsigned KeySize, class T>
 MOZ_ALWAYS_INLINE void
 BloomFilter<KeySize, T>::remove(const T* t)
 {
-    uint32_t hash = t->hash();
-    remove(hash);
+  uint32_t hash = t->hash();
+  remove(hash);
 }
 
 template<unsigned KeySize, class T>
 MOZ_ALWAYS_INLINE bool
 BloomFilter<KeySize, T>::mightContain(uint32_t hash) const
 {
-    // Check that all the slots for this hash contain something
-    return firstSlot(hash) && secondSlot(hash);
+  // Check that all the slots for this hash contain something
+  return firstSlot(hash) && secondSlot(hash);
 }
 
 template<unsigned KeySize, class T>
 MOZ_ALWAYS_INLINE bool
 BloomFilter<KeySize, T>::mightContain(const T* t) const
 {
-    uint32_t hash = t->hash();
-    return mightContain(hash);
+  uint32_t hash = t->hash();
+  return mightContain(hash);
 }
 
 } // namespace mozilla
 
 #endif /* mozilla_BloomFilter_h_ */

--- a/mfbt/GuardObjects.h
+++ b/mfbt/GuardObjects.h
@@ -1,10 +1,9 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* vim: set ts=8 sw=4 et tw=99 ft=cpp: */
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* Implementation of macros to ensure correct use of RAII Auto* objects. */
 
 #ifndef mozilla_GuardObjects_h
 #define mozilla_GuardObjects_h
@@ -13,28 +12,29 @@
 #include "mozilla/Types.h"
 
 #ifdef __cplusplus
 
 #ifdef DEBUG
 
 namespace mozilla {
 namespace detail {
+
 /*
  * The following classes are designed to cause assertions to detect
  * inadvertent use of guard objects as temporaries. In other words,
  * when we have a guard object whose only purpose is its constructor and
  * destructor (and is never otherwise referenced), the intended use
  * might be:
  *
- *     AutoRestore savePainting(mIsPainting);
+ *   AutoRestore savePainting(mIsPainting);
  *
  * but is is easy to accidentally write:
  *
- *     AutoRestore(mIsPainting);
+ *   AutoRestore(mIsPainting);
  *
  * which compiles just fine, but runs the destructor well before the
  * intended time.
  *
  * They work by adding (#ifdef DEBUG) an additional parameter to the
  * guard object's constructor, with a default value, so that users of
  * the guard object's API do not need to do anything. The default value
  * of this parameter is a temporary object. C++ (ISO/IEC 14882:1998),
@@ -67,52 +67,51 @@ namespace detail {
  * https://developer.mozilla.org/en/Using_RAII_classes_in_Mozilla
  */
 class MOZ_EXPORT_API(GuardObjectNotifier)
 {
   private:
     bool* statementDone;
 
   public:
-    GuardObjectNotifier() : statementDone(NULL) {}
+    GuardObjectNotifier() : statementDone(NULL) { }
 
     ~GuardObjectNotifier() {
-        *statementDone = true;
+      *statementDone = true;
     }
 
     void setStatementDone(bool* statementIsDone) {
-        statementDone = statementIsDone;
+      statementDone = statementIsDone;
     }
 };
 
 class MOZ_EXPORT_API(GuardObjectNotificationReceiver)
 {
   private:
     bool statementDone;
 
   public:
-    GuardObjectNotificationReceiver() : statementDone(false) {}
+    GuardObjectNotificationReceiver() : statementDone(false) { }
 
     ~GuardObjectNotificationReceiver() {
-        /*
-         * Assert that the guard object was not used as a temporary.
-         * (Note that this assert might also fire if init is not called
-         * because the guard object's implementation is not using the
-         * above macros correctly.)
-         */
-        MOZ_ASSERT(statementDone);
+      /*
+       * Assert that the guard object was not used as a temporary.  (Note that
+       * this assert might also fire if init is not called because the guard
+       * object's implementation is not using the above macros correctly.)
+       */
+      MOZ_ASSERT(statementDone);
     }
 
     void init(const GuardObjectNotifier& constNotifier) {
-        /*
-         * constNotifier is passed as a const reference so that we can pass a
-         * temporary, but we really intend it as non-const.
-         */
-        GuardObjectNotifier& notifier = const_cast<GuardObjectNotifier&>(constNotifier);
-        notifier.setStatementDone(&statementDone);
+      /*
+       * constNotifier is passed as a const reference so that we can pass a
+       * temporary, but we really intend it as non-const.
+       */
+      GuardObjectNotifier& notifier = const_cast<GuardObjectNotifier&>(constNotifier);
+      notifier.setStatementDone(&statementDone);
     }
 };
 
 } /* namespace detail */
 } /* namespace mozilla */
 
 #endif /* DEBUG */
 

--- a/mfbt/HashFunctions.cpp
+++ b/mfbt/HashFunctions.cpp
@@ -1,18 +1,17 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sw=4 et tw=99 ft=cpp:
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-/* Implementations of hash functions */
+/* Implementations of hash functions. */
 
 #include "mozilla/HashFunctions.h"
+
 #include <string.h>
 
 namespace mozilla {
 
 MFBT_API(uint32_t)
 HashBytes(const void* bytes, size_t length)
 {
   uint32_t hash = 0;
@@ -24,16 +23,15 @@ HashBytes(const void* bytes, size_t leng
     /* Do an explicitly unaligned load of the data. */
     size_t data;
     memcpy(&data, b + i, sizeof(size_t));
 
     hash = AddToHash(hash, data, sizeof(data));
   }
 
   /* Get the remaining bytes. */
-  for (; i < length; i++) {
+  for (; i < length; i++)
     hash = AddToHash(hash, b[i]);
-  }
 
   return hash;
 }
 
 } /* namespace mozilla */

--- a/mfbt/HashFunctions.h
+++ b/mfbt/HashFunctions.h
@@ -1,16 +1,14 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- * vim: set ts=8 sw=4 et tw=99 ft=cpp:
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-/* Utilities for hashing */
+/* Utilities for hashing. */
 
 /*
  * This file exports functions for hashing data down to a 32-bit value,
  * including:
  *
  *  - HashString    Hash a char* or uint16_t/wchar_t* of known or unknown
  *                  length.
  *
@@ -21,26 +19,28 @@
  *                  pointers, and function pointers.
  *
  *  - AddToHash     Add one or more values to the given hash.  This supports the
  *                  same list of types as HashGeneric.
  *
  *
  * You can chain these functions together to hash complex objects.  For example:
  *
- *  class ComplexObject {
- *    char* str;
- *    uint32_t uint1, uint2;
- *    void (*callbackFn)();
+ *  class ComplexObject
+ *  {
+ *      char* str;
+ *      uint32_t uint1, uint2;
+ *      void (*callbackFn)();
  *
- *    uint32_t Hash() {
- *      uint32_t hash = HashString(str);
- *      hash = AddToHash(hash, uint1, uint2);
- *      return AddToHash(hash, callbackFn);
- *    }
+ *    public:
+ *      uint32_t hash() {
+ *        uint32_t hash = HashString(str);
+ *        hash = AddToHash(hash, uint1, uint2);
+ *        return AddToHash(hash, callbackFn);
+ *      }
  *  };
  *
  * If you want to hash an nsAString or nsACString, use the HashString functions
  * in nsHashKey.h.
  */
 
 #ifndef mozilla_HashFunctions_h_
 #define mozilla_HashFunctions_h_

--- a/mfbt/Likely.h
+++ b/mfbt/Likely.h
@@ -1,21 +1,22 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /*
  * MOZ_LIKELY and MOZ_UNLIKELY macros to hint to the compiler how a
  * boolean predicate should be branch-predicted.
  */
 
-#ifndef Likely_h_
-#define Likely_h_
+#ifndef mozilla_Likely_h_
+#define mozilla_Likely_h_
 
 #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 2))
 #  define MOZ_LIKELY(x)   (__builtin_expect((x), 1))
 #  define MOZ_UNLIKELY(x) (__builtin_expect((x), 0))
 #else
 #  define MOZ_LIKELY(x)   (x)
 #  define MOZ_UNLIKELY(x) (x)
 #endif
 
-#endif /* Likely_h_ */
+#endif /* mozilla_Likely_h_ */

--- a/mfbt/LinkedList.h
+++ b/mfbt/LinkedList.h
@@ -1,12 +1,10 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=4 sw=4 tw=80 et cin:
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* A type-safe doubly-linked list class. */
 
 /*
  * The classes LinkedList<T> and LinkedListElement<T> together form a
  * convenient, type-safe doubly-linked list implementation.
@@ -15,46 +13,40 @@
  * LinkedListElement<T>.  A given object may be in only one linked list at a
  * time.
  *
  * For example, you might use LinkedList in a simple observer list class as
  * follows.
  *
  *   class Observer : public LinkedListElement<Observer>
  *   {
- *     void observe(char* topic) { ... }
+ *     public:
+ *       void observe(char* topic) { ... }
  *   };
  *
  *   class ObserverContainer
  *   {
- *   private:
- *     LinkedList<Observer> list;
- *
- *   public:
+ *     private:
+ *       LinkedList<Observer> list;
  *
- *     void addObserver(Observer* observer)
- *     {
- *       // Will assert if |observer| is part of another list.
- *       list.insertBack(observer);
- *     }
+ *     public:
+ *       void addObserver(Observer* observer) {
+ *         // Will assert if |observer| is part of another list.
+ *         list.insertBack(observer);
+ *       }
  *
- *     void removeObserver(Observer* observer)
- *     {
- *       // Will assert if |observer| is not part of some list.
- *       observer.remove();
- *     }
+ *       void removeObserver(Observer* observer) {
+ *         // Will assert if |observer| is not part of some list.
+ *         observer.remove();
+ *       }
  *
- *     void notifyObservers(char* topic)
- *     {
- *       for (Observer* o = list.getFirst();
- *            o != NULL;
- *            o = o->getNext()) {
- *         o->Observe(topic);
+ *       void notifyObservers(char* topic) {
+ *         for (Observer* o = list.getFirst(); o != NULL; o = o->getNext())
+ *           o->Observe(topic);
  *       }
- *     }
  *   };
  *
  */
 
 #ifndef mozilla_LinkedList_h_
 #define mozilla_LinkedList_h_
 
 #include "mozilla/Assertions.h"
@@ -99,326 +91,295 @@ class LinkedListElement
      * pointer to its iterator in the object in order to accomplish this.  Not
      * only would this waste space, but you'd have to remember to update that
      * pointer every time you added or removed the object from a list.
      *
      * In-place, constant-time removal is a killer feature of doubly-linked
      * lists, and supporting this painlessly was a key design criterion.
      */
 
-private:
+  private:
     LinkedListElement* next;
     LinkedListElement* prev;
     const bool isSentinel;
 
-public:
-    LinkedListElement()
-        : next(this)
-        , prev(this)
-        , isSentinel(false)
-    {
-    }
+  public:
+    LinkedListElement() : next(this), prev(this), isSentinel(false) { }
 
     /*
      * Get the next element in the list, or NULL if this is the last element in
      * the list.
      */
-    T* getNext()
-    {
-        return next->asT();
+    T* getNext() {
+      return next->asT();
     }
-    const T* getNext() const
-    {
-        return next->asT();
+    const T* getNext() const {
+      return next->asT();
     }
 
     /*
      * Get the previous element in the list, or NULL if this is the first element
      * in the list.
      */
-    T* getPrevious()
-    {
-        return prev->asT();
+    T* getPrevious() {
+      return prev->asT();
     }
-    const T* getPrevious() const
-    {
-        return prev->asT();
+    const T* getPrevious() const {
+      return prev->asT();
     }
 
     /*
      * Insert elem after this element in the list.  |this| must be part of a
      * linked list when you call setNext(); otherwise, this method will assert.
      */
-    void setNext(T* elem)
-    {
+    void setNext(T* elem) {
         MOZ_ASSERT(isInList());
         setNextUnsafe(elem);
     }
 
     /*
      * Insert elem before this element in the list.  |this| must be part of a
      * linked list when you call setPrevious(); otherwise, this method will
      * assert.
      */
-    void setPrevious(T* elem)
-    {
-        MOZ_ASSERT(isInList());
-        setPreviousUnsafe(elem);
+    void setPrevious(T* elem) {
+      MOZ_ASSERT(isInList());
+      setPreviousUnsafe(elem);
     }
 
     /*
      * Remove this element from the list which contains it.  If this element is
      * not currently part of a linked list, this method asserts.
      */
-    void remove()
-    {
-        MOZ_ASSERT(isInList());
+    void remove() {
+      MOZ_ASSERT(isInList());
 
-        prev->next = next;
-        next->prev = prev;
-        next = this;
-        prev = this;
+      prev->next = next;
+      next->prev = prev;
+      next = this;
+      prev = this;
     }
 
     /*
      * Return true if |this| part is of a linked list, and false otherwise.
      */
-    bool isInList() const
-    {
-        MOZ_ASSERT((next == this) == (prev == this));
-        return next != this;
+    bool isInList() const {
+      MOZ_ASSERT((next == this) == (prev == this));
+      return next != this;
     }
 
-private:
-    LinkedListElement& operator=(const LinkedList<T>& other) MOZ_DELETE;
-    LinkedListElement(const LinkedList<T>& other) MOZ_DELETE;
-
+  private:
     friend class LinkedList<T>;
 
     enum NodeKind {
-        NODE_KIND_NORMAL,
-        NODE_KIND_SENTINEL
+      NODE_KIND_NORMAL,
+      NODE_KIND_SENTINEL
     };
 
     LinkedListElement(NodeKind nodeKind)
-        : next(this)
-        , prev(this)
-        , isSentinel(nodeKind == NODE_KIND_SENTINEL)
+      : next(this),
+        prev(this),
+        isSentinel(nodeKind == NODE_KIND_SENTINEL)
     {
     }
 
     /*
      * Return |this| cast to T* if we're a normal node, or return NULL if we're
      * a sentinel node.
      */
-    T* asT()
-    {
-        if (isSentinel)
-            return NULL;
+    T* asT() {
+      if (isSentinel)
+        return NULL;
 
-        return static_cast<T*>(this);
+      return static_cast<T*>(this);
     }
-    const T* asT() const
-    {
-        if (isSentinel)
-            return NULL;
+    const T* asT() const {
+      if (isSentinel)
+        return NULL;
 
-        return static_cast<const T*>(this);
+      return static_cast<const T*>(this);
     }
 
     /*
      * Insert elem after this element, but don't check that this element is in
      * the list.  This is called by LinkedList::insertFront().
      */
-    void setNextUnsafe(T* elem)
-    {
-        LinkedListElement *listElem = static_cast<LinkedListElement*>(elem);
-        MOZ_ASSERT(!listElem->isInList());
+    void setNextUnsafe(T* elem) {
+      LinkedListElement *listElem = static_cast<LinkedListElement*>(elem);
+      MOZ_ASSERT(!listElem->isInList());
 
-        listElem->next = this->next;
-        listElem->prev = this;
-        this->next->prev = listElem;
-        this->next = listElem;
+      listElem->next = this->next;
+      listElem->prev = this;
+      this->next->prev = listElem;
+      this->next = listElem;
     }
 
     /*
      * Insert elem before this element, but don't check that this element is in
      * the list.  This is called by LinkedList::insertBack().
      */
-    void setPreviousUnsafe(T* elem)
-    {
-        LinkedListElement<T>* listElem = static_cast<LinkedListElement<T>*>(elem);
-        MOZ_ASSERT(!listElem->isInList());
+    void setPreviousUnsafe(T* elem) {
+      LinkedListElement<T>* listElem = static_cast<LinkedListElement<T>*>(elem);
+      MOZ_ASSERT(!listElem->isInList());
 
-        listElem->next = this;
-        listElem->prev = this->prev;
-        this->prev->next = listElem;
-        this->prev = listElem;
+      listElem->next = this;
+      listElem->prev = this->prev;
+      this->prev->next = listElem;
+      this->prev = listElem;
     }
+
+  private:
+    LinkedListElement& operator=(const LinkedList<T>& other) MOZ_DELETE;
+    LinkedListElement(const LinkedList<T>& other) MOZ_DELETE;
 };
 
 template<typename T>
 class LinkedList
 {
-private:
+  private:
     LinkedListElement<T> sentinel;
 
-public:
-    LinkedList& operator=(const LinkedList<T>& other) MOZ_DELETE;
-    LinkedList(const LinkedList<T>& other) MOZ_DELETE;
-
-    LinkedList()
-        : sentinel(LinkedListElement<T>::NODE_KIND_SENTINEL)
-    {
-    }
+  public:
+    LinkedList() : sentinel(LinkedListElement<T>::NODE_KIND_SENTINEL) { }
 
     /*
      * Add elem to the front of the list.
      */
-    void insertFront(T* elem)
-    {
-        /* Bypass setNext()'s this->isInList() assertion. */
-        sentinel.setNextUnsafe(elem);
+    void insertFront(T* elem) {
+      /* Bypass setNext()'s this->isInList() assertion. */
+      sentinel.setNextUnsafe(elem);
     }
 
     /*
      * Add elem to the back of the list.
      */
-    void insertBack(T* elem)
-    {
-        sentinel.setPreviousUnsafe(elem);
+    void insertBack(T* elem) {
+      sentinel.setPreviousUnsafe(elem);
     }
 
     /*
      * Get the first element of the list, or NULL if the list is empty.
      */
-    T* getFirst()
-    {
-        return sentinel.getNext();
+    T* getFirst() {
+      return sentinel.getNext();
     }
-    const T* getFirst() const
-    {
-        return sentinel.getNext();
+    const T* getFirst() const {
+      return sentinel.getNext();
     }
 
     /*
      * Get the last element of the list, or NULL if the list is empty.
      */
-    T* getLast()
-    {
-        return sentinel.getPrevious();
+    T* getLast() {
+      return sentinel.getPrevious();
     }
-    const T* getLast() const
-    {
-        return sentinel.getPrevious();
+    const T* getLast() const {
+      return sentinel.getPrevious();
     }
 
     /*
      * Get and remove the first element of the list.  If the list is empty,
      * return NULL.
      */
-    T* popFirst()
-    {
-        T* ret = sentinel.getNext();
-        if (ret)
-            static_cast<LinkedListElement<T>*>(ret)->remove();
-
-        return ret;
+    T* popFirst() {
+      T* ret = sentinel.getNext();
+      if (ret)
+        static_cast<LinkedListElement<T>*>(ret)->remove();
+      return ret;
     }
 
     /*
      * Get and remove the last element of the list.  If the list is empty,
      * return NULL.
      */
-    T* popLast()
-    {
-        T* ret = sentinel.getPrevious();
-        if (ret)
-            static_cast<LinkedListElement<T>*>(ret)->remove();
-
-        return ret;
+    T* popLast() {
+      T* ret = sentinel.getPrevious();
+      if (ret)
+        static_cast<LinkedListElement<T>*>(ret)->remove();
+      return ret;
     }
 
     /*
      * Return true if the list is empty, or false otherwise.
      */
-    bool isEmpty() const
-    {
-        return !sentinel.isInList();
+    bool isEmpty() const {
+      return !sentinel.isInList();
     }
 
     /*
      * Remove all the elements from the list.
      *
      * This runs in time linear to the list's length, because we have to mark
      * each element as not in the list.
      */
-    void clear()
-    {
-        while (popFirst())
-            continue;
+    void clear() {
+      while (popFirst())
+        continue;
     }
 
     /*
      * In a debug build, make sure that the list is sane (no cycles, consistent
      * next/prev pointers, only one sentinel).  Has no effect in release builds.
      */
-    void debugAssertIsSane() const
-    {
+    void debugAssertIsSane() const {
 #ifdef DEBUG
-        /*
-         * Check for cycles in the forward singly-linked list using the
-         * tortoise/hare algorithm.
-         */
-        for (const LinkedListElement<T>* slow = sentinel.next,
-                                       * fast1 = sentinel.next->next,
-                                       * fast2 = sentinel.next->next->next;
-             slow != sentinel && fast1 != sentinel && fast2 != sentinel;
-             slow = slow->next,
-             fast1 = fast2->next,
-             fast2 = fast1->next) {
+      const LinkedListElement<T>* slow;
+      const LinkedListElement<T>* fast1;
+      const LinkedListElement<T>* fast2;
 
-            MOZ_ASSERT(slow != fast1);
-            MOZ_ASSERT(slow != fast2);
-        }
+      /*
+       * Check for cycles in the forward singly-linked list using the
+       * tortoise/hare algorithm.
+       */
+      for (slow = sentinel.next,
+           fast1 = sentinel.next->next,
+           fast2 = sentinel.next->next->next;
+           slow != sentinel && fast1 != sentinel && fast2 != sentinel;
+           slow = slow->next, fast1 = fast2->next, fast2 = fast1->next)
+      {
+        MOZ_ASSERT(slow != fast1);
+        MOZ_ASSERT(slow != fast2);
+      }
 
-        /* Check for cycles in the backward singly-linked list. */
-        for (const LinkedListElement<T>* slow = sentinel.prev,
-                                       * fast1 = sentinel.prev->prev,
-                                       * fast2 = sentinel.prev->prev->prev;
-             slow != sentinel && fast1 != sentinel && fast2 != sentinel;
-             slow = slow->prev,
-             fast1 = fast2->prev,
-             fast2 = fast1->prev) {
-
-            MOZ_ASSERT(slow != fast1);
-            MOZ_ASSERT(slow != fast2);
-        }
+      /* Check for cycles in the backward singly-linked list. */
+      for (slow = sentinel.prev,
+           fast1 = sentinel.prev->prev,
+           fast2 = sentinel.prev->prev->prev;
+           slow != sentinel && fast1 != sentinel && fast2 != sentinel;
+           slow = slow->prev, fast1 = fast2->prev, fast2 = fast1->prev)
+      {
+        MOZ_ASSERT(slow != fast1);
+        MOZ_ASSERT(slow != fast2);
+      }
 
-        /*
-         * Check that |sentinel| is the only node in the list with
-         * isSentinel == true.
-         */
-        for (const LinkedListElement<T>* elem = sentinel.next;
-             elem != sentinel;
-             elem = elem->next) {
-
-          MOZ_ASSERT(!elem->isSentinel);
-        }
+      /*
+       * Check that |sentinel| is the only node in the list with
+       * isSentinel == true.
+       */
+      for (const LinkedListElement<T>* elem = sentinel.next;
+           elem != sentinel;
+           elem = elem->next)
+      {
+        MOZ_ASSERT(!elem->isSentinel);
+      }
 
-        /* Check that the next/prev pointers match up. */
-        const LinkedListElement<T>* prev = sentinel;
-        const LinkedListElement<T>* cur = sentinel.next;
-        do {
-            MOZ_ASSERT(cur->prev == prev);
-            MOZ_ASSERT(prev->next == cur);
+      /* Check that the next/prev pointers match up. */
+      const LinkedListElement<T>* prev = sentinel;
+      const LinkedListElement<T>* cur = sentinel.next;
+      do {
+          MOZ_ASSERT(cur->prev == prev);
+          MOZ_ASSERT(prev->next == cur);
 
-            prev = cur;
-            cur = cur->next;
-        } while (cur != sentinel);
+          prev = cur;
+          cur = cur->next;
+      } while (cur != sentinel);
 #endif /* ifdef DEBUG */
     }
+
+  private:
+    LinkedList& operator=(const LinkedList<T>& other) MOZ_DELETE;
+    LinkedList(const LinkedList<T>& other) MOZ_DELETE;
 };
 
 } /* namespace mozilla */
 
 #endif /* ifdef __cplusplus */
 #endif /* ifdef mozilla_LinkedList_h_ */

--- a/mfbt/RangedPtr.h
+++ b/mfbt/RangedPtr.h
@@ -1,12 +1,10 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sw=4 et tw=99 ft=cpp:
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /*
  * Implements a smart pointer asserted to remain within a range specified at
  * construction.
  */
 
@@ -33,215 +31,215 @@ namespace mozilla {
  * passing pointers), if the method being called isn't inlined.  If you are in
  * extremely performance-critical code, you may want to be careful using this
  * smart pointer as an argument type.
  *
  * RangedPtr<T> intentionally does not implicitly convert to T*.  Use get() to
  * explicitly convert to T*.  Keep in mind that the raw pointer of course won't
  * implement bounds checking in debug builds.
  */
-template <typename T>
+template<typename T>
 class RangedPtr
 {
     T* ptr;
 
 #ifdef DEBUG
     T* const rangeStart;
     T* const rangeEnd;
 #endif
 
     void checkSanity() {
-        MOZ_ASSERT(rangeStart <= ptr);
-        MOZ_ASSERT(ptr <= rangeEnd);
+      MOZ_ASSERT(rangeStart <= ptr);
+      MOZ_ASSERT(ptr <= rangeEnd);
     }
 
     /* Creates a new pointer for |ptr|, restricted to this pointer's range. */
     RangedPtr<T> create(T *ptr) const {
 #ifdef DEBUG
-        return RangedPtr<T>(ptr, rangeStart, rangeEnd);
+      return RangedPtr<T>(ptr, rangeStart, rangeEnd);
 #else
-        return RangedPtr<T>(ptr, NULL, size_t(0));
+      return RangedPtr<T>(ptr, NULL, size_t(0));
 #endif
     }
 
   public:
     RangedPtr(T* p, T* start, T* end)
       : ptr(p)
 #ifdef DEBUG
       , rangeStart(start), rangeEnd(end)
 #endif
     {
-        MOZ_ASSERT(rangeStart <= rangeEnd);
-        checkSanity();
+      MOZ_ASSERT(rangeStart <= rangeEnd);
+      checkSanity();
     }
     RangedPtr(T* p, T* start, size_t length)
       : ptr(p)
 #ifdef DEBUG
       , rangeStart(start), rangeEnd(start + length)
 #endif
     {
-        MOZ_ASSERT(length <= size_t(-1) / sizeof(T));
-        MOZ_ASSERT(uintptr_t(rangeStart) + length * sizeof(T) >= uintptr_t(rangeStart));
-        checkSanity();
+      MOZ_ASSERT(length <= size_t(-1) / sizeof(T));
+      MOZ_ASSERT(uintptr_t(rangeStart) + length * sizeof(T) >= uintptr_t(rangeStart));
+      checkSanity();
     }
 
     /* Equivalent to RangedPtr(p, p, length). */
     RangedPtr(T* p, size_t length)
       : ptr(p)
 #ifdef DEBUG
       , rangeStart(p), rangeEnd(p + length)
 #endif
     {
-        MOZ_ASSERT(length <= size_t(-1) / sizeof(T));
-        MOZ_ASSERT(uintptr_t(rangeStart) + length * sizeof(T) >= uintptr_t(rangeStart));
-        checkSanity();
+      MOZ_ASSERT(length <= size_t(-1) / sizeof(T));
+      MOZ_ASSERT(uintptr_t(rangeStart) + length * sizeof(T) >= uintptr_t(rangeStart));
+      checkSanity();
     }
 
     /* Equivalent to RangedPtr(arr, arr, N). */
     template<size_t N>
     RangedPtr(T arr[N])
       : ptr(arr)
 #ifdef DEBUG
       , rangeStart(arr), rangeEnd(arr + N)
 #endif
     {
       checkSanity();
     }
 
     T* get() const {
-        return ptr;
+      return ptr;
     }
 
     /*
      * You can only assign one RangedPtr into another if the two pointers have
      * the same valid range:
      *
      *   char arr1[] = "hi";
      *   char arr2[] = "bye";
      *   RangedPtr<char> p1(arr1, 2);
      *   p1 = RangedPtr<char>(arr1 + 1, arr1, arr1 + 2); // works
      *   p1 = RangedPtr<char>(arr2, 3);                  // asserts
      */
     RangedPtr<T>& operator=(const RangedPtr<T>& other) {
-        MOZ_ASSERT(rangeStart == other.rangeStart);
-        MOZ_ASSERT(rangeEnd == other.rangeEnd);
-        ptr = other.ptr;
-        checkSanity();
-        return *this;
+      MOZ_ASSERT(rangeStart == other.rangeStart);
+      MOZ_ASSERT(rangeEnd == other.rangeEnd);
+      ptr = other.ptr;
+      checkSanity();
+      return *this;
     }
 
     RangedPtr<T> operator+(size_t inc) {
-        MOZ_ASSERT(inc <= size_t(-1) / sizeof(T));
-        MOZ_ASSERT(ptr + inc > ptr);
-        return create(ptr + inc);
+      MOZ_ASSERT(inc <= size_t(-1) / sizeof(T));
+      MOZ_ASSERT(ptr + inc > ptr);
+      return create(ptr + inc);
     }
 
     RangedPtr<T> operator-(size_t dec) {
-        MOZ_ASSERT(dec <= size_t(-1) / sizeof(T));
-        MOZ_ASSERT(ptr - dec < ptr);
-        return create(ptr - dec);
+      MOZ_ASSERT(dec <= size_t(-1) / sizeof(T));
+      MOZ_ASSERT(ptr - dec < ptr);
+      return create(ptr - dec);
     }
 
     /*
      * You can assign a raw pointer into a RangedPtr if the raw pointer is
      * within the range specified at creation.
      */
     template <typename U>
     RangedPtr<T>& operator=(U* p) {
-        *this = create(p);
-        return *this;
+      *this = create(p);
+      return *this;
     }
 
     template <typename U>
     RangedPtr<T>& operator=(const RangedPtr<U>& p) {
-        MOZ_ASSERT(rangeStart <= p.ptr);
-        MOZ_ASSERT(p.ptr <= rangeEnd);
-        ptr = p.ptr;
-        checkSanity();
-        return *this;
+      MOZ_ASSERT(rangeStart <= p.ptr);
+      MOZ_ASSERT(p.ptr <= rangeEnd);
+      ptr = p.ptr;
+      checkSanity();
+      return *this;
     }
 
     RangedPtr<T>& operator++() {
-        return (*this += 1);
+      return (*this += 1);
     }
 
     RangedPtr<T> operator++(int) {
-        RangedPtr<T> rcp = *this;
-        ++*this;
-        return rcp;
+      RangedPtr<T> rcp = *this;
+      ++*this;
+      return rcp;
     }
 
     RangedPtr<T>& operator--() {
-        return (*this -= 1);
+      return (*this -= 1);
     }
 
     RangedPtr<T> operator--(int) {
-        RangedPtr<T> rcp = *this;
-        --*this;
-        return rcp;
+      RangedPtr<T> rcp = *this;
+      --*this;
+      return rcp;
     }
 
     RangedPtr<T>& operator+=(size_t inc) {
-        this->operator=<T>(*this + inc);
-        return *this;
+      *this = *this + inc;
+      return *this;
     }
 
     RangedPtr<T>& operator-=(size_t dec) {
-        this->operator=<T>(*this - dec);
-        return *this;
+      *this = *this - dec;
+      return *this;
     }
 
     T& operator[](int index) const {
-        MOZ_ASSERT(size_t(index > 0 ? index : -index) <= size_t(-1) / sizeof(T));
-        return *create(ptr + index);
+      MOZ_ASSERT(size_t(index > 0 ? index : -index) <= size_t(-1) / sizeof(T));
+      return *create(ptr + index);
     }
 
     T& operator*() const {
-        return *ptr;
+      return *ptr;
     }
 
     template <typename U>
     bool operator==(const RangedPtr<U>& other) const {
-        return ptr == other.ptr;
+      return ptr == other.ptr;
     }
     template <typename U>
     bool operator!=(const RangedPtr<U>& other) const {
-        return !(*this == other);
+      return !(*this == other);
     }
 
     template<typename U>
     bool operator==(const U* u) const {
-        return ptr == u;
+      return ptr == u;
     }
     template<typename U>
     bool operator!=(const U* u) const {
-        return !(*this == u);
+      return !(*this == u);
     }
 
     template <typename U>
     bool operator<(const RangedPtr<U>& other) const {
-        return ptr < other.ptr;
+      return ptr < other.ptr;
     }
     template <typename U>
     bool operator<=(const RangedPtr<U>& other) const {
-        return ptr <= other.ptr;
+      return ptr <= other.ptr;
     }
 
     template <typename U>
     bool operator>(const RangedPtr<U>& other) const {
-        return ptr > other.ptr;
+      return ptr > other.ptr;
     }
     template <typename U>
     bool operator>=(const RangedPtr<U>& other) const {
-        return ptr >= other.ptr;
+      return ptr >= other.ptr;
     }
 
     size_t operator-(const RangedPtr<T>& other) const {
-        MOZ_ASSERT(ptr >= other.ptr);
-        return PointerRangeSize(other.ptr, ptr);
+      MOZ_ASSERT(ptr >= other.ptr);
+      return PointerRangeSize(other.ptr, ptr);
     }
 
   private:
     RangedPtr() MOZ_DELETE;
     T* operator&() MOZ_DELETE;
     operator T*() const MOZ_DELETE;
 };
 

--- a/mfbt/RefPtr.h
+++ b/mfbt/RefPtr.h
@@ -1,12 +1,10 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sw=4 et tw=99 ft=cpp:
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* Helpers for defining and using refcounted objects. */
 
 #ifndef mozilla_RefPtr_h_
 #define mozilla_RefPtr_h_
 
@@ -42,46 +40,46 @@ template<typename T> OutParamRef<T> byRe
  * state distinguishes use-before-ref (refcount==0) from
  * use-after-destroy (refcount==-0xdead).
  */
 template<typename T>
 class RefCounted
 {
     friend class RefPtr<T>;
 
-public:
+  public:
     RefCounted() : refCnt(0) { }
     ~RefCounted() { MOZ_ASSERT(refCnt == -0xdead); }
 
     // Compatibility with nsRefPtr.
     void AddRef() {
-        MOZ_ASSERT(refCnt >= 0);
-        ++refCnt;
+      MOZ_ASSERT(refCnt >= 0);
+      ++refCnt;
     }
 
     void Release() {
-        MOZ_ASSERT(refCnt > 0);
-        if (0 == --refCnt) {
+      MOZ_ASSERT(refCnt > 0);
+      if (0 == --refCnt) {
 #ifdef DEBUG
-            refCnt = -0xdead;
+        refCnt = -0xdead;
 #endif
-            delete static_cast<T*>(this);
-        }
+        delete static_cast<T*>(this);
+      }
     }
 
     // Compatibility with wtf::RefPtr.
     void ref() { AddRef(); }
     void deref() { Release(); }
     int refCount() const { return refCnt; }
     bool hasOneRef() const {
-        MOZ_ASSERT(refCnt > 0);
-        return refCnt == 1;
+      MOZ_ASSERT(refCnt > 0);
+      return refCnt == 1;
     }
 
-private:
+  private:
     int refCnt;
 };
 
 /**
  * RefPtr points to a refcounted thing that has AddRef and Release
  * methods to increase/decrease the refcount, respectively.  After a
  * RefPtr<T> is assigned a T*, the T* can be used through the RefPtr
  * as if it were a T*.
@@ -92,119 +90,117 @@ private:
  */
 template<typename T>
 class RefPtr
 {
     // To allow them to use unref()
     friend class TemporaryRef<T>;
     friend class OutParamRef<T>;
 
-    struct dontRef {};
+    struct DontRef {};
 
-public:
+  public:
     RefPtr() : ptr(0) { }
     RefPtr(const RefPtr& o) : ptr(ref(o.ptr)) {}
     RefPtr(const TemporaryRef<T>& o) : ptr(o.drop()) {}
     RefPtr(T* t) : ptr(ref(t)) {}
 
     template<typename U>
     RefPtr(const RefPtr<U>& o) : ptr(ref(o.get())) {}
 
     ~RefPtr() { unref(ptr); }
 
     RefPtr& operator=(const RefPtr& o) {
-        assign(ref(o.ptr));
-        return *this;
+      assign(ref(o.ptr));
+      return *this;
     }
     RefPtr& operator=(const TemporaryRef<T>& o) {
-        assign(o.drop());
-        return *this;
+      assign(o.drop());
+      return *this;
     }
     RefPtr& operator=(T* t) {
-        assign(ref(t));
-        return *this;
+      assign(ref(t));
+      return *this;
     }
 
     template<typename U>
     RefPtr& operator=(const RefPtr<U>& o) {
-        assign(ref(o.get()));
-        return *this;
+      assign(ref(o.get()));
+      return *this;
     }
 
     TemporaryRef<T> forget() {
-        T* tmp = ptr;
-        ptr = 0;
-        return TemporaryRef<T>(tmp, dontRef());
+      T* tmp = ptr;
+      ptr = 0;
+      return TemporaryRef<T>(tmp, DontRef());
     }
 
     T* get() const { return ptr; }
     operator T*() const { return ptr; }
     T* operator->() const { return ptr; }
     T& operator*() const { return *ptr; }
     template<typename U>
     operator TemporaryRef<U>() { return TemporaryRef<U>(ptr); }
 
-private:
+  private:
     void assign(T* t) {
-        unref(ptr);
-        ptr = t;
+      unref(ptr);
+      ptr = t;
     }
 
     T* ptr;
 
     static MOZ_ALWAYS_INLINE T* ref(T* t) {
-        if (t) {
-            t->AddRef();
-        }
-        return t;
+      if (t)
+        t->AddRef();
+      return t;
     }
 
     static MOZ_ALWAYS_INLINE void unref(T* t) {
-        if (t) {
-            t->Release();
-        }
+      if (t)
+        t->Release();
     }
 };
 
 /**
  * TemporaryRef<T> represents an object that holds a temporary
  * reference to a T.  TemporaryRef objects can't be manually ref'd or
  * unref'd (being temporaries, not lvalues), so can only relinquish
  * references to other objects, or unref on destruction.
  */
 template<typename T>
 class TemporaryRef
 {
     // To allow it to construct TemporaryRef from a bare T*
     friend class RefPtr<T>;
 
-    typedef typename RefPtr<T>::dontRef dontRef;
+    typedef typename RefPtr<T>::DontRef DontRef;
 
-public:
+  public:
     TemporaryRef(T* t) : ptr(RefPtr<T>::ref(t)) {}
     TemporaryRef(const TemporaryRef& o) : ptr(o.drop()) {}
 
     template<typename U>
     TemporaryRef(const TemporaryRef<U>& o) : ptr(o.drop()) {}
 
     ~TemporaryRef() { RefPtr<T>::unref(ptr); }
 
     T* drop() const {
-        T* tmp = ptr;
-        ptr = 0;
-        return tmp;
+      T* tmp = ptr;
+      ptr = 0;
+      return tmp;
     }
 
-private:
-    TemporaryRef(T* t, const dontRef&) : ptr(t) {}
+  private:
+    TemporaryRef(T* t, const DontRef&) : ptr(t) {}
 
     mutable T* ptr;
 
-    TemporaryRef();
-    TemporaryRef& operator=(const TemporaryRef&);
+    TemporaryRef() MOZ_DELETE;
+    void operator=(const TemporaryRef&) MOZ_DELETE;
 };
 
 /**
  * OutParamRef is a wrapper that tracks a refcounted pointer passed as
  * an outparam argument to a function.  OutParamRef implements COM T**
  * outparam semantics: this requires the callee to AddRef() the T*
  * returned through the T** outparam on behalf of the caller.  This
  * means the caller (through OutParamRef) must Release() the old
@@ -216,42 +212,42 @@ private:
  * outparams and passing OutParamRef<T> to T**.  Prefer RefPtr<T>*
  * outparams over T** outparams.
  */
 template<typename T>
 class OutParamRef
 {
     friend OutParamRef byRef<T>(RefPtr<T>&);
 
-public:
+  public:
     ~OutParamRef() {
-        RefPtr<T>::unref(refPtr.ptr);
-        refPtr.ptr = tmp;
+      RefPtr<T>::unref(refPtr.ptr);
+      refPtr.ptr = tmp;
     }
 
     operator T**() { return &tmp; }
 
-private:
+  private:
     OutParamRef(RefPtr<T>& p) : refPtr(p), tmp(p.get()) {}
 
     RefPtr<T>& refPtr;
     T* tmp;
 
     OutParamRef() MOZ_DELETE;
     OutParamRef& operator=(const OutParamRef&) MOZ_DELETE;
 };
 
 /**
  * byRef cooperates with OutParamRef to implement COM outparam semantics.
  */
 template<typename T>
 OutParamRef<T>
 byRef(RefPtr<T>& ptr)
 {
-    return OutParamRef<T>(ptr);
+  return OutParamRef<T>(ptr);
 }
 
 } // namespace mozilla
 
 #endif // mozilla_RefPtr_h_
 
 
 #if 0
@@ -259,152 +255,152 @@ byRef(RefPtr<T>& ptr)
 // Command line that builds these tests
 //
 //   cp RefPtr.h test.cc && g++ -g -Wall -pedantic -DDEBUG -o test test.cc && ./test
 
 using namespace mozilla;
 
 struct Foo : public RefCounted<Foo>
 {
-    Foo() : dead(false) { }
-    ~Foo() {
-        MOZ_ASSERT(!dead);
-        dead = true;
-        numDestroyed++;
-    }
+  Foo() : dead(false) { }
+  ~Foo() {
+    MOZ_ASSERT(!dead);
+    dead = true;
+    numDestroyed++;
+  }
 
-    bool dead;
-    static int numDestroyed;
+  bool dead;
+  static int numDestroyed;
 };
 int Foo::numDestroyed;
 
 struct Bar : public Foo { };
 
 TemporaryRef<Foo>
 NewFoo()
 {
-    return RefPtr<Foo>(new Foo());
+  return RefPtr<Foo>(new Foo());
 }
 
 TemporaryRef<Foo>
 NewBar()
 {
-    return new Bar();
+  return new Bar();
 }
 
 void
 GetNewFoo(Foo** f)
 {
-    *f = new Bar();
-    // Kids, don't try this at home
-    (*f)->AddRef();
+  *f = new Bar();
+  // Kids, don't try this at home
+  (*f)->AddRef();
 }
 
 void
 GetPassedFoo(Foo** f)
 {
-    // Kids, don't try this at home
-    (*f)->AddRef();
+  // Kids, don't try this at home
+  (*f)->AddRef();
 }
 
 void
 GetNewFoo(RefPtr<Foo>* f)
 {
-    *f = new Bar();
+  *f = new Bar();
 }
 
 void
 GetPassedFoo(RefPtr<Foo>* f)
 {}
 
 TemporaryRef<Foo>
 GetNullFoo()
 {
-    return 0;
+  return 0;
 }
 
 int
 main(int argc, char** argv)
 {
-    // This should blow up
+  // This should blow up
 //    Foo* f = new Foo(); delete f;
 
-    MOZ_ASSERT(0 == Foo::numDestroyed);
-    {
-        RefPtr<Foo> f = new Foo();
-        MOZ_ASSERT(f->refCount() == 1);
-    }
+  MOZ_ASSERT(0 == Foo::numDestroyed);
+  {
+    RefPtr<Foo> f = new Foo();
+    MOZ_ASSERT(f->refCount() == 1);
+  }
+  MOZ_ASSERT(1 == Foo::numDestroyed);
+
+  {
+    RefPtr<Foo> f1 = NewFoo();
+    RefPtr<Foo> f2(NewFoo());
     MOZ_ASSERT(1 == Foo::numDestroyed);
+  }
+  MOZ_ASSERT(3 == Foo::numDestroyed);
 
+  {
+    RefPtr<Foo> b = NewBar();
+    MOZ_ASSERT(3 == Foo::numDestroyed);
+  }
+  MOZ_ASSERT(4 == Foo::numDestroyed);
+
+  {
+    RefPtr<Foo> f1;
     {
-        RefPtr<Foo> f1 = NewFoo();
-        RefPtr<Foo> f2(NewFoo());
-        MOZ_ASSERT(1 == Foo::numDestroyed);
-    }
-    MOZ_ASSERT(3 == Foo::numDestroyed);
-
-    {
-        RefPtr<Foo> b = NewBar();
-        MOZ_ASSERT(3 == Foo::numDestroyed);
+      f1 = new Foo();
+      RefPtr<Foo> f2(f1);
+      RefPtr<Foo> f3 = f2;
+      MOZ_ASSERT(4 == Foo::numDestroyed);
     }
     MOZ_ASSERT(4 == Foo::numDestroyed);
+  }
+  MOZ_ASSERT(5 == Foo::numDestroyed);
 
-    {
-        RefPtr<Foo> f1;
-        {
-            f1 = new Foo();
-            RefPtr<Foo> f2(f1);
-            RefPtr<Foo> f3 = f2;
-            MOZ_ASSERT(4 == Foo::numDestroyed);
-        }
-        MOZ_ASSERT(4 == Foo::numDestroyed);
-    }
-    MOZ_ASSERT(5 == Foo::numDestroyed);
+  {
+    RefPtr<Foo> f = new Foo();
+    f.forget();
+    MOZ_ASSERT(6 == Foo::numDestroyed);
+  }
 
-    {
-        RefPtr<Foo> f = new Foo();
-        f.forget();
-        MOZ_ASSERT(6 == Foo::numDestroyed);
-    }
+  {
+    RefPtr<Foo> f = new Foo();
+    GetNewFoo(byRef(f));
+    MOZ_ASSERT(7 == Foo::numDestroyed);
+  }
+  MOZ_ASSERT(8 == Foo::numDestroyed);
 
-    {
-        RefPtr<Foo> f = new Foo();
-        GetNewFoo(byRef(f));
-        MOZ_ASSERT(7 == Foo::numDestroyed);
-    }
+  {
+    RefPtr<Foo> f = new Foo();
+    GetPassedFoo(byRef(f));
     MOZ_ASSERT(8 == Foo::numDestroyed);
+  }
+  MOZ_ASSERT(9 == Foo::numDestroyed);
 
-    {
-        RefPtr<Foo> f = new Foo();
-        GetPassedFoo(byRef(f));
-        MOZ_ASSERT(8 == Foo::numDestroyed);
-    }
-    MOZ_ASSERT(9 == Foo::numDestroyed);
-
-    {
-        RefPtr<Foo> f = new Foo();
-        GetNewFoo(&f);
-        MOZ_ASSERT(10 == Foo::numDestroyed);
-    }
-    MOZ_ASSERT(11 == Foo::numDestroyed);
+  {
+    RefPtr<Foo> f = new Foo();
+    GetNewFoo(&f);
+    MOZ_ASSERT(10 == Foo::numDestroyed);
+  }
+  MOZ_ASSERT(11 == Foo::numDestroyed);
 
-    {
-        RefPtr<Foo> f = new Foo();
-        GetPassedFoo(&f);
-        MOZ_ASSERT(11 == Foo::numDestroyed);
-    }
-    MOZ_ASSERT(12 == Foo::numDestroyed);
+  {
+    RefPtr<Foo> f = new Foo();
+    GetPassedFoo(&f);
+    MOZ_ASSERT(11 == Foo::numDestroyed);
+  }
+  MOZ_ASSERT(12 == Foo::numDestroyed);
 
-    {
-        RefPtr<Foo> f1 = new Bar();
-    }
-    MOZ_ASSERT(13 == Foo::numDestroyed);
+  {
+    RefPtr<Foo> f1 = new Bar();
+  }
+  MOZ_ASSERT(13 == Foo::numDestroyed);
 
-    {
-        RefPtr<Foo> f = GetNullFoo();
-        MOZ_ASSERT(13 == Foo::numDestroyed);
-    }
+  {
+    RefPtr<Foo> f = GetNullFoo();
     MOZ_ASSERT(13 == Foo::numDestroyed);
+  }
+  MOZ_ASSERT(13 == Foo::numDestroyed);
 
-    return 0;
+  return 0;
 }
 
 #endif

--- a/mfbt/Scoped.h
+++ b/mfbt/Scoped.h
@@ -61,164 +61,164 @@
  *     typedef value_type type;
  *     // Returns the value corresponding to the uninitialized or freed state
  *     const static type empty();
  *     // Release resources corresponding to the wrapped value
  *     // This function is responsible for not releasing an |empty| value
  *     const static void release(type);
  *   }
  */
-template <typename Traits>
+template<typename Traits>
 class Scoped
 {
-public:
-  typedef typename Traits::type Resource;
+  public:
+    typedef typename Traits::type Resource;
 
-  explicit Scoped(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM)
-    : value(Traits::empty())
-  {
-    MOZ_GUARD_OBJECT_NOTIFIER_INIT;
-  }
-  explicit Scoped(const Resource& value
-                  MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
-    : value(value)
-  {
-    MOZ_GUARD_OBJECT_NOTIFIER_INIT;
-  }
-  ~Scoped() {
-    Traits::release(value);
-  }
+    explicit Scoped(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM)
+      : value(Traits::empty())
+    {
+      MOZ_GUARD_OBJECT_NOTIFIER_INIT;
+    }
+    explicit Scoped(const Resource& value
+                    MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+      : value(value)
+    {
+      MOZ_GUARD_OBJECT_NOTIFIER_INIT;
+    }
+    ~Scoped() {
+      Traits::release(value);
+    }
 
-  // Constant getter
-  operator const Resource&() const { return value; }
-  const Resource& operator->() const { return value; }
-  const Resource& get() const { return value; }
-  // Non-constant getter.
-  Resource& rwget() { return value; }
+    // Constant getter
+    operator const Resource&() const { return value; }
+    const Resource& operator->() const { return value; }
+    const Resource& get() const { return value; }
+    // Non-constant getter.
+    Resource& rwget() { return value; }
 
-  /*
-   * Forget the resource.
-   *
-   * Once |forget| has been called, the |Scoped| is neutralized, i.e. it will
-   * have no effect at destruction (unless it is reset to another resource by
-   * |operator=|).
-   *
-   * @return The original resource.
-   */
-  Resource forget() {
-    Resource tmp = value;
-    value = Traits::empty();
-    return tmp;
-  }
+    /*
+     * Forget the resource.
+     *
+     * Once |forget| has been called, the |Scoped| is neutralized, i.e. it will
+     * have no effect at destruction (unless it is reset to another resource by
+     * |operator=|).
+     *
+     * @return The original resource.
+     */
+    Resource forget() {
+      Resource tmp = value;
+      value = Traits::empty();
+      return tmp;
+    }
 
-  /*
-   * Perform immediate clean-up of this |Scoped|.
-   *
-   * If this |Scoped| is currently empty, this method has no effect.
-   */
-  void dispose() {
-    Traits::release(value);
-    value = Traits::empty();
-  }
+    /*
+     * Perform immediate clean-up of this |Scoped|.
+     *
+     * If this |Scoped| is currently empty, this method has no effect.
+     */
+    void dispose() {
+      Traits::release(value);
+      value = Traits::empty();
+    }
 
-  bool operator==(const Resource& other) const {
-    return value == other;
-  }
+    bool operator==(const Resource& other) const {
+      return value == other;
+    }
 
-  /*
-   * Replace the resource with another resource.
-   *
-   * Calling |operator=| has the side-effect of triggering clean-up. If you do
-   * not want to trigger clean-up, you should first invoke |forget|.
-   *
-   * @return this
-   */
-  Scoped<Traits>& operator=(const Resource& other) {
-    return reset(other);
-  }
-  Scoped<Traits>& reset(const Resource& other) {
-    Traits::release(value);
-    value = other;
-    return *this;
-  }
+    /*
+     * Replace the resource with another resource.
+     *
+     * Calling |operator=| has the side-effect of triggering clean-up. If you do
+     * not want to trigger clean-up, you should first invoke |forget|.
+     *
+     * @return this
+     */
+    Scoped<Traits>& operator=(const Resource& other) {
+      return reset(other);
+    }
+    Scoped<Traits>& reset(const Resource& other) {
+      Traits::release(value);
+      value = other;
+      return *this;
+    }
 
-private:
-  explicit Scoped(const Scoped<Traits>& value) MOZ_DELETE;
-  Scoped<Traits>& operator=(const Scoped<Traits>& value) MOZ_DELETE;
+  private:
+    explicit Scoped(const Scoped<Traits>& value) MOZ_DELETE;
+    Scoped<Traits>& operator=(const Scoped<Traits>& value) MOZ_DELETE;
 
-private:
-  Resource value;
-  MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
+  private:
+    Resource value;
+    MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 };
 
 /*
  * SCOPED_TEMPLATE defines a templated class derived from Scoped
  * This allows to implement templates such as ScopedFreePtr.
  *
  * @param name The name of the class to define.
  * @param Traits A struct implementing clean-up. See the implementations
  * for more details.
  */
 #define SCOPED_TEMPLATE(name, Traits)                          \
-template <typename Type>                                       \
+template<typename Type>                                        \
 struct name : public Scoped<Traits<Type> >                     \
 {                                                              \
-  typedef Scoped<Traits<Type> > Super;                         \
-  typedef typename Super::Resource Resource;                   \
-  name& operator=(Resource ptr) {                              \
-    Super::operator=(ptr);                                     \
-    return *this;                                              \
-  }                                                            \
-  explicit name(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM)          \
-    : Super(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_TO_PARENT)    \
-  {}                                                           \
-  explicit name(Resource ptr                                   \
-                MOZ_GUARD_OBJECT_NOTIFIER_PARAM)               \
-    : Super(ptr MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT)     \
-  {}                                                           \
-private:                                                       \
-  explicit name(name& source) MOZ_DELETE;                      \
-  name& operator=(name& source) MOZ_DELETE;                    \
+    typedef Scoped<Traits<Type> > Super;                       \
+    typedef typename Super::Resource Resource;                 \
+    name& operator=(Resource ptr) {                            \
+      Super::operator=(ptr);                                   \
+      return *this;                                            \
+    }                                                          \
+    explicit name(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM)        \
+      : Super(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_TO_PARENT)  \
+    {}                                                         \
+    explicit name(Resource ptr                                 \
+                  MOZ_GUARD_OBJECT_NOTIFIER_PARAM)             \
+      : Super(ptr MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT)   \
+    {}                                                         \
+  private:                                                     \
+    explicit name(name& source) MOZ_DELETE;                    \
+    name& operator=(name& source) MOZ_DELETE;                  \
 };
 
 /*
  * ScopedFreePtr is a RAII wrapper for pointers that need to be free()d.
  *
  *   struct S { ... };
  *   ScopedFreePtr<S> foo = malloc(sizeof(S));
  *   ScopedFreePtr<char> bar = strdup(str);
  */
-template <typename T>
+template<typename T>
 struct ScopedFreePtrTraits
 {
-  typedef T* type;
-  static T* empty() { return NULL; }
-  static void release(T* ptr) { free(ptr); }
+    typedef T* type;
+    static T* empty() { return NULL; }
+    static void release(T* ptr) { free(ptr); }
 };
 SCOPED_TEMPLATE(ScopedFreePtr, ScopedFreePtrTraits)
 
 /*
  * ScopedDeletePtr is a RAII wrapper for pointers that need to be deleted.
  *
  *   struct S { ... };
  *   ScopedDeletePtr<S> foo = new S();
  */
-template <typename T>
-struct ScopedDeletePtrTraits : public ScopedFreePtrTraits<T> {
-  static void release(T* ptr) { delete ptr; }
+template<typename T>
+struct ScopedDeletePtrTraits : public ScopedFreePtrTraits<T>
+{
+    static void release(T* ptr) { delete ptr; }
 };
 SCOPED_TEMPLATE(ScopedDeletePtr, ScopedDeletePtrTraits)
 
 /*
  * ScopedDeleteArray is a RAII wrapper for pointers that need to be delete[]ed.
  *
  *   struct S { ... };
  *   ScopedDeleteArray<S> foo = new S[42];
  */
-template <typename T>
+template<typename T>
 struct ScopedDeleteArrayTraits : public ScopedFreePtrTraits<T>
 {
-  static void release(T* ptr) { delete [] ptr; }
+    static void release(T* ptr) { delete [] ptr; }
 };
 SCOPED_TEMPLATE(ScopedDeleteArray, ScopedDeleteArrayTraits)
 
-
 #endif // mozilla_Scoped_h_

--- a/mfbt/StandardInteger.h
+++ b/mfbt/StandardInteger.h
@@ -1,12 +1,10 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sw=4 et tw=99 ft=cpp:
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* Implements the C99 <stdint.h> interface for C and C++ code. */
 
 #ifndef mozilla_StandardInteger_h_
 #define mozilla_StandardInteger_h_
 

--- a/mfbt/ThreadLocal.h
+++ b/mfbt/ThreadLocal.h
@@ -1,13 +1,14 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-// Cross-platform lightweight thread local data wrappers
+/* Cross-platform lightweight thread local data wrappers. */
 
 #ifndef mozilla_TLS_h_
 #define mozilla_TLS_h_
 
 #if defined(XP_WIN)
 // This file will get included in any file that wants to add a profiler mark.
 // In order to not bring <windows.h> together we could include windef.h and
 // winbase.h which are sufficient to get the prototypes for the Tls* functions.
@@ -58,27 +59,27 @@ typedef sig_atomic_t sig_safe_t;
  * }
  *
  * // Set the TLS value
  * tlsKey.set(123);
  *
  * // Get the TLS value
  * int value = tlsKey.get();
  */
-template <typename T>
+template<typename T>
 class ThreadLocal
 {
 #if defined(XP_WIN)
     typedef unsigned long key_t;
 #else
     typedef pthread_key_t key_t;
 #endif
 
     union Helper {
-      void *ptr;
+      void* ptr;
       T value;
     };
 
   public:
     MOZ_WARN_UNUSED_RESULT inline bool init();
 
     inline T get() const;
 
@@ -88,46 +89,51 @@ class ThreadLocal
       return inited;
     }
 
   private:
     key_t key;
     bool inited;
 };
 
-template <typename T>
+template<typename T>
 inline bool
-ThreadLocal<T>::init() {
-  MOZ_STATIC_ASSERT(sizeof(T) <= sizeof(void *), "mozilla::ThreadLocal can't be used for types larger than a pointer");
+ThreadLocal<T>::init()
+{
+  MOZ_STATIC_ASSERT(sizeof(T) <= sizeof(void *),
+                    "mozilla::ThreadLocal can't be used for types larger than "
+                    "a pointer");
   MOZ_ASSERT(!initialized());
 #ifdef XP_WIN
   key = TlsAlloc();
   inited = key != 0xFFFFFFFFUL; // TLS_OUT_OF_INDEXES
 #else
   inited = !pthread_key_create(&key, NULL);
 #endif
   return inited;
 }
 
-template <typename T>
+template<typename T>
 inline T
-ThreadLocal<T>::get() const {
+ThreadLocal<T>::get() const
+{
   MOZ_ASSERT(initialized());
   Helper h;
 #ifdef XP_WIN
   h.ptr = TlsGetValue(key);
 #else
   h.ptr = pthread_getspecific(key);
 #endif
   return h.value;
 }
 
-template <typename T>
+template<typename T>
 inline bool
-ThreadLocal<T>::set(const T value) {
+ThreadLocal<T>::set(const T value)
+{
   MOZ_ASSERT(initialized());
   Helper h;
   h.value = value;
 #ifdef XP_WIN
   return TlsSetValue(key, h.ptr);
 #else
   return !pthread_setspecific(key, h.ptr);
 #endif

--- a/mfbt/Types.h
+++ b/mfbt/Types.h
@@ -1,12 +1,10 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sw=4 et tw=99 ft=cpp:
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* mfbt foundational types and macros. */
 
 #ifndef mozilla_Types_h_
 #define mozilla_Types_h_
 

--- a/mfbt/Util.h
+++ b/mfbt/Util.h
@@ -1,12 +1,10 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sw=4 et tw=99 ft=cpp:
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /*
  * Miscellaneous uncategorized functionality.  Please add new functionality to
  * new headers, or to other appropriate existing headers, not here.
  */
 
@@ -17,92 +15,88 @@
 #include "mozilla/Attributes.h"
 #include "mozilla/Types.h"
 
 #ifdef __cplusplus
 
 namespace mozilla {
 
 /**
- * DebugOnly contains a value of type T, but only in debug builds.  In
- * release builds, it does not contain a value.  This helper is
- * intended to be used along with ASSERT()-style macros, allowing one
- * to write
+ * DebugOnly contains a value of type T, but only in debug builds.  In release
+ * builds, it does not contain a value.  This helper is intended to be used with
+ * MOZ_ASSERT()-style macros, allowing one to write:
  *
- *   DebugOnly<bool> check = Func();
- *   ASSERT(check);
+ *   DebugOnly<bool> check = func();
+ *   MOZ_ASSERT(check);
  *
- * more concisely than declaring |check| conditional on #ifdef DEBUG,
- * but also without allocating storage space for |check| in release
- * builds.
+ * more concisely than declaring |check| conditional on #ifdef DEBUG, but also
+ * without allocating storage space for |check| in release builds.
  *
- * DebugOnly instances can only be coerced to T in debug builds; in
- * release builds, they don't have a value so type coercion is not
- * well defined.
+ * DebugOnly instances can only be coerced to T in debug builds.  In release
+ * builds they don't have a value, so type coercion is not well defined.
  */
-template <typename T>
+template<typename T>
 struct DebugOnly
 {
 #ifdef DEBUG
     T value;
 
-    DebugOnly() {}
-    DebugOnly(const T& other) : value(other) {}
-    DebugOnly(const DebugOnly& other) : value(other.value) {}
+    DebugOnly() { }
+    DebugOnly(const T& other) : value(other) { }
+    DebugOnly(const DebugOnly& other) : value(other.value) { }
     DebugOnly& operator=(const T& rhs) {
-        value = rhs;
-        return *this;
+      value = rhs;
+      return *this;
     }
     void operator++(int) {
-        value++;
+      value++;
     }
     void operator--(int) {
-        value--;
+      value--;
     }
 
     T *operator&() { return &value; }
 
     operator T&() { return value; }
     operator const T&() const { return value; }
 
     T& operator->() { return value; }
 
 #else
-    DebugOnly() {}
-    DebugOnly(const T&) {}
-    DebugOnly(const DebugOnly&) {}
+    DebugOnly() { }
+    DebugOnly(const T&) { }
+    DebugOnly(const DebugOnly&) { }
     DebugOnly& operator=(const T&) { return *this; }
-    void operator++(int) {}
-    void operator--(int) {}
+    void operator++(int) { }
+    void operator--(int) { }
 #endif
 
     /*
      * DebugOnly must always have a destructor or else it will
      * generate "unused variable" warnings, exactly what it's intended
      * to avoid!
      */
     ~DebugOnly() {}
 };
 
 /*
  * This class, and the corresponding macro MOZ_ALIGNOF, figure out how many 
  * bytes of alignment a given type needs.
  */
 template<class T>
-struct AlignmentFinder
+class AlignmentFinder
 {
-private:
-  struct Aligner
-  {
-    char c;
-    T t;
-  };
+    struct Aligner
+    {
+        char c;
+        T t;
+    };
 
-public:
-  static const int alignment = sizeof(Aligner) - sizeof(T);
+  public:
+    static const size_t alignment = sizeof(Aligner) - sizeof(T);
 };
 
 #define MOZ_ALIGNOF(T) mozilla::AlignmentFinder<T>::alignment
 
 /*
  * Declare the MOZ_ALIGNED_DECL macro for declaring aligned types.
  *
  * For instance,
@@ -119,216 +113,218 @@ public:
 #  define MOZ_ALIGNED_DECL(_type, _align) \
      __declspec(align(_align)) _type
 #else
 #  warning "We don't know how to align variables on this compiler."
 #  define MOZ_ALIGNED_DECL(_type, _align) _type
 #endif
 
 /*
- * AlignedElem<N> is a structure whose alignment is guaranteed to be at least N bytes.
+ * AlignedElem<N> is a structure whose alignment is guaranteed to be at least N
+ * bytes.
  *
  * We support 1, 2, 4, 8, and 16-bit alignment.
  */
 template<size_t align>
 struct AlignedElem;
 
 /*
  * We have to specialize this template because GCC doesn't like __attribute__((aligned(foo))) where
  * foo is a template parameter.
  */
 
 template<>
 struct AlignedElem<1>
 {
-  MOZ_ALIGNED_DECL(uint8_t elem, 1);
+    MOZ_ALIGNED_DECL(uint8_t elem, 1);
 };
 
 template<>
 struct AlignedElem<2>
 {
-  MOZ_ALIGNED_DECL(uint8_t elem, 2);
+    MOZ_ALIGNED_DECL(uint8_t elem, 2);
 };
 
 template<>
 struct AlignedElem<4>
 {
-  MOZ_ALIGNED_DECL(uint8_t elem, 4);
+    MOZ_ALIGNED_DECL(uint8_t elem, 4);
 };
 
 template<>
 struct AlignedElem<8>
 {
-  MOZ_ALIGNED_DECL(uint8_t elem, 8);
+    MOZ_ALIGNED_DECL(uint8_t elem, 8);
 };
 
 template<>
 struct AlignedElem<16>
 {
-  MOZ_ALIGNED_DECL(uint8_t elem, 16);
+    MOZ_ALIGNED_DECL(uint8_t elem, 16);
 };
 
 /*
  * This utility pales in comparison to Boost's aligned_storage. The utility
  * simply assumes that uint64_t is enough alignment for anyone. This may need
  * to be extended one day...
  *
  * As an important side effect, pulling the storage into this template is
  * enough obfuscation to confuse gcc's strict-aliasing analysis into not giving
  * false negatives when we cast from the char buffer to whatever type we've
  * constructed using the bytes.
  */
-template <size_t nbytes>
+template<size_t nbytes>
 struct AlignedStorage
 {
     union U {
-        char bytes[nbytes];
-        uint64_t _;
+      char bytes[nbytes];
+      uint64_t _;
     } u;
 
-    const void *addr() const { return u.bytes; }
-    void *addr() { return u.bytes; }
+    const void* addr() const { return u.bytes; }
+    void* addr() { return u.bytes; }
 };
 
-template <class T>
+template<class T>
 struct AlignedStorage2
 {
     union U {
-        char bytes[sizeof(T)];
-        uint64_t _;
+      char bytes[sizeof(T)];
+      uint64_t _;
     } u;
 
-    const T *addr() const { return (const T *)u.bytes; }
-    T *addr() { return (T *)(void *)u.bytes; }
+    const T* addr() const { return reinterpret_cast<const T*>(u.bytes); }
+    T* addr() { return static_cast<T*>(static_cast<void*>(u.bytes)); }
 };
 
 /*
  * Small utility for lazily constructing objects without using dynamic storage.
  * When a Maybe<T> is constructed, it is |empty()|, i.e., no value of T has
  * been constructed and no T destructor will be called when the Maybe<T> is
  * destroyed. Upon calling |construct|, a T object will be constructed with the
  * given arguments and that object will be destroyed when the owning Maybe<T>
  * is destroyed.
  *
  * N.B. GCC seems to miss some optimizations with Maybe and may generate extra
  * branches/loads/stores. Use with caution on hot paths.
  */
-template <class T>
+template<class T>
 class Maybe
 {
     AlignedStorage2<T> storage;
     bool constructed;
 
-    T &asT() { return *storage.addr(); }
-
-    explicit Maybe(const Maybe &other);
-    const Maybe &operator=(const Maybe &other);
+    T& asT() { return *storage.addr(); }
 
   public:
     Maybe() { constructed = false; }
     ~Maybe() { if (constructed) asT().~T(); }
 
     bool empty() const { return !constructed; }
 
     void construct() {
-        MOZ_ASSERT(!constructed);
-        new(storage.addr()) T();
-        constructed = true;
+      MOZ_ASSERT(!constructed);
+      new (storage.addr()) T();
+      constructed = true;
     }
 
-    template <class T1>
-    void construct(const T1 &t1) {
-        MOZ_ASSERT(!constructed);
-        new(storage.addr()) T(t1);
-        constructed = true;
+    template<class T1>
+    void construct(const T1& t1) {
+      MOZ_ASSERT(!constructed);
+      new (storage.addr()) T(t1);
+      constructed = true;
     }
 
-    template <class T1, class T2>
-    void construct(const T1 &t1, const T2 &t2) {
-        MOZ_ASSERT(!constructed);
-        new(storage.addr()) T(t1, t2);
-        constructed = true;
+    template<class T1, class T2>
+    void construct(const T1& t1, const T2& t2) {
+      MOZ_ASSERT(!constructed);
+      new (storage.addr()) T(t1, t2);
+      constructed = true;
     }
 
-    template <class T1, class T2, class T3>
-    void construct(const T1 &t1, const T2 &t2, const T3 &t3) {
-        MOZ_ASSERT(!constructed);
-        new(storage.addr()) T(t1, t2, t3);
-        constructed = true;
+    template<class T1, class T2, class T3>
+    void construct(const T1& t1, const T2& t2, const T3& t3) {
+      MOZ_ASSERT(!constructed);
+      new (storage.addr()) T(t1, t2, t3);
+      constructed = true;
     }
 
-    template <class T1, class T2, class T3, class T4>
-    void construct(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4) {
-        MOZ_ASSERT(!constructed);
-        new(storage.addr()) T(t1, t2, t3, t4);
-        constructed = true;
+    template<class T1, class T2, class T3, class T4>
+    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
+      MOZ_ASSERT(!constructed);
+      new (storage.addr()) T(t1, t2, t3, t4);
+      constructed = true;
     }
 
-    T *addr() {
-        MOZ_ASSERT(constructed);
-        return &asT();
+    T* addr() {
+      MOZ_ASSERT(constructed);
+      return &asT();
     }
 
-    T &ref() {
-        MOZ_ASSERT(constructed);
-        return asT();
+    T& ref() {
+      MOZ_ASSERT(constructed);
+      return asT();
     }
 
-    const T &ref() const {
-        MOZ_ASSERT(constructed);
-        return const_cast<Maybe *>(this)->asT();
+    const T& ref() const {
+      MOZ_ASSERT(constructed);
+      return const_cast<Maybe*>(this)->asT();
     }
 
     void destroy() {
-        ref().~T();
-        constructed = false;
+      ref().~T();
+      constructed = false;
     }
 
     void destroyIfConstructed() {
-        if (!empty())
-            destroy();
+      if (!empty())
+        destroy();
     }
+
+  private:
+    Maybe(const Maybe& other) MOZ_DELETE;
+    const Maybe& operator=(const Maybe& other) MOZ_DELETE;
 };
 
 /*
  * Safely subtract two pointers when it is known that end >= begin.  This avoids
  * the common compiler bug that if (size_t(end) - size_t(begin)) has the MSB
  * set, the unsigned subtraction followed by right shift will produce -1, or
  * size_t(-1), instead of the real difference.
  */
-template <class T>
+template<class T>
 MOZ_ALWAYS_INLINE size_t
 PointerRangeSize(T* begin, T* end)
 {
-    MOZ_ASSERT(end >= begin);
-    return (size_t(end) - size_t(begin)) / sizeof(T);
+  MOZ_ASSERT(end >= begin);
+  return (size_t(end) - size_t(begin)) / sizeof(T);
 }
 
 /*
  * Compute the length of an array with constant length.  (Use of this method
  * with a non-array pointer will not compile.)
  *
  * Beware of the implicit trailing '\0' when using this with string constants.
  */
 template<typename T, size_t N>
 size_t
 ArrayLength(T (&arr)[N])
 {
-    return N;
+  return N;
 }
 
 /*
  * Compute the address one past the last element of a constant-length array.
  *
  * Beware of the implicit trailing '\0' when using this with string constants.
  */
 template<typename T, size_t N>
 T*
 ArrayEnd(T (&arr)[N])
 {
-    return arr + ArrayLength(arr);
+  return arr + ArrayLength(arr);
 }
 
 } /* namespace mozilla */
 
 #endif /* __cplusplus */
 
 #endif  /* mozilla_Util_h_ */