--- a/accessible/base/NotificationController.h
+++ b/accessible/base/NotificationController.h
@@ -4,21 +4,22 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_a11y_NotificationController_h_
#define mozilla_a11y_NotificationController_h_
#include "EventQueue.h"
#include "EventTree.h"
-#include "mozilla/IndexSequence.h"
#include "mozilla/Tuple.h"
#include "nsCycleCollectionParticipant.h"
#include "nsRefreshDriver.h"
+#include <utility>
+
#ifdef A11Y_LOG
#include "Logging.h"
#endif
namespace mozilla {
namespace a11y {
class DocAccessible;
@@ -63,24 +64,24 @@ class TNotification : public Notificatio
public:
typedef void (Class::*Callback)(Args* ...);
TNotification(Class* aInstance, Callback aCallback, Args* ... aArgs) :
mInstance(aInstance), mCallback(aCallback), mArgs(aArgs...) { }
virtual ~TNotification() { mInstance = nullptr; }
virtual void Process() override
- { ProcessHelper(typename IndexSequenceFor<Args...>::Type()); }
+ { ProcessHelper(std::index_sequence_for<Args...>); }
private:
TNotification(const TNotification&);
TNotification& operator = (const TNotification&);
template <size_t... Indices>
- void ProcessHelper(IndexSequence<Indices...>)
+ void ProcessHelper(std::index_sequence<Indices...>)
{
(mInstance->*mCallback)(Get<Indices>(mArgs)...);
}
Class* mInstance;
Callback mCallback;
Tuple<RefPtr<Args> ...> mArgs;
};
--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -7,23 +7,23 @@
#ifdef XP_WIN
// Include Windows headers required for enabling high precision timers.
#include "windows.h"
#include "mmsystem.h"
#endif
#include <algorithm>
#include <stdint.h>
+#include <utility>
#include "mediasink/AudioSink.h"
#include "mediasink/AudioSinkWrapper.h"
#include "mediasink/DecodedStream.h"
#include "mediasink/OutputStreamManager.h"
#include "mediasink/VideoSink.h"
-#include "mozilla/IndexSequence.h"
#include "mozilla/Logging.h"
#include "mozilla/MathAlgorithms.h"
#include "mozilla/NotNull.h"
#include "mozilla/Preferences.h"
#include "mozilla/SharedThreadPool.h"
#include "mozilla/Sprintf.h"
#include "mozilla/Telemetry.h"
#include "mozilla/TaskQueue.h"
@@ -259,17 +259,17 @@ protected:
const MediaInfo& Info() const { return mMaster->Info(); }
MediaQueue<AudioData>& AudioQueue() const { return mMaster->mAudioQueue; }
MediaQueue<VideoData>& VideoQueue() const { return mMaster->mVideoQueue; }
template <class S, typename... Args, size_t... Indexes>
auto
CallEnterMemberFunction(S* aS,
Tuple<Args...>& aTuple,
- IndexSequence<Indexes...>)
+ std::index_sequence<Indexes...>)
-> decltype(ReturnTypeHelper(&S::Enter))
{
return aS->Enter(Move(Get<Indexes>(aTuple))...);
}
// Note this function will delete the current state object.
// Don't access members to avoid UAF after this call.
template <class S, typename... Ts>
@@ -301,17 +301,17 @@ protected:
master->OwnerThread()->DispatchDirectTask(
NS_NewRunnableFunction("MDSM::StateObject::DeleteOldState",
[toDelete = Move(master->mStateObj)](){}));
// Also reset mMaster to catch potentail UAF.
mMaster = nullptr;
master->mStateObj.reset(s);
return CallEnterMemberFunction(s, copiedArgs,
- typename IndexSequenceFor<Ts...>::Type());
+ std::index_sequence_for<Ts...>);
}
RefPtr<MediaDecoder::SeekPromise>
SetSeekingState(SeekJob&& aSeekJob, EventVisibility aVisibility);
// Take a raw pointer in order not to change the life cycle of MDSM.
// It is guaranteed to be valid by MDSM.
Master* mMaster;
--- a/dom/plugins/ipc/FunctionBroker.h
+++ b/dom/plugins/ipc/FunctionBroker.h
@@ -4,16 +4,17 @@
* 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 dom_plugins_ipc_PluginHooksWin_h
#define dom_plugins_ipc_PluginHooksWin_h 1
#include <map>
#include <algorithm>
+#include <utility>
#include "base/task.h"
#include "mozilla/ipc/ProcessChild.h"
#include "FunctionBrokerChild.h"
#include "mtransport/runnable_utils.h"
#include "PluginMessageUtils.h"
#include "mozilla/Logging.h"
#include "FunctionHook.h"
#include "FunctionBrokerIPCUtils.h"
@@ -1258,17 +1259,17 @@ public:
return BrokerCallServer(aClientId, aInTuple, aOutTuple);
}
protected:
bool BrokerCallServer(base::ProcessId aClientId, const IpdlTuple &aInTuple,
IpdlTuple *aOutTuple) const
{
return BrokerCallServer(aClientId, aInTuple, aOutTuple,
- typename IndexSequenceFor<ParamTypes...>::Type());
+ std::index_sequence_for<ParamTypes...>);
}
bool BrokerCallClient(uint32_t& aWinError, ResultType& aResult, ParamTypes&... aParameters) const;
bool PostToDispatchThread(uint32_t& aWinError, ResultType& aRet, ParamTypes&... aParameters) const;
static void
PostToDispatchHelper(const SelfType* bmhi, Monitor* monitor, bool* notified,
bool* ok, uint32_t* winErr, ResultType* r, ParamTypes*... p)
@@ -1298,17 +1299,17 @@ protected:
return aFunction(aParams...);
};
bool BrokerCallServer(base::ProcessId aClientId, const IpdlTuple &aInTuple,
IpdlTuple *aOutTuple, ParamTypes&... aParams) const;
template<size_t... Indices>
bool BrokerCallServer(base::ProcessId aClientId, const IpdlTuple &aInTuple,
- IpdlTuple *aOutTuple, IndexSequence<Indices...>) const
+ IpdlTuple *aOutTuple, std::index_sequence<Indices...>) const
{
TupleParamTypes paramTuple;
return BrokerCallServer(aClientId, aInTuple, aOutTuple,
Get<Indices>(paramTuple)...);
}
};
template <FunctionHookId functionId, typename ResultType, typename ... ParamTypes>
--- a/ipc/chromium/src/base/task.h
+++ b/ipc/chromium/src/base/task.h
@@ -4,61 +4,60 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BASE_TASK_H_
#define BASE_TASK_H_
#include "base/revocable_store.h"
#include "base/tuple.h"
-#include "mozilla/IndexSequence.h"
#include "mozilla/Tuple.h"
#include "nsISupportsImpl.h"
#include "nsThreadUtils.h"
+#include <utility>
+
// Helper functions so that we can call a function a pass it arguments that come
// from a Tuple.
namespace details {
// Call the given method on the given object. Arguments are passed by move
// semantics from the given tuple. If the tuple has length N, the sequence must
// be IndexSequence<0, 1, ..., N-1>.
template<size_t... Indices, class ObjT, class Method, typename... Args>
-void CallMethod(mozilla::IndexSequence<Indices...>, ObjT* obj, Method method,
+void CallMethod(std::index_sequence<Indices...>, ObjT* obj, Method method,
mozilla::Tuple<Args...>& arg)
{
(obj->*method)(mozilla::Move(mozilla::Get<Indices>(arg))...);
}
// Same as above, but call a function.
template<size_t... Indices, typename Function, typename... Args>
-void CallFunction(mozilla::IndexSequence<Indices...>, Function function,
+void CallFunction(std::index_sequence<Indices...>, Function function,
mozilla::Tuple<Args...>& arg)
{
(*function)(mozilla::Move(mozilla::Get<Indices>(arg))...);
}
} // namespace details
// Call a method on the given object. Arguments are passed by move semantics
// from the given tuple.
template<class ObjT, class Method, typename... Args>
void DispatchTupleToMethod(ObjT* obj, Method method, mozilla::Tuple<Args...>& arg)
{
- details::CallMethod(typename mozilla::IndexSequenceFor<Args...>::Type(),
- obj, method, arg);
+ details::CallMethod(std::index_sequence_for<Args...>, obj, method, arg);
}
// Same as above, but call a function.
template<typename Function, typename... Args>
void DispatchTupleToFunction(Function function, mozilla::Tuple<Args...>& arg)
{
- details::CallFunction(typename mozilla::IndexSequenceFor<Args...>::Type(),
- function, arg);
+ details::CallFunction(std::index_sequence_for<Args...>, function, arg);
}
// Scoped Factories ------------------------------------------------------------
//
// These scoped factory objects can be used by non-refcounted objects to safely
// place tasks in a message loop. Each factory guarantees that the tasks it
// produces will not run after the factory is destroyed. Commonly, factories
// are declared as class members, so the class' tasks will automatically cancel
--- a/js/src/frontend/EitherParser.h
+++ b/js/src/frontend/EitherParser.h
@@ -8,58 +8,59 @@
* A variant-like class abstracting operations on a Parser with a given ParseHandler but
* unspecified character type.
*/
#ifndef frontend_EitherParser_h
#define frontend_EitherParser_h
#include "mozilla/Attributes.h"
-#include "mozilla/IndexSequence.h"
#include "mozilla/Move.h"
#include "mozilla/Tuple.h"
#include "mozilla/TypeTraits.h"
#include "mozilla/Variant.h"
#include "frontend/Parser.h"
#include "frontend/TokenStream.h"
+#include <utility>
+
namespace js {
namespace detail {
template<template <class Parser> class GetThis,
template <class This> class MemberFunction,
typename... Args>
struct InvokeMemberFunction
{
mozilla::Tuple<typename mozilla::Decay<Args>::Type...> args;
template<class This, size_t... Indices>
auto
- matchInternal(This* obj, mozilla::IndexSequence<Indices...>)
+ matchInternal(This* obj, std::index_sequence<Indices...>)
-> decltype(((*obj).*(MemberFunction<This>::get()))(mozilla::Get<Indices>(args)...))
{
return ((*obj).*(MemberFunction<This>::get()))(mozilla::Get<Indices>(args)...);
}
public:
template<typename... ActualArgs>
explicit InvokeMemberFunction(ActualArgs&&... actualArgs)
: args { mozilla::Forward<ActualArgs>(actualArgs)... }
{}
template<class Parser>
auto
match(Parser* parser)
-> decltype(this->matchInternal(GetThis<Parser>::get(parser),
- typename mozilla::IndexSequenceFor<Args...>::Type()))
+ std::index_sequence_for<Args...>))
{
return this->matchInternal(GetThis<Parser>::get(parser),
- typename mozilla::IndexSequenceFor<Args...>::Type());
+ std::index_sequence_for<Args...>);
}
};
// |this|-computing templates.
template<class Parser>
struct GetParser
{
--- a/js/src/threading/Thread.h
+++ b/js/src/threading/Thread.h
@@ -5,21 +5,21 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef threading_Thread_h
#define threading_Thread_h
#include "mozilla/Atomics.h"
#include "mozilla/Attributes.h"
#include "mozilla/HashFunctions.h"
-#include "mozilla/IndexSequence.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/Tuple.h"
#include <stdint.h>
+#include <utility>
#include "jsutil.h"
#include "threading/LockGuard.h"
#include "threading/Mutex.h"
#include "vm/MutexIDs.h"
#ifdef XP_WIN
@@ -227,23 +227,23 @@ public:
explicit ThreadTrampoline(G&& aG, ArgsT&&... aArgsT)
: f(mozilla::Forward<F>(aG)),
args(mozilla::Forward<Args>(aArgsT)...)
{
}
static THREAD_RETURN_TYPE THREAD_CALL_API Start(void* aPack) {
auto* pack = static_cast<ThreadTrampoline<F, Args...>*>(aPack);
- pack->callMain(typename mozilla::IndexSequenceFor<Args...>::Type());
+ pack->callMain(std::index_sequence_for<Args...>);
js_delete(pack);
return 0;
}
template<size_t ...Indices>
- void callMain(mozilla::IndexSequence<Indices...>) {
+ void callMain(std::index_sequence<Indices...>) {
f(mozilla::Get<Indices>(args)...);
}
};
} // namespace detail
} // namespace js
#undef THREAD_RETURN_TYPE
--- a/media/mtransport/runnable_utils.h
+++ b/media/mtransport/runnable_utils.h
@@ -5,21 +5,22 @@
* You can obtain one at http://mozilla.org/MPL/2.0/. */
// Original author: ekr@rtfm.com
#ifndef runnable_utils_h__
#define runnable_utils_h__
#include "nsThreadUtils.h"
-#include "mozilla/IndexSequence.h"
#include "mozilla/Move.h"
#include "mozilla/RefPtr.h"
#include "mozilla/Tuple.h"
+#include <utility>
+
// Abstract base class for all of our templates
namespace mozilla {
namespace detail {
enum RunnableResult {
NoResult,
ReturnsResult
@@ -39,53 +40,53 @@ class runnable_args_base : public Runnab
NS_IMETHOD Run() override = 0;
};
template<typename R>
struct RunnableFunctionCallHelper
{
template<typename FunType, typename... Args, size_t... Indices>
- static R apply(FunType func, Tuple<Args...>& args, IndexSequence<Indices...>)
+ static R apply(FunType func, Tuple<Args...>& args, std::index_sequence<Indices...>)
{
return func(Get<Indices>(args)...);
}
};
// A void specialization is needed in the case where the template instantiator
// knows we don't want to return a value, but we don't know whether the called
// function returns void or something else.
template<>
struct RunnableFunctionCallHelper<void>
{
template<typename FunType, typename... Args, size_t... Indices>
- static void apply(FunType func, Tuple<Args...>& args, IndexSequence<Indices...>)
+ static void apply(FunType func, Tuple<Args...>& args, std::index_sequence<Indices...>)
{
func(Get<Indices>(args)...);
}
};
template<typename R>
struct RunnableMethodCallHelper
{
template<typename Class, typename M, typename... Args, size_t... Indices>
- static R apply(Class obj, M method, Tuple<Args...>& args, IndexSequence<Indices...>)
+ static R apply(Class obj, M method, Tuple<Args...>& args, std::index_sequence<Indices...>)
{
return ((*obj).*method)(Get<Indices>(args)...);
}
};
// A void specialization is needed in the case where the template instantiator
// knows we don't want to return a value, but we don't know whether the called
// method returns void or something else.
template<>
struct RunnableMethodCallHelper<void>
{
template<typename Class, typename M, typename... Args, size_t... Indices>
- static void apply(Class obj, M method, Tuple<Args...>& args, IndexSequence<Indices...>)
+ static void apply(Class obj, M method, Tuple<Args...>& args, std::index_sequence<Indices...>)
{
((*obj).*method)(Get<Indices>(args)...);
}
};
}
template<typename FunType, typename... Args>
@@ -94,17 +95,17 @@ class runnable_args_func : public detail
public:
// |explicit| to pacify static analysis when there are no |args|.
template<typename... Arguments>
explicit runnable_args_func(FunType f, Arguments&&... args)
: mFunc(f), mArgs(Forward<Arguments>(args)...)
{}
NS_IMETHOD Run() override {
- detail::RunnableFunctionCallHelper<void>::apply(mFunc, mArgs, typename IndexSequenceFor<Args...>::Type());
+ detail::RunnableFunctionCallHelper<void>::apply(mFunc, mArgs, std::index_sequence_for<Args...>);
return NS_OK;
}
private:
FunType mFunc;
Tuple<Args...> mArgs;
};
@@ -120,17 +121,17 @@ class runnable_args_func_ret : public de
{
public:
template<typename... Arguments>
runnable_args_func_ret(Ret* ret, FunType f, Arguments&&... args)
: mReturn(ret), mFunc(f), mArgs(Forward<Arguments>(args)...)
{}
NS_IMETHOD Run() override {
- *mReturn = detail::RunnableFunctionCallHelper<Ret>::apply(mFunc, mArgs, typename IndexSequenceFor<Args...>::Type());
+ *mReturn = detail::RunnableFunctionCallHelper<Ret>::apply(mFunc, mArgs, std::index_sequence_for<Args...>);
return NS_OK;
}
private:
Ret* mReturn;
FunType mFunc;
Tuple<Args...> mArgs;
};
@@ -147,17 +148,17 @@ class runnable_args_memfn : public detai
{
public:
template<typename... Arguments>
runnable_args_memfn(Class obj, M method, Arguments&&... args)
: mObj(obj), mMethod(method), mArgs(Forward<Arguments>(args)...)
{}
NS_IMETHOD Run() override {
- detail::RunnableMethodCallHelper<void>::apply(mObj, mMethod, mArgs, typename IndexSequenceFor<Args...>::Type());
+ detail::RunnableMethodCallHelper<void>::apply(mObj, mMethod, mArgs, std::index_sequence_for<Args...>);
return NS_OK;
}
private:
Class mObj;
M mMethod;
Tuple<Args...> mArgs;
};
@@ -174,17 +175,17 @@ class runnable_args_memfn_ret : public d
{
public:
template<typename... Arguments>
runnable_args_memfn_ret(Ret* ret, Class obj, M method, Arguments... args)
: mReturn(ret), mObj(obj), mMethod(method), mArgs(Forward<Arguments>(args)...)
{}
NS_IMETHOD Run() override {
- *mReturn = detail::RunnableMethodCallHelper<Ret>::apply(mObj, mMethod, mArgs, typename IndexSequenceFor<Args...>::Type());
+ *mReturn = detail::RunnableMethodCallHelper<Ret>::apply(mObj, mMethod, mArgs, std::index_sequence_for<Args...>);
return NS_OK;
}
private:
Ret* mReturn;
Class mObj;
M mMethod;
Tuple<Args...> mArgs;
deleted file mode 100644
--- a/mfbt/IndexSequence.h
+++ /dev/null
@@ -1,143 +0,0 @@
-/* -*- 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 utility for expanding a tuple into a variadic argument list.
- * Based on std::index_sequence. */
-
-/**
- * Example usage:
- *
- * Problem:
- *
- * You have a variadic function Foo:
- *
- * template <typename... Args> void Foo(Args...);
- *
- * And a variadic function Bar, which contains a tuple:
- *
- * template <typename... Args>
- * void Bar() {
- * // ...
- * Tuple<Args...> t;
- * }
- *
- * And inside Bar, you want to call Foo with the elements of the tuple as
- * arguments to Foo.
- *
- * You want to write:
- *
- * Foo(Get<0>(t), Get<1>(t), ..., Get<N>(t))
- *
- * but you can't literally write that, because N is different for different
- * instantiations of Bar.
- *
- * Solution:
- *
- * Write a helper function which takes the tuple, and an index sequence
- * containing indices corresponding to the tuple indices.
- *
- * template <typename... Args, size_t... Indices>
- * void Helper(const Tuple<Args...>& t, IndexSequence<Indices...>)
- * {
- * Foo(Get<Indices>(t)...);
- * }
- *
- * Assuming 'Indices...' are 0, 1, ..., N - 1, where N is the size of the
- * tuple, pack expansion will expand the pack 'Get<Indices>(t)...' to
- * 'Get<0>(t), Get<1>(t), ..., Get<N>(t)'.
- *
- * Finally, call the helper, creating the index sequence to pass in like so:
- *
- * template <typename... Args>
- * void Bar() {
- * // ...
- * Tuple<Args...> t;
- * Helper(t, typename IndexSequenceFor<Args...>::Type());
- * }
- */
-
-#ifndef mozilla_IndexSequence_h
-#define mozilla_IndexSequence_h
-
-#include "mozilla/Attributes.h"
-
-#include <stddef.h>
-
-namespace mozilla {
-
-/**
- * Represents a compile-time sequence of integer indices.
- */
-template<size_t... Indices>
-struct IndexSequence
-{
- static constexpr size_t Size() { return sizeof...(Indices); }
-};
-
-namespace detail {
-
-// Helpers used by MakeIndexSequence.
-
-template<size_t... Indices>
-struct IndexTuple
-{
- typedef IndexTuple<Indices..., sizeof...(Indices)> Next;
-};
-
-// Builds IndexTuple<0, 1, ..., N - 1>.
-template<size_t N>
-struct BuildIndexTuple
-{
- typedef typename BuildIndexTuple<N - 1>::Type::Next Type;
-};
-
-template<>
-struct BuildIndexTuple<0>
-{
- typedef IndexTuple<> Type;
-};
-
-template<size_t N, typename IndexTuple>
-struct MakeIndexSequenceImpl;
-
-template<size_t N, size_t... Indices>
-struct MakeIndexSequenceImpl<N, IndexTuple<Indices...>>
-{
- typedef IndexSequence<Indices...> Type;
-};
-
-} // namespace detail
-
-/**
- * A utility for building an IndexSequence of consecutive indices.
- * MakeIndexSequence<N>::Type evaluates to IndexSequence<0, 1, .., N - 1>.
- * Note: unlike std::make_index_sequence, this is not an alias template
- * to work around bugs in MSVC 2013.
- */
-template<size_t N>
-struct MakeIndexSequence
-{
- typedef typename detail::MakeIndexSequenceImpl<N,
- typename detail::BuildIndexTuple<N>::Type>::Type Type;
-};
-
-/**
- * A utility for building an IndexSequence of consecutive indices
- * corresponding to a variadic argument list.
- * IndexSequenceFor<Types...> evaluates to IndexSequence<0, 1, ..., N - 1>
- * where N is the number of types in Types.
- * Note: unlike std::index_sequence_for, this is not an alias template
- * to work around bugs in MSVC 2013.
- */
-template<typename... Types>
-struct IndexSequenceFor
-{
- typedef typename MakeIndexSequence<sizeof...(Types)>::Type Type;
-};
-
-} // namespace mozilla
-
-#endif /* mozilla_IndexSequence_h */
--- a/mfbt/moz.build
+++ b/mfbt/moz.build
@@ -38,17 +38,16 @@ EXPORTS.mozilla = [
'EnumeratedRange.h',
'EnumSet.h',
'EnumTypeTraits.h',
'FastBernoulliTrial.h',
'FloatingPoint.h',
'FStream.h',
'GuardObjects.h',
'HashFunctions.h',
- 'IndexSequence.h',
'IntegerPrintfMacros.h',
'IntegerRange.h',
'IntegerTypeTraits.h',
'JSONWriter.h',
'Likely.h',
'LinkedList.h',
'MacroArgs.h',
'MacroForEach.h',
--- a/xpcom/string/nsASCIIMask.h
+++ b/xpcom/string/nsASCIIMask.h
@@ -3,17 +3,17 @@
/* 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"
+#include <utility>
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,23 +49,23 @@ 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)
{
- return details::CreateASCIIMask(fun, mozilla::MakeIndexSequence<128>::Type{});
+ return details::CreateASCIIMask(fun, std::make_index_sequence<128>);
}
} // namespace mozilla
#endif // nsASCIIMask_h_
--- a/xpcom/threads/nsThreadUtils.h
+++ b/xpcom/threads/nsThreadUtils.h
@@ -17,22 +17,22 @@
#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"
+#include <utility>
//-----------------------------------------------------------------------------
// These methods are alternatives to the methods on nsIThreadManager, provided
// for convenience.
/**
* Create a new thread, and optionally provide an initial event for the thread.
*
@@ -1153,27 +1153,27 @@ 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()))
+ std::index_sequence_for<Ts...>))
{
return applyImpl(o, m, mArguments,
- typename IndexSequenceFor<Ts...>::Type());
+ std::index_sequence_for<Ts...>);
}
};
template<typename PtrType, typename Method, bool Owning, RunnableKind Kind, typename... Storages>
class RunnableMethodImpl final
: public ::nsRunnableMethodTraits<PtrType, Method, Owning, Kind>::base_type
{
typedef typename ::nsRunnableMethodTraits<PtrType, Method, Owning, Kind> Traits;