--- a/mfbt/AllocPolicy.h
+++ b/mfbt/AllocPolicy.h
@@ -1,20 +1,21 @@
-/* -*- 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/. */
 
 /*
  * An allocation policy concept, usable for structures and algorithms to
  * control how memory is allocated and how failures are handled.
  */
 
-#ifndef mozilla_AllocPolicy_h_
-#define mozilla_AllocPolicy_h_
+#ifndef mozilla_AllocPolicy_h
+#define mozilla_AllocPolicy_h
 
 #include <stddef.h>
 #include <stdlib.h>
 
 namespace mozilla {
 
 /*
  * Allocation policies are used to implement the standard allocation behaviors
@@ -54,9 +55,9 @@ class MallocAllocPolicy
     void* realloc_(void* p, size_t oldBytes, size_t bytes) { return realloc(p, bytes); }
     void free_(void* p) { free(p); }
     void reportAllocOverflow() const {}
 };
 
 
 } // namespace mozilla
 
-#endif // mozilla_AllocPolicy_h_
+#endif /* mozilla_AllocPolicy_h */

--- a/mfbt/Array.h
+++ b/mfbt/Array.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* A compile-time constant-length array with bounds-checking assertions. */
 
-#ifndef mozilla_Array_h_
-#define mozilla_Array_h_
+#ifndef mozilla_Array_h
+#define mozilla_Array_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Attributes.h"
 
 #include <stddef.h>
 
 namespace mozilla {
 
@@ -42,9 +43,9 @@ class Array<T, 0>
 
     const T& operator[](size_t i) const {
       MOZ_ASSUME_UNREACHABLE("indexing into zero-length array");
     }
 };
 
 }  /* namespace mozilla */
 
-#endif /* mozilla_Array_h_ */
+#endif /* mozilla_Array_h */

--- a/mfbt/Assertions.h
+++ b/mfbt/Assertions.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* Implementations of runtime and static assertion macros for C and C++. */
 
-#ifndef mozilla_Assertions_h_
-#define mozilla_Assertions_h_
+#ifndef mozilla_Assertions_h
+#define mozilla_Assertions_h
 
 #include "mozilla/Attributes.h"
 #include "mozilla/Compiler.h"
 #include "mozilla/Likely.h"
 
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -450,9 +451,9 @@ MOZ_ReportCrash(const char* s, const cha
 #ifdef DEBUG
 #  define MOZ_ALWAYS_TRUE(expr)      MOZ_ASSERT((expr))
 #  define MOZ_ALWAYS_FALSE(expr)     MOZ_ASSERT(!(expr))
 #else
 #  define MOZ_ALWAYS_TRUE(expr)      ((void)(expr))
 #  define MOZ_ALWAYS_FALSE(expr)     ((void)(expr))
 #endif
 
-#endif /* mozilla_Assertions_h_ */
+#endif /* mozilla_Assertions_h */

--- a/mfbt/Atomics.h
+++ b/mfbt/Atomics.h
@@ -1,24 +1,25 @@
-/* -*- 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/. */
 
 /*
  * Implements (almost always) lock-free atomic operations. The operations here
  * are a subset of that which can be found in C++11's <atomic> header, with a
  * different API to enforce consistent memory ordering constraints.
  *
  * Anyone caught using |volatile| for inter-thread memory safety needs to be
  * sent a copy of this header and the C++11 standard.
  */
 
-#ifndef mozilla_Atomics_h_
-#define mozilla_Atomics_h_
+#ifndef mozilla_Atomics_h
+#define mozilla_Atomics_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/TypeTraits.h"
 
 #include <stdint.h>
 
 /*
  * Our minimum deployment target on clang/OS X is OS X 10.6, whose SDK
@@ -952,9 +953,9 @@ class Atomic<T*, Order> : public detail:
     }
 
   private:
     Atomic(Atomic<T*, Order>& aOther) MOZ_DELETE;
 };
 
 } // namespace mozilla
 
-#endif /* mozilla_Atomics_h_ */
+#endif /* mozilla_Atomics_h */

--- a/mfbt/Attributes.h
+++ b/mfbt/Attributes.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* Implementations of various class and method modifier attributes. */
 
-#ifndef mozilla_Attributes_h_
-#define mozilla_Attributes_h_
+#ifndef mozilla_Attributes_h
+#define mozilla_Attributes_h
 
 #include "mozilla/Compiler.h"
 
 /*
  * MOZ_INLINE is a macro which expands to tell the compiler that the method
  * decorated with it should be inlined.  This macro is usable from C and C++
  * code, even though C89 does not support the |inline| keyword.  The compiler
  * may ignore this directive if it chooses.
@@ -422,9 +423,9 @@
      this \
      __pragma(warning(pop))
 #else
 #  define MOZ_THIS_IN_INITIALIZER_LIST() this
 #endif
 
 #endif /* __cplusplus */
 
-#endif  /* mozilla_Attributes_h_ */
+#endif /* mozilla_Attributes_h */

--- a/mfbt/BloomFilter.h
+++ b/mfbt/BloomFilter.h
@@ -1,22 +1,23 @@
-/* -*- 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/. */
+ * 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
  * incorrectly answer "yes" when the correct answer is "no").
  */
 
