--- a/xpcom/string/nsASCIIMask.h
+++ b/xpcom/string/nsASCIIMask.h
@@ -3,17 +3,16 @@
 /* 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 nsASCIIMask_h_
 #define nsASCIIMask_h_
 
 #include <array>
-#include "mozilla/IndexSequence.h"
 
 typedef std::array<bool, 128> ASCIIMaskArray;
 
 namespace mozilla {
 
 // Boolean arrays, fixed size and filled in at compile time, meant to
 // record something about each of the (standard) ASCII characters.
 // No extended ASCII for now, there has been no use case.
@@ -49,17 +48,17 @@ public:
 // constexpr std::array<bool, 128> sABCMask = CreateASCIIMask(TestABC);
 // ...
 // if (someChar < 128 && sABCMask[someChar]) this is A or B or C
 
 
 namespace details
 {
 template<typename F, size_t... Indices>
-constexpr std::array<bool, 128> CreateASCIIMask(F fun, mozilla::IndexSequence<Indices...>)
+constexpr std::array<bool, 128> CreateASCIIMask(F fun, std::index_sequence<Indices...>)
 {
   return {{ fun(Indices)... }};
 }
 } // namespace details
 
 template<typename F>
 constexpr std::array<bool, 128> CreateASCIIMask(F fun)
 {

--- a/xpcom/threads/nsThreadUtils.h
+++ b/xpcom/threads/nsThreadUtils.h
@@ -17,17 +17,16 @@
 #include "nsIRunnable.h"
 #include "nsIThreadManager.h"
 #include "nsITimer.h"
 #include "nsIThread.h"
 #include "nsString.h"
 #include "nsCOMPtr.h"
 #include "nsAutoPtr.h"
 #include "mozilla/Atomics.h"
-#include "mozilla/IndexSequence.h"
 #include "mozilla/Likely.h"
 #include "mozilla/Move.h"
 #include "mozilla/TimeStamp.h"
 #include "mozilla/Tuple.h"
 #include "mozilla/TypeTraits.h"
 
 //-----------------------------------------------------------------------------
 // These methods are alternatives to the methods on nsIThreadManager, provided
@@ -1153,17 +1152,17 @@ struct RunnableMethodArguments final
 {
   Tuple<typename ::detail::ParameterStorage<Ts>::Type...> mArguments;
   template <typename... As>
   explicit RunnableMethodArguments(As&&... aArguments)
     : mArguments(Forward<As>(aArguments)...)
   {}
   template<typename C, typename M, typename... Args, size_t... Indices>
   static auto
-  applyImpl(C* o, M m, Tuple<Args...>& args, IndexSequence<Indices...>)
+  applyImpl(C* o, M m, Tuple<Args...>& args, std::index_sequence<Indices...>)
       -> decltype(((*o).*m)(Get<Indices>(args).PassAsParameter()...))
   {
     return ((*o).*m)(Get<Indices>(args).PassAsParameter()...);
   }
   template<class C, typename M> auto apply(C* o, M m)
       -> decltype(applyImpl(o, m, mArguments,
                   typename IndexSequenceFor<Ts...>::Type()))
   {