--- a/toolkit/components/commandlines/nsCommandLine.cpp
+++ b/toolkit/components/commandlines/nsCommandLine.cpp
@@ -617,17 +617,17 @@ EnumHelp(nsICommandLineHandler* aHandler
   nsresult rv;
 
   nsCString text;
   rv = aHandler->GetHelpInfo(text);
   if (NS_SUCCEEDED(rv)) {
     NS_ASSERTION(text.Length() == 0 || text.Last() == '\n',
                  "Help text from command line handlers should end in a newline.");
 
-    nsACString* totalText = reinterpret_cast<nsACString*>(aClosure);
+    auto* totalText = reinterpret_cast<nsACString*>(aClosure);
     totalText->Append(text);
   }
 
   return NS_OK;
 }  
 
 NS_IMETHODIMP
 nsCommandLine::GetHelpText(nsACString& aResult)

--- a/toolkit/components/ctypes/ctypes.cpp
+++ b/toolkit/components/ctypes/ctypes.cpp
@@ -29,17 +29,17 @@ UnicodeToNative(JSContext *cx, const cha
   nsAutoCString native;
   nsDependentString unicode(reinterpret_cast<const char16_t*>(source), slen);
   nsresult rv = NS_CopyUnicodeToNative(unicode, native);
   if (NS_FAILED(rv)) {
     JS_ReportErrorASCII(cx, "could not convert string to native charset");
     return nullptr;
   }
 
-  char* result = static_cast<char*>(JS_malloc(cx, native.Length() + 1));
+  auto* result = static_cast<char*>(JS_malloc(cx, native.Length() + 1));
   if (!result)
     return nullptr;
 
   memcpy(result, native.get(), native.Length() + 1);
   return result;
 }
 
 static JSCTypesCallbacks sCallbacks = {

--- a/toolkit/components/downloads/SQLFunctions.cpp
+++ b/toolkit/components/downloads/SQLFunctions.cpp
@@ -108,17 +108,17 @@ GenerateRandomBytes(uint32_t aSize,
 
 nsresult
 GenerateGUID(nsCString& _guid)
 {
   _guid.Truncate();
 
   // Request raw random bytes and base64url encode them.  For each set of three
   // bytes, we get one character.
-  const uint32_t kRequiredBytesLength =
+  const auto kRequiredBytesLength =
     static_cast<uint32_t>(GUID_LENGTH / 4 * 3);
 
   uint8_t buffer[kRequiredBytesLength];
   nsresult rv = GenerateRandomBytes(kRequiredBytesLength, buffer);
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = Base64urlEncode(buffer, kRequiredBytesLength, _guid);
   NS_ENSURE_SUCCESS(rv, rv);

--- a/toolkit/components/filepicker/nsFileView.cpp
+++ b/toolkit/components/filepicker/nsFileView.cpp
@@ -949,17 +949,17 @@ nsFileView::SortArray(nsTArray<nsCOMPtr<
     compareFunc = SortDateCallback;
     break;
   default:
     return;
   }
 
   uint32_t count = aArray.Length();
 
-  nsIFile** array = new nsIFile*[count];
+  auto** array = new nsIFile*[count];
   for (uint32_t i = 0; i < count; ++i) {
     array[i] = aArray[i];
   }
 
   NS_QuickSort(array, count, sizeof(nsIFile*), compareFunc, nullptr);
 
   for (uint32_t i = 0; i < count; ++i) {
     // Use swap() to avoid refcounting.

--- a/toolkit/components/osfile/NativeOSFileInternals.cpp
+++ b/toolkit/components/osfile/NativeOSFileInternals.cpp
@@ -679,17 +679,17 @@ public:
 
     if (!aBuffer.Allocate(bytes)) {
       Fail(NS_LITERAL_CSTRING("allocate"), nullptr, OS_ERROR_NOMEM);
       return NS_ERROR_FAILURE;
     }
 
     uint64_t total_read = 0;
     int32_t just_read = 0;
-    char* dest_chars = reinterpret_cast<char*>(aBuffer.rwget().data);
+    auto* dest_chars = reinterpret_cast<char*>(aBuffer.rwget().data);
     do {
       just_read = PR_Read(file, dest_chars + total_read,
                           std::min(uint64_t(PR_INT32_MAX), bytes - total_read));
       if (just_read == -1) {
         Fail(NS_LITERAL_CSTRING("read"), nullptr, PR_GetOSError());
         return NS_ERROR_FAILURE;
       }
       total_read += just_read;
@@ -806,17 +806,17 @@ protected:
     return NS_OK;
   }
 
   void AfterRead(TimeStamp aDispatchDate,
                  ScopedArrayBufferContents& aBuffer) override {
     MOZ_ASSERT(!NS_IsMainThread());
 
     int32_t maxChars;
-    const char* sourceChars = reinterpret_cast<const char*>(aBuffer.get().data);
+    const auto* sourceChars = reinterpret_cast<const char*>(aBuffer.get().data);
     int32_t sourceBytes = aBuffer.get().nbytes;
     if (sourceBytes < 0) {
       Fail(NS_LITERAL_CSTRING("arithmetics"), mResult.forget(), OS_ERROR_TOO_LARGE);
       return;
     }
 
     nsresult rv = mDecoder->GetMaxLength(sourceChars, sourceBytes, &maxChars);
     if (NS_FAILED(rv)) {

--- a/toolkit/components/remote/nsGTKRemoteService.cpp
+++ b/toolkit/components/remote/nsGTKRemoteService.cpp
@@ -63,17 +63,17 @@ static nsIWidget* GetMainWidget(nsPIDOMW
 }
 
 NS_IMETHODIMP
 nsGTKRemoteService::RegisterWindow(mozIDOMWindow* aWindow)
 {
   nsIWidget* mainWidget = GetMainWidget(nsPIDOMWindowInner::From(aWindow));
   NS_ENSURE_TRUE(mainWidget, NS_ERROR_FAILURE);
 
-  GtkWidget* widget =
+  auto* widget =
     (GtkWidget*) mainWidget->GetNativeData(NS_NATIVE_SHELLWIDGET);
   NS_ENSURE_TRUE(widget, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsIWeakReference> weak = do_GetWeakReference(aWindow);
   NS_ENSURE_TRUE(weak, NS_ERROR_FAILURE);
 
   mWindows.Put(widget, weak);
 

--- a/toolkit/components/remote/nsXRemoteService.cpp
+++ b/toolkit/components/remote/nsXRemoteService.cpp
@@ -259,17 +259,17 @@ nsXRemoteService::HandleCommandLine(char
   nsCOMPtr<nsIFile> lf;
   rv = NS_NewNativeLocalFile(nsDependentCString(wd), true,
                              getter_AddRefs(lf));
   if (NS_FAILED(rv))
     return "509 internal error";
 
   nsAutoCString desktopStartupID;
 
-  char **argv = (char**) malloc(sizeof(char*) * argc);
+  auto **argv = (char**) malloc(sizeof(char*) * argc);
   if (!argv) return "509 internal error";
 
   int32_t  *offset = reinterpret_cast<int32_t*>(aBuffer) + 1;
 
   for (int i = 0; i < argc; ++i) {
     argv[i] = aBuffer + TO_LITTLE_ENDIAN32(offset[i]);
 
     if (i == 0) {

--- a/toolkit/components/statusfilter/nsBrowserStatusFilter.cpp
+++ b/toolkit/components/statusfilter/nsBrowserStatusFilter.cpp
@@ -377,16 +377,16 @@ nsBrowserStatusFilter::ProcessTimeout()
         mDelayedProgress = false;
         MaybeSendProgress();
     }
 }
 
 void
 nsBrowserStatusFilter::TimeoutHandler(nsITimer *aTimer, void *aClosure)
 {
-    nsBrowserStatusFilter *self = reinterpret_cast<nsBrowserStatusFilter *>(aClosure);
+    auto *self = reinterpret_cast<nsBrowserStatusFilter *>(aClosure);
     if (!self) {
         NS_ERROR("no self");
         return;
     }
 
     self->ProcessTimeout();
 }

--- a/toolkit/components/telemetry/Telemetry.cpp
+++ b/toolkit/components/telemetry/Telemetry.cpp
@@ -137,17 +137,17 @@ CombinedStacks::AddStack(const Telemetry
   for (size_t i = 0; i < stackSize; ++i) {
     const Telemetry::ProcessedStack::Frame& frame = aStack.GetFrame(i);
     uint16_t modIndex;
     if (frame.mModIndex == std::numeric_limits<uint16_t>::max()) {
       modIndex = frame.mModIndex;
     } else {
       const Telemetry::ProcessedStack::Module& module =
         aStack.GetModule(frame.mModIndex);
-      std::vector<Telemetry::ProcessedStack::Module>::iterator modIterator =
+      auto modIterator =
         std::find(mModules.begin(), mModules.end(), module);
       if (modIterator == mModules.end()) {
         mModules.push_back(module);
         modIndex = mModules.size() - 1;
       } else {
         modIndex = modIterator - mModules.begin();
       }
     }

--- a/toolkit/components/telemetry/TelemetryHistogram.cpp
+++ b/toolkit/components/telemetry/TelemetryHistogram.cpp
@@ -290,17 +290,17 @@ internal_GetRegisteredHistogramIds(bool 
     }
 
     const char* id = h.id();
     const size_t len = strlen(id);
     collection.AppendElement(static_cast<char*>(nsMemory::Clone(id, len+1)));
   }
 
   const size_t bytes = collection.Length() * sizeof(char*);
-  char** histograms = static_cast<char**>(moz_xmalloc(bytes));
+  auto** histograms = static_cast<char**>(moz_xmalloc(bytes));
   memcpy(histograms, collection.Elements(), bytes);
   *aHistograms = histograms;
   *aCount = collection.Length();
 
   return NS_OK;
 }
 
 const char *
@@ -1547,17 +1547,17 @@ bool
 internal_JSHistogram_Add(JSContext *cx, unsigned argc, JS::Value *vp)
 {
   JSObject *obj = JS_THIS_OBJECT(cx, vp);
   MOZ_ASSERT(obj);
   if (!obj) {
     return false;
   }
 
-  Histogram *h = static_cast<Histogram*>(JS_GetPrivate(obj));
+  auto *h = static_cast<Histogram*>(JS_GetPrivate(obj));
   MOZ_ASSERT(h);
   Histogram::ClassType type = h->histogram_type();
 
   JS::CallArgs args = CallArgsFromVp(argc, vp);
 
   if (!internal_CanRecordBase()) {
     return true;
   }
@@ -1613,17 +1613,17 @@ bool
 internal_JSHistogram_Snapshot(JSContext *cx, unsigned argc, JS::Value *vp)
 {
   JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
   JSObject *obj = JS_THIS_OBJECT(cx, vp);
   if (!obj) {
     return false;
   }
 
-  Histogram *h = static_cast<Histogram*>(JS_GetPrivate(obj));
+  auto *h = static_cast<Histogram*>(JS_GetPrivate(obj));
   JS::Rooted<JSObject*> snapshot(cx, JS_NewPlainObject(cx));
   if (!snapshot)
     return false;
 
   switch (internal_ReflectHistogramSnapshot(cx, snapshot, h)) {
   case REFLECT_FAILURE:
     return false;
   case REFLECT_CORRUPT:
@@ -1654,17 +1654,17 @@ internal_JSHistogram_Clear(JSContext *cx
       JS_ReportErrorASCII(cx, "Not a boolean");
       return false;
     }
 
     onlySubsession = JS::ToBoolean(args[0]);
   }
 #endif
 
-  Histogram *h = static_cast<Histogram*>(JS_GetPrivate(obj));
+  auto *h = static_cast<Histogram*>(JS_GetPrivate(obj));
   MOZ_ASSERT(h);
   if (h) {
     internal_HistogramClear(*h, onlySubsession);
   }
 
   return true;
 }
 
@@ -1672,17 +1672,17 @@ bool
 internal_JSHistogram_Dataset(JSContext *cx, unsigned argc, JS::Value *vp)
 {
   JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
   JSObject *obj = JS_THIS_OBJECT(cx, vp);
   if (!obj) {
     return false;
   }
 
-  Histogram *h = static_cast<Histogram*>(JS_GetPrivate(obj));
+  auto *h = static_cast<Histogram*>(JS_GetPrivate(obj));
   mozilla::Telemetry::ID id;
   nsresult rv = internal_GetHistogramEnumId(h->histogram_name().c_str(), &id);
   if (NS_SUCCEEDED(rv)) {
     args.rval().setNumber(gHistograms[id].dataset);
     return true;
   }
 
   return false;
@@ -1747,17 +1747,17 @@ internal_KeyedHistogram_SnapshotImpl(JSC
                                      JS::Value *vp,
                                      bool subsession, bool clearSubsession)
 {
   JSObject *obj = JS_THIS_OBJECT(cx, vp);
   if (!obj) {
     return false;
   }
 
-  KeyedHistogram* keyed = static_cast<KeyedHistogram*>(JS_GetPrivate(obj));
+  auto* keyed = static_cast<KeyedHistogram*>(JS_GetPrivate(obj));
   if (!keyed) {
     return false;
   }
 
   JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 
   if (args.length() == 0) {
     JS::RootedObject snapshot(cx, JS_NewPlainObject(cx));
@@ -1810,17 +1810,17 @@ internal_KeyedHistogram_SnapshotImpl(JSC
 bool
 internal_JSKeyedHistogram_Add(JSContext *cx, unsigned argc, JS::Value *vp)
 {
   JSObject *obj = JS_THIS_OBJECT(cx, vp);
   if (!obj) {
     return false;
   }
 
-  KeyedHistogram* keyed = static_cast<KeyedHistogram*>(JS_GetPrivate(obj));
+  auto* keyed = static_cast<KeyedHistogram*>(JS_GetPrivate(obj));
   if (!keyed) {
     return false;
   }
 
   JS::CallArgs args = CallArgsFromVp(argc, vp);
   if (args.length() < 1) {
     JS_ReportErrorASCII(cx, "Expected one argument");
     return false;
@@ -1863,17 +1863,17 @@ internal_JSKeyedHistogram_Add(JSContext 
 bool
 internal_JSKeyedHistogram_Keys(JSContext *cx, unsigned argc, JS::Value *vp)
 {
   JSObject *obj = JS_THIS_OBJECT(cx, vp);
   if (!obj) {
     return false;
   }
 
-  KeyedHistogram* keyed = static_cast<KeyedHistogram*>(JS_GetPrivate(obj));
+  auto* keyed = static_cast<KeyedHistogram*>(JS_GetPrivate(obj));
   if (!keyed) {
     return false;
   }
 
   JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
   return NS_SUCCEEDED(keyed->GetJSKeys(cx, args));
 }
 
@@ -1910,17 +1910,17 @@ internal_JSKeyedHistogram_SnapshotSubses
 bool
 internal_JSKeyedHistogram_Clear(JSContext *cx, unsigned argc, JS::Value *vp)
 {
   JSObject *obj = JS_THIS_OBJECT(cx, vp);
   if (!obj) {
     return false;
   }
 
-  KeyedHistogram* keyed = static_cast<KeyedHistogram*>(JS_GetPrivate(obj));
+  auto* keyed = static_cast<KeyedHistogram*>(JS_GetPrivate(obj));
   if (!keyed) {
     return false;
   }
 
 #if !defined(MOZ_WIDGET_GONK) && !defined(MOZ_WIDGET_ANDROID)
   bool onlySubsession = false;
   JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 
@@ -1944,17 +1944,17 @@ bool
 internal_JSKeyedHistogram_Dataset(JSContext *cx, unsigned argc, JS::Value *vp)
 {
   JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
   JSObject *obj = JS_THIS_OBJECT(cx, vp);
   if (!obj) {
     return false;
   }
 
-  KeyedHistogram* keyed = static_cast<KeyedHistogram*>(JS_GetPrivate(obj));
+  auto* keyed = static_cast<KeyedHistogram*>(JS_GetPrivate(obj));
   if (!keyed) {
     return false;
   }
 
   uint32_t dataset = nsITelemetry::DATASET_RELEASE_CHANNEL_OPTIN;
   nsresult rv = keyed->GetDataset(&dataset);;
   if (NS_FAILED(rv)) {
     return false;
@@ -2369,17 +2369,17 @@ TelemetryHistogram::CreateHistogramSnaps
     if (gHistograms[i].keyed) {
       continue;
     }
     const uint32_t type = gHistograms[i].histogramType;
     if (type == nsITelemetry::HISTOGRAM_FLAG ||
         type == nsITelemetry::HISTOGRAM_COUNT) {
       Histogram *h;
       mozilla::DebugOnly<nsresult> rv;
-      mozilla::Telemetry::ID id = mozilla::Telemetry::ID(i);
+      auto id = mozilla::Telemetry::ID(i);
 
       rv = internal_GetHistogramByEnumId(id, &h, GeckoProcessType_Default);
       MOZ_ASSERT(NS_SUCCEEDED(rv));
 
       rv = internal_GetHistogramByEnumId(id, &h, GeckoProcessType_Content);
       MOZ_ASSERT(NS_SUCCEEDED(rv));
 
       if (includeGPUProcess) {

--- a/toolkit/components/telemetry/TelemetryScalar.cpp
+++ b/toolkit/components/telemetry/TelemetryScalar.cpp
@@ -639,17 +639,17 @@ KeyedScalar::SetMaximum(const nsAString&
  * @return {nsresult} NS_OK or an error value as reported by the
  *         the specific scalar objects implementations (e.g.
  *         ScalarUnsigned).
  */
 nsresult
 KeyedScalar::GetValue(nsTArray<KeyValuePair>& aValues) const
 {
   for (auto iter = mScalarKeys.ConstIter(); !iter.Done(); iter.Next()) {
-    ScalarBase* scalar = static_cast<ScalarBase*>(iter.Data());
+    auto* scalar = static_cast<ScalarBase*>(iter.Data());
 
     // Get the scalar value.
     nsCOMPtr<nsIVariant> scalarValue;
     nsresult rv = scalar->GetValue(scalarValue);
     if (NS_FAILED(rv)) {
       return rv;
     }
 
@@ -695,17 +695,17 @@ KeyedScalar::GetScalarForKey(const nsASt
   return ScalarResult::Ok;
 }
 
 size_t
 KeyedScalar::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
 {
   size_t n = aMallocSizeOf(this);
   for (auto iter = mScalarKeys.Iter(); !iter.Done(); iter.Next()) {
-    ScalarBase* scalar = static_cast<ScalarBase*>(iter.Data());
+    auto* scalar = static_cast<ScalarBase*>(iter.Data());
     n += scalar->SizeOfIncludingThis(aMallocSizeOf);
   }
   return n;
 }
 
 typedef nsUint32HashKey ScalarIDHashKey;
 typedef nsClassHashtable<ScalarIDHashKey, ScalarBase> ScalarStorageMapType;
 typedef nsClassHashtable<ScalarIDHashKey, KeyedScalar> KeyedScalarStorageMapType;
@@ -945,17 +945,17 @@ internal_GetEnumByScalarName(const nsACS
 nsresult
 internal_GetScalarByEnum(mozilla::Telemetry::ScalarID aId, ScalarBase** aRet)
 {
   if (!IsValidEnumId(aId)) {
     MOZ_ASSERT(false, "Requested a scalar with an invalid id.");
     return NS_ERROR_INVALID_ARG;
   }
 
-  const uint32_t id = static_cast<uint32_t>(aId);
+  const auto id = static_cast<uint32_t>(aId);
 
   ScalarBase* scalar = nullptr;
   if (gScalarStorageMap.Get(id, &scalar)) {
     *aRet = scalar;
     return NS_OK;
   }
 
   const ScalarInfo &info = gScalars[id];
@@ -1031,17 +1031,17 @@ namespace {
 nsresult
 internal_GetKeyedScalarByEnum(mozilla::Telemetry::ScalarID aId, KeyedScalar** aRet)
 {
   if (!IsValidEnumId(aId)) {
     MOZ_ASSERT(false, "Requested a keyed scalar with an invalid id.");
     return NS_ERROR_INVALID_ARG;
   }
 
-  const uint32_t id = static_cast<uint32_t>(aId);
+  const auto id = static_cast<uint32_t>(aId);
 
   KeyedScalar* scalar = nullptr;
   if (gKeyedScalarStorageMap.Get(id, &scalar)) {
     *aRet = scalar;
     return NS_OK;
   }
 
   const ScalarInfo &info = gScalars[id];
@@ -1122,17 +1122,17 @@ TelemetryScalar::InitializeGlobalState(b
   MOZ_ASSERT(!gInitDone, "TelemetryScalar::InitializeGlobalState "
              "may only be called once");
 
   gCanRecordBase = aCanRecordBase;
   gCanRecordExtended = aCanRecordExtended;
 
   // Populate the static scalar name->id cache. Note that the scalar names are
   // statically allocated and come from the automatically generated TelemetryScalarData.h.
-  uint32_t scalarCount = static_cast<uint32_t>(mozilla::Telemetry::ScalarID::ScalarCount);
+  auto scalarCount = static_cast<uint32_t>(mozilla::Telemetry::ScalarID::ScalarCount);
   for (uint32_t i = 0; i < scalarCount; i++) {
     CharPtrEntryType *entry = gScalarNameIDMap.PutEntry(gScalars[i].name());
     entry->mData = static_cast<mozilla::Telemetry::ScalarID>(i);
   }
 
 #ifdef DEBUG
   gScalarNameIDMap.MarkImmutable();
 #endif
@@ -1746,17 +1746,17 @@ TelemetryScalar::CreateSnapshots(unsigne
   // Only lock the mutex while accessing our data, without locking any JS related code.
   typedef mozilla::Pair<const char*, nsCOMPtr<nsIVariant>> DataPair;
   nsTArray<DataPair> scalarsToReflect;
   {
     StaticMutexAutoLock locker(gTelemetryScalarsMutex);
     // Iterate the scalars in gScalarStorageMap. The storage may contain empty or yet to be
     // initialized scalars.
     for (auto iter = gScalarStorageMap.Iter(); !iter.Done(); iter.Next()) {
-      ScalarBase* scalar = static_cast<ScalarBase*>(iter.Data());
+      auto* scalar = static_cast<ScalarBase*>(iter.Data());
 
       // Get the informations for this scalar.
       const ScalarInfo& info = gScalars[iter.Key()];
 
       // Serialize the scalar if it's in the desired dataset.
       if (IsInDataset(info.dataset, aDataset)) {
         // Get the scalar value.
         nsCOMPtr<nsIVariant> scalarValue;
@@ -1822,17 +1822,17 @@ TelemetryScalar::CreateKeyedSnapshots(un
   // Only lock the mutex while accessing our data, without locking any JS related code.
   typedef mozilla::Pair<const char*, nsTArray<KeyedScalar::KeyValuePair>> DataPair;
   nsTArray<DataPair> scalarsToReflect;
   {
     StaticMutexAutoLock locker(gTelemetryScalarsMutex);
     // Iterate the scalars in gKeyedScalarStorageMap. The storage may contain empty or yet
     // to be initialized scalars.
     for (auto iter = gKeyedScalarStorageMap.Iter(); !iter.Done(); iter.Next()) {
-      KeyedScalar* scalar = static_cast<KeyedScalar*>(iter.Data());
+      auto* scalar = static_cast<KeyedScalar*>(iter.Data());
 
       // Get the informations for this scalar.
       const ScalarInfo& info = gScalars[iter.Key()];
 
       // Serialize the scalar if it's in the desired dataset.
       if (IsInDataset(info.dataset, aDataset)) {
         // Get the keys for this scalar.
         nsTArray<KeyedScalar::KeyValuePair> scalarKeyedData;
@@ -1909,18 +1909,18 @@ TelemetryScalar::GetMapShallowSizesOfExc
 
 size_t
 TelemetryScalar::GetScalarSizesOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
 {
   StaticMutexAutoLock locker(gTelemetryScalarsMutex);
   size_t n = 0;
   // For the plain scalars...
   for (auto iter = gScalarStorageMap.Iter(); !iter.Done(); iter.Next()) {
-    ScalarBase* scalar = static_cast<ScalarBase*>(iter.Data());
+    auto* scalar = static_cast<ScalarBase*>(iter.Data());
     n += scalar->SizeOfIncludingThis(aMallocSizeOf);
   }
   // ...and for the keyed scalars.
   for (auto iter = gKeyedScalarStorageMap.Iter(); !iter.Done(); iter.Next()) {
-    KeyedScalar* scalar = static_cast<KeyedScalar*>(iter.Data());
+    auto* scalar = static_cast<KeyedScalar*>(iter.Data());
     n += scalar->SizeOfIncludingThis(aMallocSizeOf);
   }
   return n;
 }

--- a/toolkit/components/url-classifier/HashStore.cpp
+++ b/toolkit/components/url-classifier/HashStore.cpp
@@ -165,35 +165,35 @@ TableUpdateV2::NewSubComplete(uint32_t a
 void
 TableUpdateV4::NewPrefixes(int32_t aSize, std::string& aPrefixes)
 {
   NS_ENSURE_TRUE_VOID(aPrefixes.size() % aSize == 0);
   NS_ENSURE_TRUE_VOID(!mPrefixesMap.Get(aSize));
 
   if (LOG_ENABLED() && 4 == aSize) {
     int numOfPrefixes = aPrefixes.size() / 4;
-    uint32_t* p = (uint32_t*)aPrefixes.c_str();
+    auto* p = (uint32_t*)aPrefixes.c_str();
 
     // Dump the first/last 10 fixed-length prefixes for debugging.
     LOG(("* The first 10 (maximum) fixed-length prefixes: "));
     for (int i = 0; i < std::min(10, numOfPrefixes); i++) {
-      uint8_t* c = (uint8_t*)&p[i];
+      auto* c = (uint8_t*)&p[i];
       LOG(("%.2X%.2X%.2X%.2X", c[0], c[1], c[2], c[3]));
     }
 
     LOG(("* The last 10 (maximum) fixed-length prefixes: "));
     for (int i = std::max(0, numOfPrefixes - 10); i < numOfPrefixes; i++) {
-      uint8_t* c = (uint8_t*)&p[i];
+      auto* c = (uint8_t*)&p[i];
       LOG(("%.2X%.2X%.2X%.2X", c[0], c[1], c[2], c[3]));
     }
 
     LOG(("---- %d fixed-length prefixes in total.", aPrefixes.size() / aSize));
   }
 
-  PrefixStdString* prefix = new PrefixStdString(aPrefixes);
+  auto* prefix = new PrefixStdString(aPrefixes);
   mPrefixesMap.Put(aSize, prefix);
 }
 
 void
 TableUpdateV4::NewRemovalIndices(const uint32_t* aIndices, size_t aNumOfIndices)
 {
   for (size_t i = 0; i < aNumOfIndices; i++) {
     mRemovalIndiceArray.AppendElement(aIndices[i]);

--- a/toolkit/components/url-classifier/nsUrlClassifierPrefixSet.cpp
+++ b/toolkit/components/url-classifier/nsUrlClassifierPrefixSet.cpp
@@ -181,17 +181,17 @@ nsUrlClassifierPrefixSet::GetPrefixes(ui
 
   FallibleTArray<uint32_t> prefixes;
   nsresult rv = GetPrefixesNative(prefixes);
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   uint64_t itemCount = prefixes.Length();
-  uint32_t* prefixArray = static_cast<uint32_t*>(moz_xmalloc(itemCount * sizeof(uint32_t)));
+  auto* prefixArray = static_cast<uint32_t*>(moz_xmalloc(itemCount * sizeof(uint32_t)));
   NS_ENSURE_TRUE(prefixArray, NS_ERROR_OUT_OF_MEMORY);
 
   memcpy(prefixArray, prefixes.Elements(), sizeof(uint32_t) * itemCount);
 
   *aCount = itemCount;
   *aPrefixes = prefixArray;
 
   return NS_OK;

--- a/toolkit/crashreporter/google-breakpad/src/common/linux/file_id.cc
+++ b/toolkit/crashreporter/google-breakpad/src/common/linux/file_id.cc
@@ -62,17 +62,17 @@ FileID::FileID(const char* path) : path_
 // and use the syscall/libc wrappers instead of direct syscalls or libc.
 
 template<typename ElfClass>
 static bool ElfClassBuildIDNoteIdentifier(const void *section, size_t length,
                                           wasteful_vector<uint8_t>& identifier) {
   typedef typename ElfClass::Nhdr Nhdr;
 
   const void* section_end = reinterpret_cast<const char*>(section) + length;
-  const Nhdr* note_header = reinterpret_cast<const Nhdr*>(section);
+  const auto* note_header = reinterpret_cast<const Nhdr*>(section);
   while (reinterpret_cast<const void *>(note_header) < section_end) {
     if (note_header->n_type == NT_GNU_BUILD_ID)
       break;
     note_header = reinterpret_cast<const Nhdr*>(
                   reinterpret_cast<const char*>(note_header) + sizeof(Nhdr) +
                   NOTE_PADDING(note_header->n_namesz) +
                   NOTE_PADDING(note_header->n_descsz));
   }
@@ -129,17 +129,17 @@ static bool HashElfTextSection(const voi
                       (const void**)&text_section, &text_size, NULL) ||
       text_size == 0) {
     return false;
   }
 
   // Only provide |kMDGUIDSize| bytes to keep identifiers produced by this
   // function backwards-compatible.
   my_memset(&identifier[0], 0, kMDGUIDSize);
-  const uint8_t* ptr = reinterpret_cast<const uint8_t*>(text_section);
+  const auto* ptr = reinterpret_cast<const uint8_t*>(text_section);
   const uint8_t* ptr_end = ptr + std::min(text_size, static_cast<size_t>(4096));
   while (ptr < ptr_end) {
     for (unsigned i = 0; i < kMDGUIDSize; i++)
       identifier[i] ^= ptr[i];
     ptr += kMDGUIDSize;
   }
   return true;
 }
@@ -178,21 +178,21 @@ static string bytes_to_hex_string(const 
 // static
 string FileID::ConvertIdentifierToUUIDString(
     const wasteful_vector<uint8_t>& identifier) {
   uint8_t identifier_swapped[kMDGUIDSize] = { 0 };
 
   // Endian-ness swap to match dump processor expectation.
   memcpy(identifier_swapped, &identifier[0],
          std::min(kMDGUIDSize, identifier.size()));
-  uint32_t* data1 = reinterpret_cast<uint32_t*>(identifier_swapped);
+  auto* data1 = reinterpret_cast<uint32_t*>(identifier_swapped);
   *data1 = htonl(*data1);
-  uint16_t* data2 = reinterpret_cast<uint16_t*>(identifier_swapped + 4);
+  auto* data2 = reinterpret_cast<uint16_t*>(identifier_swapped + 4);
   *data2 = htons(*data2);
-  uint16_t* data3 = reinterpret_cast<uint16_t*>(identifier_swapped + 6);
+  auto* data3 = reinterpret_cast<uint16_t*>(identifier_swapped + 6);
   *data3 = htons(*data3);
 
   return bytes_to_hex_string(identifier_swapped, kMDGUIDSize);
 }
 
 // static
 string FileID::ConvertIdentifierToString(
     const wasteful_vector<uint8_t>& identifier) {

--- a/toolkit/mozapps/update/common/readstrings.cpp
+++ b/toolkit/mozapps/update/common/readstrings.cpp
@@ -59,17 +59,17 @@ NS_strspnp(const char *delims, const cha
 }
 
 static char*
 NS_strtok(const char *delims, char **str)
 {
   if (!*str)
     return nullptr;
 
-  char *ret = (char*) NS_strspnp(delims, *str);
+  auto *ret = (char*) NS_strspnp(delims, *str);
 
   if (!*ret) {
     *str = ret;
     return nullptr;
   }
 
   char *i = ret;
   do {
@@ -137,17 +137,17 @@ ReadStrings(const NS_tchar *path,
   /* get file size */
   if (fseek(fp, 0, SEEK_END) != 0)
     return READ_ERROR;
 
   long len = ftell(fp);
   if (len <= 0)
     return READ_ERROR;
 
-  size_t flen = size_t(len);
+  auto flen = size_t(len);
   AutoCharArray fileContents(flen + 1);
   if (!fileContents)
     return READ_STRINGS_MEM_ERROR;
 
   /* read the file in one swoop */
   if (fseek(fp, 0, SEEK_SET) != 0)
     return READ_ERROR;
 

--- a/toolkit/mozapps/update/tests/TestAUSHelper.cpp
+++ b/toolkit/mozapps/update/tests/TestAUSHelper.cpp
@@ -106,17 +106,17 @@ CheckMsg(const NS_tchar *path, const cha
 
   struct stat ms;
   if (fstat(fileno(inFP), &ms)) {
     fclose(inFP);
     inFP = nullptr;
     return false;
   }
 
-  char *mbuf = (char *) malloc(ms.st_size + 1);
+  auto *mbuf = (char *) malloc(ms.st_size + 1);
   if (!mbuf) {
     fclose(inFP);
     inFP = nullptr;
     return false;
   }
 
   size_t r = ms.st_size;
   char *rb = mbuf;

--- a/toolkit/mozapps/update/updater/bspatch.cpp
+++ b/toolkit/mozapps/update/updater/bspatch.cpp
@@ -87,17 +87,17 @@ MBS_ReadHeader(FILE* file, MBSPatchHeade
 }
          
 int
 MBS_ApplyPatch(const MBSPatchHeader *header, FILE* patchFile,
                unsigned char *fbuffer, FILE* file)
 {
   unsigned char *fbufend = fbuffer + header->slen;
 
-  unsigned char *buf = (unsigned char*) malloc(header->cblen +
+  auto *buf = (unsigned char*) malloc(header->cblen +
                                                header->difflen +
                                                header->extralen);
   if (!buf)
     return BSPATCH_MEM_ERROR;
 
   int rv = OK;
 
   size_t r = header->cblen + header->difflen + header->extralen;
@@ -110,21 +110,21 @@ MBS_ApplyPatch(const MBSPatchHeader *hea
       goto end;
     }
 
     r -= c;
     wb += c;
   }
 
   {
-    MBSPatchTriple *ctrlsrc = (MBSPatchTriple*) buf;
+    auto *ctrlsrc = (MBSPatchTriple*) buf;
     unsigned char *diffsrc = buf + header->cblen;
     unsigned char *extrasrc = diffsrc + header->difflen;
 
-    MBSPatchTriple *ctrlend = (MBSPatchTriple*) diffsrc;
+    auto *ctrlend = (MBSPatchTriple*) diffsrc;
     unsigned char *diffend = extrasrc;
     unsigned char *extraend = extrasrc + header->extralen;
 
     do {
       ctrlsrc->x = ntohl(ctrlsrc->x);
       ctrlsrc->y = ntohl(ctrlsrc->y);
       ctrlsrc->z = ntohl(ctrlsrc->z);
 

--- a/toolkit/mozapps/update/updater/updater.cpp
+++ b/toolkit/mozapps/update/updater/updater.cpp
@@ -390,17 +390,17 @@ EnvHasValue(const char *name)
  * @return valid filesystem full path or nullptr if memory allocation fails.
  */
 static NS_tchar*
 get_full_path(const NS_tchar *relpath)
 {
   NS_tchar *destpath = sStagedUpdate ? gWorkingDirPath : gInstallDirPath;
   size_t lendestpath = NS_tstrlen(destpath);
   size_t lenrelpath = NS_tstrlen(relpath);
-  NS_tchar *s = new NS_tchar[lendestpath + lenrelpath + 2];
+  auto *s = new NS_tchar[lendestpath + lenrelpath + 2];
   if (!s) {
     return nullptr;
   }
 
   NS_tchar *c = s;
 
   NS_tstrcpy(c, destpath);
   c += lendestpath;
@@ -500,17 +500,17 @@ get_valid_path(NS_tchar **line, bool isd
 
 static NS_tchar*
 get_quoted_path(const NS_tchar *path)
 {
   size_t lenQuote = NS_tstrlen(kQuote);
   size_t lenPath = NS_tstrlen(path);
   size_t len = lenQuote + lenPath + lenQuote + 1;
 
-  NS_tchar *s = (NS_tchar *) malloc(len * sizeof(NS_tchar));
+  auto *s = (NS_tchar *) malloc(len * sizeof(NS_tchar));
   if (!s)
     return nullptr;
 
   NS_tchar *c = s;
   NS_tstrcpy(c, kQuote);
   c += lenQuote;
   NS_tstrcat(c, path);
   c += lenPath;
@@ -641,17 +641,17 @@ static FILE* ensure_open(const NS_tchar 
   return f;
 }
 
 // Ensure that the directory containing this file exists.
 static int ensure_parent_dir(const NS_tchar *path)
 {
   int rv = OK;
 
-  NS_tchar *slash = (NS_tchar *) NS_tstrrchr(path, NS_T('/'));
+  auto *slash = (NS_tchar *) NS_tstrrchr(path, NS_T('/'));
   if (slash) {
     *slash = NS_T('\0');
     rv = ensure_parent_dir(path);
     // Only attempt to create the directory if we're not at the root
     if (rv == OK && *path) {
       rv = NS_tmkdir(path, 0755);
       // If the directory already exists, then ignore the error.
       if (rv < 0 && errno != EEXIST) {
@@ -1169,17 +1169,17 @@ RemoveFile::Prepare()
     return READ_ERROR;
   }
 
   if (!S_ISREG(fileInfo.st_mode)) {
     LOG(("path present, but not a file: " LOG_S, mFile.get()));
     return DELETE_ERROR_EXPECTED_FILE;
   }
 
-  NS_tchar *slash = (NS_tchar *) NS_tstrrchr(mFile.get(), NS_T('/'));
+  auto *slash = (NS_tchar *) NS_tstrrchr(mFile.get(), NS_T('/'));
   if (slash) {
     *slash = NS_T('\0');
     rv = NS_taccess(mFile.get(), W_OK);
     *slash = NS_T('/');
   } else {
     rv = NS_taccess(NS_T("."), W_OK);
   }
 
@@ -4113,17 +4113,17 @@ GetManifestContents(const NS_tchar *mani
 
   struct stat ms;
   int rv = fstat(fileno((FILE *)mfile), &ms);
   if (rv) {
     LOG(("GetManifestContents: error stating manifest file: " LOG_S, manifest));
     return nullptr;
   }
 
-  char *mbuf = (char *) malloc(ms.st_size + 1);
+  auto *mbuf = (char *) malloc(ms.st_size + 1);
   if (!mbuf)
     return nullptr;
 
   size_t r = ms.st_size;
   char *rb = mbuf;
   while (r) {
     const size_t count = mmin(SSIZE_MAX, r);
     size_t c = fread(rb, 1, count, mfile);

--- a/toolkit/system/gnome/nsAlertsIconListener.cpp
+++ b/toolkit/system/gnome/nsAlertsIconListener.cpp
@@ -32,30 +32,30 @@ nsAlertsIconListener::notify_notificatio
 nsAlertsIconListener::notify_notification_show_t nsAlertsIconListener::notify_notification_show = nullptr;
 nsAlertsIconListener::notify_notification_set_icon_from_pixbuf_t nsAlertsIconListener::notify_notification_set_icon_from_pixbuf = nullptr;
 nsAlertsIconListener::notify_notification_add_action_t nsAlertsIconListener::notify_notification_add_action = nullptr;
 nsAlertsIconListener::notify_notification_close_t nsAlertsIconListener::notify_notification_close = nullptr;
 
 static void notify_action_cb(NotifyNotification *notification,
                              gchar *action, gpointer user_data)
 {
-  nsAlertsIconListener* alert = static_cast<nsAlertsIconListener*> (user_data);
+  auto* alert = static_cast<nsAlertsIconListener*> (user_data);
   alert->SendCallback();
 }
 
 static void notify_closed_marshal(GClosure* closure,
                                   GValue* return_value,
                                   guint n_param_values,
                                   const GValue* param_values,
                                   gpointer invocation_hint,
                                   gpointer marshal_data)
 {
   MOZ_ASSERT(n_param_values >= 1, "No object in params");
 
-  nsAlertsIconListener* alert =
+  auto* alert =
     static_cast<nsAlertsIconListener*>(closure->data);
   alert->SendClosed();
   NS_RELEASE(alert);
 }
 
 static GdkPixbuf*
 GetPixbufFromImgRequest(imgIRequest* aRequest)
 {

--- a/toolkit/system/gnome/nsGIOService.cpp
+++ b/toolkit/system/gnome/nsGIOService.cpp
@@ -269,17 +269,17 @@ NS_IMETHODIMP
 nsGIOService::GetAppForURIScheme(const nsACString& aURIScheme,
                                  nsIGIOMimeApp** aApp)
 {
   *aApp = nullptr;
 
   GAppInfo *app_info = g_app_info_get_default_for_uri_scheme(
                           PromiseFlatCString(aURIScheme).get());
   if (app_info) {
-    nsGIOMimeApp *mozApp = new nsGIOMimeApp(app_info);
+    auto *mozApp = new nsGIOMimeApp(app_info);
     NS_ADDREF(*aApp = mozApp);
   } else {
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 
 NS_IMETHODIMP
@@ -289,17 +289,17 @@ nsGIOService::GetAppForMimeType(const ns
   *aApp = nullptr;
   char *content_type =
     g_content_type_from_mime_type(PromiseFlatCString(aMimeType).get());
   if (!content_type)
     return NS_ERROR_FAILURE;
 
   GAppInfo *app_info = g_app_info_get_default_for_type(content_type, false);
   if (app_info) {
-    nsGIOMimeApp *mozApp = new nsGIOMimeApp(app_info);
+    auto *mozApp = new nsGIOMimeApp(app_info);
     NS_ENSURE_TRUE(mozApp, NS_ERROR_OUT_OF_MEMORY);
     NS_ADDREF(*aApp = mozApp);
   } else {
     g_free(content_type);
     return NS_ERROR_FAILURE;
   }
   g_free(content_type);
   return NS_OK;
@@ -463,13 +463,13 @@ nsGIOService::CreateAppFromCommand(nsACS
                                                   &error);
   }
 
   if (!app_info) {
     g_warning("Cannot create application info from command: %s", error->message);
     g_error_free(error);
     return NS_ERROR_FAILURE;
   }
-  nsGIOMimeApp *mozApp = new nsGIOMimeApp(app_info);
+  auto *mozApp = new nsGIOMimeApp(app_info);
   NS_ENSURE_TRUE(mozApp, NS_ERROR_OUT_OF_MEMORY);
   NS_ADDREF(*appInfo = mozApp);
   return NS_OK;
 }

--- a/toolkit/system/gnome/nsGSettingsService.cpp
+++ b/toolkit/system/gnome/nsGSettingsService.cpp
@@ -335,16 +335,16 @@ nsGSettingsService::GetCollectionForSche
 {
   NS_ENSURE_ARG_POINTER(collection);
 
   const char * const *schemas = g_settings_list_schemas();
 
   for (uint32_t i = 0; schemas[i] != nullptr; i++) {
     if (schema.Equals(schemas[i])) {
       GSettings *settings = g_settings_new(PromiseFlatCString(schema).get());
-      nsGSettingsCollection *mozGSettings = new nsGSettingsCollection(settings);
+      auto *mozGSettings = new nsGSettingsCollection(settings);
       NS_ADDREF(*collection = mozGSettings);
       return NS_OK;
     }
   }
 
   return NS_ERROR_FAILURE;
 }

--- a/toolkit/system/gnome/nsPackageKitService.cpp
+++ b/toolkit/system/gnome/nsPackageKitService.cpp
@@ -140,17 +140,17 @@ InstallPackagesNotifyObserver(nsIObserve
 }
 
 static void
 InstallPackagesProxyCallCallback(GObject *aSourceObject,
                                  GAsyncResult *aResult,
                                  gpointer aUserData)
 {
   nsCOMPtr<nsIObserver> observer = static_cast<nsIObserver*>(aUserData);
-  GDBusProxy* proxy = reinterpret_cast<GDBusProxy*>(aSourceObject);
+  auto* proxy = reinterpret_cast<GDBusProxy*>(aSourceObject);
 
   GError* error = nullptr;
   GVariant* result = g_dbus_proxy_call_finish(proxy, aResult, &error);
   if (result) {
     InstallPackagesNotifyObserver(observer, nullptr);
     g_variant_unref(result);
   } else {
     NS_ASSERTION(error, "g_dbus_proxy_call_finish should set error when it returns NULL");
@@ -162,17 +162,17 @@ InstallPackagesProxyCallCallback(GObject
   Unused << observer.forget().take();
 }
 
 static void
 InstallPackagesProxyNewCallback(GObject *aSourceObject,
                                 GAsyncResult *aResult,
                                 gpointer aUserData)
 {
-  InstallPackagesProxyNewData* userData =
+  auto* userData =
     static_cast<InstallPackagesProxyNewData*>(aUserData);
 
   NS_ASSERTION(g_variant_is_floating(userData->parameters),
                "userData->parameters should be a floating reference.");
 
   GError* error = nullptr;
   GDBusProxy* proxy = g_dbus_proxy_new_finish(aResult, &error);
 
@@ -245,17 +245,17 @@ nsPackageKitService::InstallPackages(uin
     }
   }
   for (uint32_t i = 0; i < arrayLength; i++) {
     g_free(packages[i]);
   }
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Send the asynchronous request to load the bus proxy
-  InstallPackagesProxyNewData* data = new InstallPackagesProxyNewData;
+  auto* data = new InstallPackagesProxyNewData;
   data->observer = aObserver;
   data->method = aInstallMethod;
   data->parameters = parameters;
   g_dbus_proxy_new_for_bus(G_BUS_TYPE_SESSION,
                            G_DBUS_PROXY_FLAGS_NONE,
                            nullptr,
                            "org.freedesktop.PackageKit",
                            "/org/freedesktop/PackageKit",

--- a/toolkit/xre/nsAppRunner.cpp
+++ b/toolkit/xre/nsAppRunner.cpp
@@ -4698,17 +4698,17 @@ XRE_InitCommandLine(int aArgc, char* aAr
 {
   nsresult rv = NS_OK;
 
 #if defined(OS_WIN)
   CommandLine::Init(aArgc, aArgv);
 #else
 
   // these leak on error, but that's OK: we'll just exit()
-  char** canonArgs = new char*[aArgc];
+  auto** canonArgs = new char*[aArgc];
 
   // get the canonical version of the binary's path
   nsCOMPtr<nsIFile> binFile;
   rv = XRE_GetBinaryPath(aArgv[0], getter_AddRefs(binFile));
   if (NS_FAILED(rv))
     return NS_ERROR_FAILURE;
 
   nsAutoCString canonBinPath;

--- a/toolkit/xre/nsEmbedFunctions.cpp
+++ b/toolkit/xre/nsEmbedFunctions.cpp
@@ -940,17 +940,17 @@ XRE_SendTestShellCommand(JSContext* aCx,
 
     nsAutoJSString command;
     NS_ENSURE_TRUE(command.init(aCx, cmd), false);
 
     if (!aCallback) {
         return tsp->SendExecuteCommand(command);
     }
 
-    TestShellCommandParent* callback = static_cast<TestShellCommandParent*>(
+    auto* callback = static_cast<TestShellCommandParent*>(
         tsp->SendPTestShellCommandConstructor(command));
     NS_ENSURE_TRUE(callback, false);
 
     JS::Value callbackVal = *reinterpret_cast<JS::Value*>(aCallback);
     NS_ENSURE_TRUE(callback->SetCallback(aCx, callbackVal), false);
 
     return true;
 }