-#ifndef mozilla_BloomFilter_h_
-#define mozilla_BloomFilter_h_
+#ifndef mozilla_BloomFilter_h
+#define mozilla_BloomFilter_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Likely.h"
 #include "mozilla/StandardInteger.h"
 #include "mozilla/Util.h"
 
 #include <string.h>
 
@@ -226,9 +227,9 @@ MOZ_ALWAYS_INLINE bool
 BloomFilter<KeySize, T>::mightContain(const T* t) const
 {
   uint32_t hash = t->hash();
   return mightContain(hash);
 }
 
 } // namespace mozilla
 
-#endif /* mozilla_BloomFilter_h_ */
+#endif /* mozilla_BloomFilter_h */

--- a/mfbt/Casting.h
+++ b/mfbt/Casting.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* Cast operations to supplement the built-in casting operations. */
 
-#ifndef mozilla_Casting_h_
-#define mozilla_Casting_h_
+#ifndef mozilla_Casting_h
+#define mozilla_Casting_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/TypeTraits.h"
 
 #include <limits.h>
 
 namespace mozilla {
 
@@ -193,9 +194,9 @@ inline To
 SafeCast(const From from)
 {
   MOZ_ASSERT((detail::IsInBounds<From, To>(from)));
   return static_cast<To>(from);
 }
 
 } // namespace mozilla
 
-#endif  /* mozilla_Casting_h_ */
+#endif /* mozilla_Casting_h */

--- a/mfbt/Char16.h
+++ b/mfbt/Char16.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* Implements a UTF-16 character type. */
 
-#ifndef mozilla_Char16_h_
-#define mozilla_Char16_h_
+#ifndef mozilla_Char16_h
+#define mozilla_Char16_h
 
 #include "mozilla/Assertions.h"
 
 /*
  * C11 and C++11 introduce a char16_t type and support for UTF-16 string and
  * character literals. C++11's char16_t is a distinct builtin type. C11's
  * char16_t is a typedef for uint_least16_t. Technically, char16_t is a 16-bit
  * code unit of a Unicode code point, not a "character".
@@ -48,9 +49,9 @@
  * CPP manual for a more accurate and precise explanation.
  */
 #define MOZ_UTF16(s) MOZ_UTF16_HELPER(s)
 
 MOZ_STATIC_ASSERT(sizeof(char16_t) == 2, "Is char16_t type 16 bits?");
 MOZ_STATIC_ASSERT(sizeof(MOZ_UTF16('A')) == 2, "Is char literal 16 bits?");
 MOZ_STATIC_ASSERT(sizeof(MOZ_UTF16("")[0]) == 2, "Is string char 16 bits?");
 
-#endif /* mozilla_Char16_h_ */
+#endif /* mozilla_Char16_h */

--- a/mfbt/CheckedInt.h
+++ b/mfbt/CheckedInt.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
+ * 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/. */
 
 /* Provides checked integers, detecting integer overflow and divide-by-0. */
 
-#ifndef mozilla_CheckedInt_h_
-#define mozilla_CheckedInt_h_
+#ifndef mozilla_CheckedInt_h
+#define mozilla_CheckedInt_h
 
 // Enable relying of Mozilla's MFBT for possibly-available C++11 features
 #define MOZ_CHECKEDINT_USE_MFBT
 
 #ifdef MOZ_CHECKEDINT_USE_MFBT
 #  include "mozilla/Assertions.h"
 #  include "mozilla/StandardInteger.h"
 #else
@@ -870,9 +871,9 @@ typedef CheckedInt<int16_t>  CheckedInt1
 typedef CheckedInt<uint16_t> CheckedUint16;
 typedef CheckedInt<int32_t>  CheckedInt32;
 typedef CheckedInt<uint32_t> CheckedUint32;
 typedef CheckedInt<int64_t>  CheckedInt64;
 typedef CheckedInt<uint64_t> CheckedUint64;
 
 } // namespace mozilla
 
-#endif /* mozilla_CheckedInt_h_ */
+#endif /* mozilla_CheckedInt_h */

--- a/mfbt/Compiler.h
+++ b/mfbt/Compiler.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* Various compiler checks. */
 
-#ifndef mozilla_Compiler_h_
-#define mozilla_Compiler_h_
+#ifndef mozilla_Compiler_h
+#define mozilla_Compiler_h
 
 #if !defined(__clang__) && defined(__GNUC__)
 
 #define MOZ_IS_GCC 1
    /*
     * This macro should simplify gcc version checking. For example, to check
     * for gcc 4.5.1 or later, check `#ifdef MOZ_GCC_VERSION_AT_LEAST(4, 5, 1)`.
     */
@@ -23,9 +24,9 @@
 #endif
 
 #else
 
 #define MOZ_IS_GCC 0
 
 #endif
 
-#endif  /* mozilla_Compiler_h_ */
+#endif /* mozilla_Compiler_h */

--- a/mfbt/Constants.h
+++ b/mfbt/Constants.h
@@ -1,15 +1,16 @@
-/* -*- 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/. */
 
 /* mfbt math constants. */
 
-#ifndef mozilla_Constants_h_
-#define mozilla_Constants_h_
+#ifndef mozilla_Constants_h
+#define mozilla_Constants_h
 
 #ifndef M_PI
 #  define M_PI 3.14159265358979323846
 #endif
 
-#endif  /* mozilla_Constants_h_ */
+#endif /* mozilla_Constants_h */

--- a/mfbt/DebugOnly.h
+++ b/mfbt/DebugOnly.h
@@ -1,20 +1,21 @@
-/* -*- 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/. */
 
 /*
  * Provides DebugOnly, a type for variables used only in debug builds (i.e. by
  * assertions).
  */
 
-#ifndef mozilla_DebugOnly_h_
-#define mozilla_DebugOnly_h_
+#ifndef mozilla_DebugOnly_h
+#define mozilla_DebugOnly_h
 
 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 with
  * MOZ_ASSERT()-style macros, allowing one to write:
  *
@@ -69,9 +70,9 @@ class DebugOnly
      * generate "unused variable" warnings, exactly what it's intended
      * to avoid!
      */
     ~DebugOnly() {}
 };
 
 }
 
-#endif  /* mozilla_DebugOnly_h_ */
+#endif /* mozilla_DebugOnly_h */

--- a/mfbt/Endian.h
+++ b/mfbt/Endian.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/. */
 
 /* Functions for reading and writing integers in various endiannesses. */
 
 /*
  * The classes LittleEndian and BigEndian expose static methods for
@@ -54,18 +55,18 @@
  *       length = BigEndian::readUint32(ptr); ptr += sizeof(uint32_t);
  *       totalRecords = BigEndian::readUint32(ptr); ptr += sizeof(uint32_t);
  *       checksum = BigEndian::readUint64(ptr);
  *     }
  *     ...
  * };
  */
 
-#ifndef mozilla_Endian_h_
-#define mozilla_Endian_h_
+#ifndef mozilla_Endian_h
+#define mozilla_Endian_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/Compiler.h"
 #include "mozilla/DebugOnly.h"
 #include "mozilla/StandardInteger.h"
 #include "mozilla/TypeTraits.h"
 
@@ -631,9 +632,9 @@ class NativeEndian MOZ_FINAL : public de
     using super::copyAndSwapFromNetworkOrder;
     using super::swapFromNetworkOrderInPlace;
 };
 
 #undef MOZ_NATIVE_ENDIANNESS
 
 } /* namespace mozilla */
 
-#endif /* mozilla_Endian_h_ */
+#endif /* mozilla_Endian_h */

--- a/mfbt/EnumSet.h
+++ b/mfbt/EnumSet.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/. */
 
 /* A set abstraction for enumeration values. */
 
 #ifndef mozilla_EnumSet_h
 #define mozilla_EnumSet_h
@@ -167,9 +168,9 @@ class EnumSet
       return 1U << bitNumber;
     }
 
     uint32_t mBitField;
 };
 
 } // namespace mozilla
 
-#endif // mozilla_EnumSet_h_
+#endif /* mozilla_EnumSet_h_*/

--- a/mfbt/FloatingPoint.h
+++ b/mfbt/FloatingPoint.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
+ * 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/. */
 
 /* Various predicates and operations on IEEE-754 floating point types. */
 
-#ifndef mozilla_FloatingPoint_h_
-#define mozilla_FloatingPoint_h_
+#ifndef mozilla_FloatingPoint_h
+#define mozilla_FloatingPoint_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/Casting.h"
 #include "mozilla/StandardInteger.h"
 
 namespace mozilla {
 
@@ -201,9 +202,9 @@ DoublesAreIdentical(double d1, double d2
 {
   if (IsNaN(d1))
     return IsNaN(d2);
   return BitwiseCast<uint64_t>(d1) == BitwiseCast<uint64_t>(d2);
 }
 
 } /* namespace mozilla */
 
-#endif  /* mozilla_FloatingPoint_h_ */
+#endif /* mozilla_FloatingPoint_h */

--- a/mfbt/GuardObjects.h
+++ b/mfbt/GuardObjects.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/. */
 
 /* Implementation of macros to ensure correct use of RAII Auto* objects. */
 
 #ifndef mozilla_GuardObjects_h
 #define mozilla_GuardObjects_h

--- a/mfbt/HashFunctions.h
+++ b/mfbt/HashFunctions.h
@@ -1,12 +1,13 @@
-/* -*- 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/. */
+ * 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. */
 
 /*
  * 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
@@ -37,18 +38,18 @@
  *        return AddToHash(hash, callbackFn);
  *      }
  *  };
  *
  * If you want to hash an nsAString or nsACString, use the HashString functions
  * in nsHashKeys.h.
  */
 
-#ifndef mozilla_HashFunctions_h_
-#define mozilla_HashFunctions_h_
+#ifndef mozilla_HashFunctions_h
+#define mozilla_HashFunctions_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/StandardInteger.h"
 #include "mozilla/Types.h"
 
 #ifdef __cplusplus
 namespace mozilla {
@@ -351,9 +352,10 @@ HashString(const wchar_t* str, size_t le
  * same result out of HashBytes as you would out of HashString.
  */
 MOZ_WARN_UNUSED_RESULT
 extern MFBT_API uint32_t
 HashBytes(const void* bytes, size_t length);
 
 } /* namespace mozilla */
 #endif /* __cplusplus */
-#endif /* mozilla_HashFunctions_h_ */
+
+#endif /* mozilla_HashFunctions_h */

--- a/mfbt/Likely.h
+++ b/mfbt/Likely.h
@@ -1,22 +1,23 @@
-/* -*- 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/. */
+ * 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 mozilla_Likely_h_
-#define mozilla_Likely_h_
+#ifndef mozilla_Likely_h
+#define mozilla_Likely_h
 
 #if defined(__clang__) || defined(__GNUC__)
 #  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 /* mozilla_Likely_h_ */
+#endif /* mozilla_Likely_h */

--- a/mfbt/LinkedList.h
+++ b/mfbt/LinkedList.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/. */
 
 /* A type-safe doubly-linked list class. */
 
 /*
  * The classes LinkedList<T> and LinkedListElement<T> together form a
@@ -47,18 +48,18 @@
  *       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_
+#ifndef mozilla_LinkedList_h
+#define mozilla_LinkedList_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Attributes.h"
 
 #ifdef __cplusplus
 
 namespace mozilla {
 
@@ -418,10 +419,11 @@ class LinkedList
     }
 
     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_ */
+#endif /* __cplusplus */
+
+#endif /* mozilla_LinkedList_h */

--- a/mfbt/MathAlgorithms.h
+++ b/mfbt/MathAlgorithms.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* mfbt maths algorithms. */
 
-#ifndef mozilla_MathAlgorithms_h_
-#define mozilla_MathAlgorithms_h_
+#ifndef mozilla_MathAlgorithms_h
+#define mozilla_MathAlgorithms_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/StandardInteger.h"
 #include "mozilla/TypeTraits.h"
 
 #include <cmath>
 #include <limits.h>
 
@@ -420,9 +421,9 @@ inline size_t
 RoundUpPow2(size_t x)
 {
   MOZ_ASSERT(~x > x, "can't round up -- will overflow!");
   return size_t(1) << CeilingLog2(x);
 }
 
 } /* namespace mozilla */
 
-#endif  /* mozilla_MathAlgorithms_h_ */
+#endif /* mozilla_MathAlgorithms_h */

--- a/mfbt/MemoryChecking.h
+++ b/mfbt/MemoryChecking.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/. */
 
 /*
  * Provides a common interface to the ASan (AddressSanitizer) and Valgrind 
  * functions used to mark memory in certain ways. In detail, the following
  * three macros are provided:
@@ -14,18 +15,18 @@
  *
  * With Valgrind in use, these directly map to the three respective Valgrind
  * macros. With ASan in use, the NOACCESS macro maps to poisoning the memory,
  * while the UNDEFINED/DEFINED macros unpoison memory.
  *
  * With no memory checker available, all macros expand to the empty statement.
  */
 
-#ifndef mozilla_MemoryChecking_h_
-#define mozilla_MemoryChecking_h_
+#ifndef mozilla_MemoryChecking_h
+#define mozilla_MemoryChecking_h
 
 #if defined(MOZ_VALGRIND)
 #include "valgrind/memcheck.h"
 #endif
 
 #if defined(MOZ_ASAN) || defined(MOZ_VALGRIND)
 #define MOZ_HAVE_MEM_CHECKS 1
 #endif
@@ -63,9 +64,9 @@ extern "C" {
 #else
 
 #define MOZ_MAKE_MEM_NOACCESS(addr, size) do {} while(0)
 #define MOZ_MAKE_MEM_UNDEFINED(addr, size) do {} while(0)
 #define MOZ_MAKE_MEM_DEFINED(addr, size) do {} while(0)
 
 #endif
 
-#endif  /* mozilla_MemoryChecking_h_ */
+#endif /* mozilla_MemoryChecking_h */

--- a/mfbt/MemoryReporting.h
+++ b/mfbt/MemoryReporting.h
@@ -1,18 +1,18 @@
 /* -*- 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/. */
 
 /* Memory reporting infrastructure. */
 
-#ifndef mozilla_MemoryReporting_h_
-#define mozilla_MemoryReporting_h_
+#ifndef mozilla_MemoryReporting_h
+#define mozilla_MemoryReporting_h
 
 #include <stddef.h>
 
 #ifdef __cplusplus
 
 namespace mozilla {
 
 /*
@@ -22,9 +22,9 @@ namespace mozilla {
 typedef size_t (*MallocSizeOf)(const void* p);
 
 } /* namespace mozilla */
 
 #endif /* __cplusplus */
 
 typedef size_t (*MozMallocSizeOf)(const void* p);
 
-#endif /* mozilla_MemoryReporting_h_ */
+#endif /* mozilla_MemoryReporting_h */

--- a/mfbt/Move.h
+++ b/mfbt/Move.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* C++11-style, but C++98-usable, "move references" implementation. */
 
-#ifndef mozilla_Move_h_
-#define mozilla_Move_h_
+#ifndef mozilla_Move_h
+#define mozilla_Move_h
 
 namespace mozilla {
 
 /*
  * "Move" References
  *
  * Some types can be copied much more efficiently if we know the original's
  * value need not be preserved --- that is, if we are doing a "move", not a
@@ -157,9 +158,9 @@ Swap(T& t, T& u)
 {
   T tmp(Move(t));
   t = Move(u);
   u = Move(tmp);
 }
 
 } // namespace mozilla
 
-#endif // mozilla_Move_h_
+#endif /* mozilla_Move_h */

--- a/mfbt/NullPtr.h
+++ b/mfbt/NullPtr.h
@@ -1,20 +1,21 @@
-/* -*- 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/. */
 
 /*
  * Implements a workaround for compilers which do not support the C++11 nullptr
  * constant.
  */
 
-#ifndef mozilla_NullPtr_h_
-#define mozilla_NullPtr_h_
+#ifndef mozilla_NullPtr_h
+#define mozilla_NullPtr_h
 
 #include "mozilla/Compiler.h"
 
 #if defined(__clang__)
 #  ifndef __has_extension
 #    define __has_extension __has_feature
 #  endif
 #  if __has_extension(cxx_nullptr)
@@ -40,9 +41,9 @@
 #    define nullptr __null
 #  elif defined(_WIN64)
 #    define nullptr 0LL
 #  else
 #    define nullptr 0L
 #  endif
 #endif
 
-#endif  /* mozilla_NullPtr_h_ */
+#endif /* mozilla_NullPtr_h */

--- a/mfbt/PodOperations.h
+++ b/mfbt/PodOperations.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/. */
 
 /*
  * Operations for zeroing POD types, arrays, and so on.
  *
  * These operations are preferable to memset, memcmp, and the like because they
@@ -151,9 +152,9 @@ PodEqual(const T* one, const T* two, siz
     return true;
   }
 
   return !memcmp(one, two, len * sizeof(T));
 }
 
 } // namespace mozilla
 
-#endif // mozilla_PodOperations_h_
+#endif /* mozilla_PodOperations_h */

--- a/mfbt/Poison.h
+++ b/mfbt/Poison.h
@@ -4,18 +4,18 @@
  * 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 poison value that can be used to fill a memory space with
  * an address that leads to a safe crash when dereferenced.
  */
 
-#ifndef mozilla_Poison_h_
-#define mozilla_Poison_h_
+#ifndef mozilla_Poison_h
+#define mozilla_Poison_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/StandardInteger.h"
 #include "mozilla/Types.h"
 
 MOZ_BEGIN_EXTERN_C
 
 extern MFBT_DATA uintptr_t gMozillaPoisonValue;
@@ -53,9 +53,9 @@ inline void mozWritePoison(void* aPtr, s
 extern MFBT_API void mozPoisonValueInit();
 
 /* Values annotated by CrashReporter */
 extern MFBT_DATA uintptr_t gMozillaPoisonBase;
 extern MFBT_DATA uintptr_t gMozillaPoisonSize;
 
 MOZ_END_EXTERN_C
 
-#endif /* mozilla_Poison_h_ */
+#endif /* mozilla_Poison_h */

--- a/mfbt/Range.h
+++ b/mfbt/Range.h
@@ -1,17 +1,16 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sw=4 et tw=78:
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- 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_Range_h_
-#define mozilla_Range_h_
+#ifndef mozilla_Range_h
+#define mozilla_Range_h
 
 #include "mozilla/NullPtr.h"
 #include "mozilla/RangedPtr.h"
 
 #include <stddef.h>
 
 namespace mozilla {
 
@@ -40,10 +39,9 @@ class Range
       return mStart[offset];
     }
 
     operator ConvertibleToBool() const { return mStart ? &Range::nonNull : 0; }
 };
 
 } // namespace mozilla
 
-#endif // mozilla_Range_h_
-
+#endif /* mozilla_Range_h */

--- a/mfbt/RangedPtr.h
+++ b/mfbt/RangedPtr.h
@@ -1,20 +1,21 @@
-/* -*- 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/. */
 
 /*
  * Implements a smart pointer asserted to remain within a range specified at
  * construction.
  */
 
-#ifndef mozilla_RangedPtr_h_
-#define mozilla_RangedPtr_h_
+#ifndef mozilla_RangedPtr_h
+#define mozilla_RangedPtr_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/Util.h"
 
 namespace mozilla {
 
 /*
@@ -246,9 +247,9 @@ class RangedPtr
 
   private:
     RangedPtr() MOZ_DELETE;
     T* operator&() MOZ_DELETE;
 };
 
 } /* namespace mozilla */
 
-#endif  /* mozilla_RangedPtr_h_ */
+#endif /* mozilla_RangedPtr_h */

--- a/mfbt/ReentrancyGuard.h
+++ b/mfbt/ReentrancyGuard.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* Small helper class for asserting uses of a class are non-reentrant. */
 
-#ifndef mozilla_ReentrancyGuard_h_
-#define mozilla_ReentrancyGuard_h_
+#ifndef mozilla_ReentrancyGuard_h
+#define mozilla_ReentrancyGuard_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/GuardObjects.h"
 
 namespace mozilla {
 
 /* Useful for implementing containers that assert non-reentrancy */
@@ -48,9 +49,9 @@ class ReentrancyGuard
 
   private:
     ReentrancyGuard(const ReentrancyGuard&) MOZ_DELETE;
     void operator=(const ReentrancyGuard&) MOZ_DELETE;
 };
 
 } // namespace mozilla
 
-#endif // mozilla_ReentrancyGuard_h_
+#endif /* mozilla_ReentrancyGuard_h */

--- a/mfbt/RefPtr.h
+++ b/mfbt/RefPtr.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* Helpers for defining and using refcounted objects. */
 
-#ifndef mozilla_RefPtr_h_
-#define mozilla_RefPtr_h_
+#ifndef mozilla_RefPtr_h
+#define mozilla_RefPtr_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Atomics.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/TypeTraits.h"
 
 namespace mozilla {
 
@@ -285,19 +286,16 @@ template<typename T>
 OutParamRef<T>
 byRef(RefPtr<T>& ptr)
 {
   return OutParamRef<T>(ptr);
 }
 
 } // namespace mozilla
 
-#endif // mozilla_RefPtr_h_
-
-
 #if 0
 
 // Command line that builds these tests
 //
 //   cp RefPtr.h test.cc && g++ -g -Wall -pedantic -DDEBUG -o test test.cc && ./test
 
 using namespace mozilla;
 
@@ -442,8 +440,10 @@ main(int argc, char** argv)
     MOZ_ASSERT(13 == Foo::numDestroyed);
   }
   MOZ_ASSERT(13 == Foo::numDestroyed);
 
   return 0;
 }
 
 #endif
+
+#endif /* mozilla_RefPtr_h */

--- a/mfbt/SHA1.h
+++ b/mfbt/SHA1.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* Simple class for computing SHA1. */
 
-#ifndef mozilla_SHA1_h_
-#define mozilla_SHA1_h_
+#ifndef mozilla_SHA1_h
+#define mozilla_SHA1_h
 
 #include "mozilla/StandardInteger.h"
 #include "mozilla/Types.h"
 
 #include <stddef.h>
 
 namespace mozilla {
 
@@ -53,9 +54,9 @@ class SHA1Sum
     MFBT_API void update(const void* dataIn, uint32_t len);
 
     /* Compute the final hash of all data into hashOut. */
     MFBT_API void finish(SHA1Sum::Hash& hashOut);
 };
 
 } /* namespace mozilla */
 
-#endif /* mozilla_SHA1_h_ */
+#endif /* mozilla_SHA1_h */

--- a/mfbt/Scoped.h
+++ b/mfbt/Scoped.h
@@ -1,16 +1,18 @@
+/* -*- 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/. */
+ * 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 number of structures to simplify scope-based RAII management. */
 
-#ifndef mozilla_Scoped_h_
-#define mozilla_Scoped_h_
+#ifndef mozilla_Scoped_h
+#define mozilla_Scoped_h
 
 /*
  * Resource Acquisition Is Initialization is a programming idiom used
  * to write robust code that is able to deallocate resources properly,
  * even in presence of execution errors or exceptions that need to be
  * propagated.  The Scoped* classes defined in this header perform the
  * deallocation of the resource they hold once program execution
  * reaches the end of the scope for which they have been defined.
@@ -263,9 +265,9 @@ struct TypeSpecificScopedPointerTraits
         TypeSpecificDelete(value);
     }
 };
 
 SCOPED_TEMPLATE(TypeSpecificScopedPointer, TypeSpecificScopedPointerTraits)
 
 } /* namespace mozilla */
 
-#endif // mozilla_Scoped_h_
+#endif /* mozilla_Scoped_h */

--- a/mfbt/SplayTree.h
+++ b/mfbt/SplayTree.h
@@ -1,22 +1,21 @@
-/* -*- 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: 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/. */
 
 /**
  * A sorted tree with optimal access times, where recently-accessed elements
  * are faster to access again.
  */
 
-#ifndef mozilla_SplayTree_h_
-#define mozilla_SplayTree_h_
+#ifndef mozilla_SplayTree_h
+#define mozilla_SplayTree_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/NullPtr.h"
 
 namespace mozilla {
 
 template<class T, class C>
 class SplayTree;
@@ -277,9 +276,9 @@ class SplayTree
     }
 
     SplayTree(const SplayTree&) MOZ_DELETE;
     void operator=(const SplayTree&) MOZ_DELETE;
 };
 
 }  /* namespace mozilla */
 
-#endif /* mozilla_SplayTree_h_ */
+#endif /* mozilla_SplayTree_h */

--- a/mfbt/StandardInteger.h
+++ b/mfbt/StandardInteger.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* Implements the C99 <stdint.h> interface for C and C++ code. */
 
-#ifndef mozilla_StandardInteger_h_
-#define mozilla_StandardInteger_h_
+#ifndef mozilla_StandardInteger_h
+#define mozilla_StandardInteger_h
 
 /*
  * The C99 standard header <stdint.h> exposes typedefs for common fixed-width
  * integer types.  It would be feasible to simply #include <stdint.h>, but
  * MSVC++ versions prior to 2010 don't provide <stdint.h>.  We could solve this
  * by reimplementing <stdint.h> for MSVC++ 2008 and earlier.  But then we reach
  * a second problem: our custom <stdint.h> might conflict with a <stdint.h>
  * defined by an embedder already looking to work around the MSVC++ <stdint.h>
@@ -35,9 +36,9 @@
 #if defined(MOZ_CUSTOM_STDINT_H)
 #  include MOZ_CUSTOM_STDINT_H
 #elif defined(_MSC_VER) && _MSC_VER < 1600
 #  include "mozilla/MSStdInt.h"
 #else
 #  include <stdint.h>
 #endif
 
-#endif  /* mozilla_StandardInteger_h_ */
+#endif /* mozilla_StandardInteger_h */

--- a/mfbt/TemplateLib.h
+++ b/mfbt/TemplateLib.h
@@ -1,11 +1,11 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- * vim: set ts=8 sts=4 et sw=4 tw=99:
- * This Source Code Form is subject to the terms of the Mozilla Public
+/* -*- 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/. */
 
 /*
  * Reusable template meta-functions on types and compile-time values.  Meta-
  * functions are placed inside the 'tl' namespace to avoid conflict with non-
  * meta functions of the same name (e.g., mozilla::tl::FloorLog2 vs.
  * mozilla::FloorLog2).
@@ -103,9 +103,9 @@ struct MulOverflowMask
 };
 template<> struct MulOverflowMask<0> { /* Error */ };
 template<> struct MulOverflowMask<1> { static const size_t value = 0; };
 
 } // namespace tl
 
 } // namespace mozilla
 
-#endif  /* mozilla_TemplateLib_h */
+#endif /* mozilla_TemplateLib_h */

--- a/mfbt/ThreadLocal.h
+++ b/mfbt/ThreadLocal.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
+ * 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. */
 
-#ifndef mozilla_ThreadLocal_h_
-#define mozilla_ThreadLocal_h_
+#ifndef mozilla_ThreadLocal_h
+#define mozilla_ThreadLocal_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.
 // # include <windef.h>
 // # include <winbase.h>
 // Unfortunately, even including these headers causes us to add a bunch of ugly
@@ -139,9 +140,9 @@ ThreadLocal<T>::set(const T value)
   succeeded = !pthread_setspecific(key, h.ptr);
 #endif
   if (!succeeded)
     MOZ_CRASH();
 }
 
 } // namespace mozilla
 
-#endif // mozilla_ThreadLocal_h_
+#endif /* mozilla_ThreadLocal_h */

--- a/mfbt/TypeTraits.h
+++ b/mfbt/TypeTraits.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* Template-based metaprogramming and type-testing facilities. */
 
-#ifndef mozilla_TypeTraits_h_
-#define mozilla_TypeTraits_h_
+#ifndef mozilla_TypeTraits_h
+#define mozilla_TypeTraits_h
 
 /*
  * These traits are approximate copies of the traits and semantics from C++11's
  * <type_traits> header.  Don't add traits not in that header!  When all
  * platforms provide that header, we can convert all users and remove this one.
  */
 
 #include <wchar.h>
@@ -660,9 +661,9 @@ struct Conditional
 template<class A, class B>
 struct Conditional<false, A, B>
 {
     typedef B Type;
 };
 
 } /* namespace mozilla */
 
-#endif  /* mozilla_TypeTraits_h_ */
+#endif /* mozilla_TypeTraits_h */

--- a/mfbt/TypedEnum.h
+++ b/mfbt/TypedEnum.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* Macros to emulate C++11 typed enums and enum classes. */
 
-#ifndef mozilla_TypedEnum_h_
-#define mozilla_TypedEnum_h_
+#ifndef mozilla_TypedEnum_h
+#define mozilla_TypedEnum_h
 
 #include "mozilla/Attributes.h"
 
 #if defined(__cplusplus)
 
 #if defined(__clang__)
    /*
     * Per Clang documentation, "Note that marketing version numbers should not
@@ -205,9 +206,9 @@
      inline int& operator|=(int&, const Name::Enum&) MOZ_DELETE; \
      inline int& operator^=(int&, const Name::Enum&) MOZ_DELETE; \
      inline int& operator<<=(int&, const Name::Enum&) MOZ_DELETE; \
      inline int& operator>>=(int&, const Name::Enum&) MOZ_DELETE;
 #endif
 
 #endif /* __cplusplus */
 
-#endif  /* mozilla_TypedEnum_h_ */
+#endif /* mozilla_TypedEnum_h */

--- a/mfbt/Types.h
+++ b/mfbt/Types.h
@@ -1,17 +1,18 @@
-/* -*- 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/. */
 
 /* mfbt foundational types and macros. */
 
-#ifndef mozilla_Types_h_
-#define mozilla_Types_h_
+#ifndef mozilla_Types_h
+#define mozilla_Types_h
 
 /*
  * This header must be valid C and C++, includable by code embedding either
  * SpiderMonkey or Gecko.
  */
 
 /*
  * Expose all the integer types defined in C99's <stdint.h> (and the integer
@@ -136,9 +137,9 @@
 /*
  * GCC's typeof is available when decltype is not.
  */
 #if defined(__GNUC__) && defined(__cplusplus) && \
   !defined(__GXX_EXPERIMENTAL_CXX0X__) && __cplusplus < 201103L
 #  define decltype __typeof__
 #endif
 
-#endif  /* mozilla_Types_h_ */
+#endif /* mozilla_Types_h */

--- a/mfbt/Util.h
+++ b/mfbt/Util.h
@@ -1,20 +1,21 @@
-/* -*- 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/. */
 
 /*
  * Miscellaneous uncategorized functionality.  Please add new functionality to
  * new headers, or to other appropriate existing headers, not here.
  */
 
-#ifndef mozilla_Util_h_
-#define mozilla_Util_h_
+#ifndef mozilla_Util_h
+#define mozilla_Util_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/Types.h"
 
 #ifdef __cplusplus
 
 namespace mozilla {
@@ -327,9 +328,9 @@ ArrayEnd(T (&arr)[N])
  * can't call ArrayLength() when it is not a C++11 constexpr function.
  */
 #ifdef MOZ_HAVE_CXX11_CONSTEXPR
 #  define MOZ_ARRAY_LENGTH(array)   mozilla::ArrayLength(array)
 #else
 #  define MOZ_ARRAY_LENGTH(array)   (sizeof(array)/sizeof((array)[0]))
 #endif
 
-#endif  /* mozilla_Util_h_ */
+#endif /* mozilla_Util_h */

--- a/mfbt/Vector.h
+++ b/mfbt/Vector.h
@@ -1,11 +1,11 @@
-/* -*- Mode: C++; tab-width: 2; 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
+/* -*- 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/. */
 
 /* A type/length-parametrized vector class. */
 
 #ifndef mozilla_Vector_h
 #define mozilla_Vector_h
 

--- a/mfbt/WeakPtr.h
+++ b/mfbt/WeakPtr.h
@@ -1,12 +1,13 @@
-/* -*- 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/. */
+ * 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/. */
 
 /* Weak pointer functionality, implemented as a mixin for use with any class. */
 
 /**
  * SupportsWeakPtr lets you have a pointer to an object 'Foo' without affecting
  * its lifetime. It works by creating a single shared reference counted object
  * (WeakReference) that each WeakPtr will access 'Foo' through. This lets 'Foo'
  * clear the pointer in the WeakReference without having to know about all of
@@ -53,18 +54,18 @@
  *
  * WeakPtr is typesafe and may be used with any class. It is not required that
  * the class be reference-counted or allocated in any particular way.
  *
  * The API was loosely inspired by Chromium's weak_ptr.h:
  * http://src.chromium.org/svn/trunk/src/base/memory/weak_ptr.h
  */
 
-#ifndef mozilla_WeakPtr_h_
-#define mozilla_WeakPtr_h_
+#ifndef mozilla_WeakPtr_h
+#define mozilla_WeakPtr_h
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Atomics.h"
 #include "mozilla/NullPtr.h"
 #include "mozilla/RefPtr.h"
 #include "mozilla/TypeTraits.h"
 
 namespace mozilla {
@@ -182,9 +183,9 @@ class WeakPtr : public WeakPtrBase<T, de
   public:
     WeakPtr(const WeakPtr<T>& o) : Base(o) {}
     WeakPtr(const Base& o) : Base(o) {}
     WeakPtr() {}
 };
 
 } // namespace mozilla
 
-#endif /* ifdef mozilla_WeakPtr_h_ */
+#endif /* mozilla_WeakPtr_h */