--- a/accessible/xpcom/xpcAccessibleTextRange.h
+++ b/accessible/xpcom/xpcAccessibleTextRange.h
@@ -58,17 +58,17 @@ public:
NS_IMETHOD RemoveFromSelection() final;
NS_IMETHOD Select() final;
NS_IMETHOD ScrollIntoView(uint32_t aHow) final;
NS_DECLARE_STATIC_IID_ACCESSOR(NS_ACCESSIBLETEXTRANGE_IMPL_IID)
private:
explicit xpcAccessibleTextRange(TextRange&& aRange) :
- mRange(Forward<TextRange>(aRange)) {}
+ mRange(std::forward<TextRange>(aRange)) {}
xpcAccessibleTextRange() {}
~xpcAccessibleTextRange() {}
friend class xpcAccessibleHyperText;
xpcAccessibleTextRange(const xpcAccessibleTextRange&) = delete;
xpcAccessibleTextRange& operator =(const xpcAccessibleTextRange&) = delete;
--- a/devtools/shared/heapsnapshot/HeapSnapshot.cpp
+++ b/devtools/shared/heapsnapshot/HeapSnapshot.cpp
@@ -913,23 +913,23 @@ class TwoByteString : public Variant<JSA
MOZ_ASSERT(chars);
JS::ubi::AtomOrTwoByteChars s(chars);
return s.copyToBuffer(destination, maxLength);
}
};
public:
template<typename T>
- MOZ_IMPLICIT TwoByteString(T&& rhs) : Base(Forward<T>(rhs)) { }
+ MOZ_IMPLICIT TwoByteString(T&& rhs) : Base(std::forward<T>(rhs)) { }
template<typename T>
TwoByteString& operator=(T&& rhs) {
MOZ_ASSERT(this != &rhs, "self-move disallowed");
this->~TwoByteString();
- new (this) TwoByteString(Forward<T>(rhs));
+ new (this) TwoByteString(std::forward<T>(rhs));
return *this;
}
TwoByteString(const TwoByteString&) = delete;
TwoByteString& operator=(const TwoByteString&) = delete;
// Rewrap the inner value of a JS::ubi::AtomOrTwoByteChars as a TwoByteString.
static TwoByteString from(JS::ubi::AtomOrTwoByteChars&& s) {
--- a/dom/animation/Animation.cpp
+++ b/dom/animation/Animation.cpp
@@ -8,17 +8,17 @@
#include "AnimationUtils.h"
#include "mozilla/dom/AnimationBinding.h"
#include "mozilla/dom/AnimationPlaybackEvent.h"
#include "mozilla/dom/DocumentTimeline.h"
#include "mozilla/AnimationTarget.h"
#include "mozilla/AutoRestore.h"
#include "mozilla/AsyncEventDispatcher.h" // For AsyncEventDispatcher
#include "mozilla/Maybe.h" // For Maybe
-#include "mozilla/TypeTraits.h" // For Forward<>
+#include "mozilla/TypeTraits.h" // For std::forward<>
#include "nsAnimationManager.h" // For CSSAnimation
#include "nsDOMMutationObserver.h" // For nsAutoAnimationMutationBatch
#include "nsIDocument.h" // For nsIDocument
#include "nsIPresShell.h" // For nsIPresShell
#include "nsThreadUtils.h" // For nsRunnableMethod and nsRevocableEventPtr
#include "nsTransitionManager.h" // For CSSTransition
#include "PendingAnimationTracker.h" // For PendingAnimationTracker
--- a/dom/animation/EffectCompositor.cpp
+++ b/dom/animation/EffectCompositor.cpp
@@ -19,17 +19,17 @@
#include "mozilla/AutoRestore.h"
#include "mozilla/ComputedStyleInlines.h"
#include "mozilla/EffectSet.h"
#include "mozilla/LayerAnimationInfo.h"
#include "mozilla/RestyleManager.h"
#include "mozilla/ServoBindings.h" // Servo_GetProperties_Overriding_Animation
#include "mozilla/ServoStyleSet.h"
#include "mozilla/StyleAnimationValue.h"
-#include "mozilla/TypeTraits.h" // For Forward<>
+#include "mozilla/TypeTraits.h" // For std::forward<>
#include "nsContentUtils.h"
#include "nsCSSPseudoElements.h"
#include "nsCSSPropertyIDSet.h"
#include "nsCSSProps.h"
#include "nsAtom.h"
#include "nsIPresShell.h"
#include "nsIPresShellInlines.h"
#include "nsLayoutUtils.h"
--- a/dom/bindings/BindingDeclarations.h
+++ b/dom/bindings/BindingDeclarations.h
@@ -173,17 +173,17 @@ public:
{
return mImpl.isSome();
}
// Return InternalType here so we can work with it usefully.
template<typename... Args>
InternalType& Construct(Args&&... aArgs)
{
- mImpl.emplace(Forward<Args>(aArgs)...);
+ mImpl.emplace(std::forward<Args>(aArgs)...);
return *mImpl;
}
void Reset()
{
mImpl.reset();
}
--- a/dom/bindings/ErrorResult.h
+++ b/dom/bindings/ErrorResult.h
@@ -73,17 +73,17 @@ namespace binding_detail {
void ThrowErrorMessage(JSContext* aCx, const unsigned aErrorNumber, ...);
} // namespace binding_detail
template<typename... Ts>
inline bool
ThrowErrorMessage(JSContext* aCx, const ErrNum aErrorNumber, Ts&&... aArgs)
{
binding_detail::ThrowErrorMessage(aCx, static_cast<unsigned>(aErrorNumber),
- mozilla::Forward<Ts>(aArgs)...);
+ std::forward<Ts>(aArgs)...);
return false;
}
struct StringArrayAppender
{
static void Append(nsTArray<nsString>& aArgs, uint16_t aCount)
{
MOZ_RELEASE_ASSERT(aCount == 0, "Must give at least as many string arguments as are required by the ErrNum.");
@@ -92,17 +92,17 @@ struct StringArrayAppender
template<typename... Ts>
static void Append(nsTArray<nsString>& aArgs, uint16_t aCount, const nsAString& aFirst, Ts&&... aOtherArgs)
{
if (aCount == 0) {
MOZ_ASSERT(false, "There should not be more string arguments provided than are required by the ErrNum.");
return;
}
aArgs.AppendElement(aFirst);
- Append(aArgs, aCount - 1, Forward<Ts>(aOtherArgs)...);
+ Append(aArgs, aCount - 1, std::forward<Ts>(aOtherArgs)...);
}
};
} // namespace dom
class ErrorResult;
class OOMReporter;
@@ -288,24 +288,24 @@ public:
// When this function returns, JS_IsExceptionPending(cx) will definitely be
// false.
void StealExceptionFromJSContext(JSContext* cx);
template<dom::ErrNum errorNumber, typename... Ts>
void ThrowTypeError(Ts&&... messageArgs)
{
ThrowErrorWithMessage<errorNumber>(NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR,
- Forward<Ts>(messageArgs)...);
+ std::forward<Ts>(messageArgs)...);
}
template<dom::ErrNum errorNumber, typename... Ts>
void ThrowRangeError(Ts&&... messageArgs)
{
ThrowErrorWithMessage<errorNumber>(NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR,
- Forward<Ts>(messageArgs)...);
+ std::forward<Ts>(messageArgs)...);
}
bool IsErrorWithMessage() const
{
return ErrorCode() == NS_ERROR_INTERNAL_ERRORRESULT_TYPEERROR ||
ErrorCode() == NS_ERROR_INTERNAL_ERRORRESULT_RANGEERROR;
}
@@ -429,17 +429,17 @@ private:
"Pass in the right number of arguments");
#endif
ClearUnionData();
nsTArray<nsString>& messageArgsArray = CreateErrorMessageHelper(errorNumber, errorType);
uint16_t argCount = dom::GetErrorArgCount(errorNumber);
dom::StringArrayAppender::Append(messageArgsArray, argCount,
- Forward<Ts>(messageArgs)...);
+ std::forward<Ts>(messageArgs)...);
#ifdef DEBUG
mUnionState = HasMessage;
#endif // DEBUG
}
MOZ_ALWAYS_INLINE void AssertInOwningThread() const {
#ifdef DEBUG
if (CleanupPolicy::assertSameThread) {
--- a/dom/clients/manager/ClientManagerOpParent.cpp
+++ b/dom/clients/manager/ClientManagerOpParent.cpp
@@ -15,17 +15,17 @@ namespace dom {
using mozilla::ipc::BackgroundParent;
template <typename Method, typename... Args>
void
ClientManagerOpParent::DoServiceOp(Method aMethod, Args&&... aArgs)
{
// Note, we need perfect forarding of the template type in order
// to allow already_AddRefed<> to be passed as an arg.
- RefPtr<ClientOpPromise> p = (mService->*aMethod)(Forward<Args>(aArgs)...);
+ RefPtr<ClientOpPromise> p = (mService->*aMethod)(std::forward<Args>(aArgs)...);
// Capturing `this` is safe here because we disconnect the promise in
// ActorDestroy() which ensures neither lambda is called if the actor
// is destroyed before the source operation completes.
p->Then(GetCurrentThreadSerialEventTarget(), __func__,
[this] (const mozilla::dom::ClientOpResult& aResult) {
mPromiseRequestHolder.Complete();
Unused << PClientManagerOpParent::Send__delete__(this, aResult);
--- a/dom/console/nsIConsoleReportCollector.h
+++ b/dom/console/nsIConsoleReportCollector.h
@@ -56,17 +56,17 @@ public:
AddConsoleReport(uint32_t aErrorFlags, const nsACString& aCategory,
nsContentUtils::PropertiesFile aPropertiesFile,
const nsACString& aSourceFileURI, uint32_t aLineNumber,
uint32_t aColumnNumber, const nsACString& aMessageName,
Params&&... aParams)
{
nsTArray<nsString> params;
mozilla::dom::StringArrayAppender::Append(params, sizeof...(Params),
- mozilla::Forward<Params>(aParams)...);
+ std::forward<Params>(aParams)...);
AddConsoleReport(aErrorFlags, aCategory, aPropertiesFile, aSourceFileURI,
aLineNumber, aColumnNumber, aMessageName, params);
}
// An enum calss to indicate whether should free the pending reports or not.
// Forget Free the pending reports.
// Save Keep the pending reports.
enum class ReportAction {
--- a/dom/html/HTMLMediaElement.cpp
+++ b/dom/html/HTMLMediaElement.cpp
@@ -4850,17 +4850,17 @@ nsresult
HTMLMediaElement::SetupDecoder(DecoderType* aDecoder, LoadArgs&&... aArgs)
{
LOG(LogLevel::Debug,
("%p Created decoder %p for type %s",
this,
aDecoder,
aDecoder->ContainerType().OriginalString().Data()));
- nsresult rv = aDecoder->Load(Forward<LoadArgs>(aArgs)...);
+ nsresult rv = aDecoder->Load(std::forward<LoadArgs>(aArgs)...);
if (NS_FAILED(rv)) {
aDecoder->Shutdown();
LOG(LogLevel::Debug, ("%p Failed to load for decoder %p", this, aDecoder));
return rv;
}
rv = FinishDecoderSetup(aDecoder);
// Only ChannelMediaDecoder supports resource cloning.
--- a/dom/media/AudioStream.cpp
+++ b/dom/media/AudioStream.cpp
@@ -326,17 +326,17 @@ template <>
struct ToCubebFormat<AUDIO_FORMAT_S16> {
static const cubeb_sample_format value = CUBEB_SAMPLE_S16NE;
};
template <typename Function, typename... Args>
int AudioStream::InvokeCubeb(Function aFunction, Args&&... aArgs)
{
MonitorAutoUnlock mon(mMonitor);
- return aFunction(mCubebStream.get(), Forward<Args>(aArgs)...);
+ return aFunction(mCubebStream.get(), std::forward<Args>(aArgs)...);
}
nsresult
AudioStream::Init(uint32_t aNumChannels,
AudioConfig::ChannelLayout::ChannelMap aChannelMap,
uint32_t aRate)
{
auto startTime = TimeStamp::Now();
--- a/dom/media/Intervals.h
+++ b/dom/media/Intervals.h
@@ -44,28 +44,28 @@ public:
Interval()
: mStart(T())
, mEnd(T())
, mFuzz(T())
{ }
template<typename StartArg, typename EndArg>
Interval(StartArg&& aStart, EndArg&& aEnd)
- : mStart(Forward<StartArg>(aStart))
- , mEnd(Forward<EndArg>(aEnd))
+ : mStart(std::forward<StartArg>(aStart))
+ , mEnd(std::forward<EndArg>(aEnd))
, mFuzz()
{
MOZ_ASSERT(aStart <= aEnd);
}
template<typename StartArg, typename EndArg, typename FuzzArg>
Interval(StartArg&& aStart, EndArg&& aEnd, FuzzArg&& aFuzz)
- : mStart(Forward<StartArg>(aStart))
- , mEnd(Forward<EndArg>(aEnd))
- , mFuzz(Forward<FuzzArg>(aFuzz))
+ : mStart(std::forward<StartArg>(aStart))
+ , mEnd(std::forward<EndArg>(aEnd))
+ , mFuzz(std::forward<FuzzArg>(aFuzz))
{
MOZ_ASSERT(aStart <= aEnd);
}
Interval(const SelfType& aOther)
: mStart(aOther.mStart)
, mEnd(aOther.mEnd)
, mFuzz(aOther.mFuzz)
--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -270,17 +270,17 @@ protected:
-> decltype(ReturnTypeHelper(&S::Enter))
{
// |aArgs| must be passed by reference to avoid passing MOZ_NON_PARAM class
// SeekJob by value. See bug 1287006 and bug 1338374. But we still *must*
// copy the parameters, because |Exit()| can modify them. See bug 1312321.
// So we 1) pass the parameters by reference, but then 2) immediately copy
// them into a Tuple to be safe against modification, and finally 3) move
// the elements of the Tuple into the final function call.
- auto copiedArgs = MakeTuple(Forward<Ts>(aArgs)...);
+ auto copiedArgs = MakeTuple(std::forward<Ts>(aArgs)...);
// Copy mMaster which will reset to null.
auto master = mMaster;
auto* s = new S(master);
MOZ_ASSERT(GetState() != s->GetState() ||
GetState() == DECODER_STATE_SEEKING);
--- a/dom/media/MediaDecoderStateMachine.h
+++ b/dom/media/MediaDecoderStateMachine.h
@@ -140,17 +140,17 @@ struct MediaPlaybackEvent
: mType(aType)
, mData(Nothing{})
{
}
template<typename T>
MediaPlaybackEvent(EventType aType, T&& aArg)
: mType(aType)
- , mData(Forward<T>(aArg))
+ , mData(std::forward<T>(aArg))
{
}
};
enum class VideoDecodeMode : uint8_t
{
Normal,
Suspend
--- a/dom/media/MediaEventSource.h
+++ b/dom/media/MediaEventSource.h
@@ -133,17 +133,17 @@ public:
template <typename... Ts>
void Dispatch(Ts&&... aEvents)
{
if (CanTakeArgs()) {
DispatchTask(NewRunnableMethod<typename Decay<Ts>::Type&&...>(
"detail::Listener::ApplyWithArgs",
this,
&Listener::ApplyWithArgs,
- Forward<Ts>(aEvents)...));
+ std::forward<Ts>(aEvents)...));
} else {
DispatchTask(NewRunnableMethod(
"detail::Listener::ApplyWithNoArgs", this, &Listener::ApplyWithNoArgs));
}
}
protected:
virtual ~Listener()
@@ -173,17 +173,17 @@ class ListenerImpl : public Listener<As.
{
// Strip CV and reference from Function.
using FunctionStorage = typename Decay<Function>::Type;
public:
template <typename F>
ListenerImpl(Target* aTarget, F&& aFunction)
: mTarget(aTarget)
- , mFunction(Forward<F>(aFunction))
+ , mFunction(std::forward<F>(aFunction))
{
}
private:
void DispatchTask(already_AddRefed<nsIRunnable> aTask) override
{
EventTarget<Target>::Dispatch(mTarget.get(), std::move(aTask));
}
@@ -340,17 +340,17 @@ class MediaEventSourceImpl {
template<typename Target, typename Function>
MediaEventListener
ConnectInternal(Target* aTarget, Function&& aFunction) {
MutexAutoLock lock(mMutex);
PruneListeners();
MOZ_ASSERT(Lp == ListenerPolicy::NonExclusive || mListeners.IsEmpty());
auto l = mListeners.AppendElement();
*l = new ListenerImpl<Target, Function>(
- aTarget, Forward<Function>(aFunction));
+ aTarget, std::forward<Function>(aFunction));
return MediaEventListener(*l);
}
// |Method| takes one or more arguments.
template <typename Target, typename This, typename Method>
typename EnableIf<TakeArgs<Method>::value, MediaEventListener>::Type
ConnectInternal(Target* aTarget, This* aThis, Method aMethod) {
detail::RawPtr<This> thiz(aThis);
@@ -378,23 +378,23 @@ public:
* @param aTarget The target thread on which the function will run.
* @param aFunction A function to be called on the target thread. The function
* parameter must be convertible from |EventType|.
* @return An object used to disconnect from the event source.
*/
template<typename Function>
MediaEventListener
Connect(AbstractThread* aTarget, Function&& aFunction) {
- return ConnectInternal(aTarget, Forward<Function>(aFunction));
+ return ConnectInternal(aTarget, std::forward<Function>(aFunction));
}
template<typename Function>
MediaEventListener
Connect(nsIEventTarget* aTarget, Function&& aFunction) {
- return ConnectInternal(aTarget, Forward<Function>(aFunction));
+ return ConnectInternal(aTarget, std::forward<Function>(aFunction));
}
/**
* As above.
*
* Note we deliberately keep a weak reference to |aThis| in order not to
* change its lifetime. This is because notifications are dispatched
* asynchronously and removing a listener doesn't always break the reference
@@ -425,17 +425,17 @@ protected:
for (int32_t i = last; i >= 0; --i) {
auto&& l = mListeners[i];
// Remove disconnected listeners.
// It is not optimal but is simple and works well.
if (l->IsRevoked()) {
mListeners.RemoveElementAt(i);
continue;
}
- l->Dispatch(Forward<Ts>(aEvents)...);
+ l->Dispatch(std::forward<Ts>(aEvents)...);
}
}
private:
Mutex mMutex;
nsTArray<RefPtr<Listener>> mListeners;
};
@@ -477,15 +477,15 @@ public:
/**
* A producer allowing at most one listener.
*/
template <typename... Es>
class MediaEventProducerExc : public MediaEventSourceExc<Es...> {
public:
template <typename... Ts>
void Notify(Ts&&... aEvents) {
- this->NotifyInternal(Forward<Ts>(aEvents)...);
+ this->NotifyInternal(std::forward<Ts>(aEvents)...);
}
};
} // namespace mozilla
#endif //MediaEventSource_h_
--- a/dom/media/MediaInfo.h
+++ b/dom/media/MediaInfo.h
@@ -431,17 +431,17 @@ public:
{
}
struct InitData
{
template<typename AInitDatas>
InitData(const nsAString& aType, AInitDatas&& aInitData)
: mType(aType)
- , mInitData(Forward<AInitDatas>(aInitData))
+ , mInitData(std::forward<AInitDatas>(aInitData))
{
}
// Encryption type to be passed to JS. Usually `cenc'.
nsString mType;
// Encryption data.
nsTArray<uint8_t> mInitData;
@@ -458,17 +458,17 @@ public:
{
mEncrypted = false;
mInitDatas.Clear();
}
template<typename AInitDatas>
void AddInitData(const nsAString& aType, AInitDatas&& aInitData)
{
- mInitDatas.AppendElement(InitData(aType, Forward<AInitDatas>(aInitData)));
+ mInitDatas.AppendElement(InitData(aType, std::forward<AInitDatas>(aInitData)));
mEncrypted = true;
}
void AddInitData(const EncryptionInfo& aInfo)
{
mInitDatas.AppendElements(aInfo.mInitDatas);
mEncrypted = !!mInitDatas.Length();
}
--- a/dom/media/MediaManager.cpp
+++ b/dom/media/MediaManager.cpp
@@ -2238,17 +2238,17 @@ MediaManager::PostTask(already_AddRefed<
template<typename MozPromiseType, typename FunctionType>
/* static */ RefPtr<MozPromiseType>
MediaManager::PostTask(const char* aName, FunctionType&& aFunction)
{
MozPromiseHolder<MozPromiseType> holder;
RefPtr<MozPromiseType> promise = holder.Ensure(aName);
MediaManager::PostTask(NS_NewRunnableFunction(aName,
- [h = std::move(holder), func = Forward<FunctionType>(aFunction)]() mutable
+ [h = std::move(holder), func = std::forward<FunctionType>(aFunction)]() mutable
{
func(h);
}));
return promise;
}
/* static */ nsresult
MediaManager::NotifyRecordingStatusChange(nsPIDOMWindowInner* aWindow)
--- a/dom/media/MediaSegment.h
+++ b/dom/media/MediaSegment.h
@@ -150,17 +150,17 @@ public:
*/
const PrincipalHandle& GetLastPrincipalHandle() const { return mLastPrincipalHandle; }
/**
* Called by the MediaStreamGraph as it appends a chunk with a different
* principal id than the current one.
*/
void SetLastPrincipalHandle(PrincipalHandle aLastPrincipalHandle)
{
- mLastPrincipalHandle = Forward<PrincipalHandle>(aLastPrincipalHandle);
+ mLastPrincipalHandle = std::forward<PrincipalHandle>(aLastPrincipalHandle);
}
/**
* Returns true if all chunks in this segment are null.
*/
virtual bool IsNull() const = 0;
/**
--- a/dom/media/MediaTimer.h
+++ b/dom/media/MediaTimer.h
@@ -148,18 +148,18 @@ public:
MOZ_ASSERT(mTargetThread->IsCurrentThreadIn());
if (IsScheduled() && mTarget <= aTarget) {
return;
}
Reset();
mTarget = aTarget;
mMediaTimer->WaitUntil(mTarget, __func__)->Then(
mTargetThread, __func__,
- Forward<ResolveFunc>(aResolver),
- Forward<RejectFunc>(aRejector))
+ std::forward<ResolveFunc>(aResolver),
+ std::forward<RejectFunc>(aRejector))
->Track(mRequest);
}
void CompleteRequest()
{
MOZ_ASSERT(mTargetThread->IsCurrentThreadIn());
mRequest.Complete();
mTarget = TimeStamp();
--- a/dom/media/VideoSegment.h
+++ b/dom/media/VideoSegment.h
@@ -37,17 +37,17 @@ public:
return !operator==(aFrame);
}
Image* GetImage() const { return mImage; }
void SetForceBlack(bool aForceBlack) { mForceBlack = aForceBlack; }
bool GetForceBlack() const { return mForceBlack; }
void SetPrincipalHandle(PrincipalHandle aPrincipalHandle)
{
- mPrincipalHandle = Forward<PrincipalHandle>(aPrincipalHandle);
+ mPrincipalHandle = std::forward<PrincipalHandle>(aPrincipalHandle);
}
const PrincipalHandle& GetPrincipalHandle() const { return mPrincipalHandle; }
const gfx::IntSize& GetIntrinsicSize() const { return mIntrinsicSize; }
void SetNull();
void TakeFrom(VideoFrame* aFrame);
// Create a planar YCbCr black image.
static already_AddRefed<Image> CreateBlackImage(const gfx::IntSize& aSize);
--- a/dom/media/doctor/DecoderDoctorLogger.h
+++ b/dom/media/doctor/DecoderDoctorLogger.h
@@ -82,30 +82,30 @@ public:
DDLogCategory aCategory,
const char* aLabel,
Value&& aValue)
{
Log(aSubjectTypeName,
aSubjectPointer,
aCategory,
aLabel,
- DDLogValue{ Forward<Value>(aValue) });
+ DDLogValue{ std::forward<Value>(aValue) });
}
template<typename Subject, typename Value>
static void EagerLogValue(const Subject* aSubject,
DDLogCategory aCategory,
const char* aLabel,
Value&& aValue)
{
EagerLogValue(DDLoggedTypeTraits<Subject>::Name(),
aSubject,
aCategory,
aLabel,
- Forward<Value>(aValue));
+ std::forward<Value>(aValue));
}
// EagerLogValue that can explicitly take strings, as the templated function
// above confuses Variant when forwarding string literals.
static void EagerLogValue(const char* aSubjectTypeName,
const void* aSubjectPointer,
DDLogCategory aCategory,
const char* aLabel,
@@ -149,17 +149,17 @@ public:
const char* aFormat,
Args&&... aArgs)
{
Log(aSubjectTypeName,
aSubjectPointer,
aCategory,
aLabel,
DDLogValue{
- nsCString{ nsPrintfCString(aFormat, Forward<Args>(aArgs)...) } });
+ nsCString{ nsPrintfCString(aFormat, std::forward<Args>(aArgs)...) } });
}
template<typename Subject>
static void EagerLogPrintf(const Subject* aSubject,
DDLogCategory aCategory,
const char* aLabel,
const char* aString)
{
@@ -177,17 +177,17 @@ public:
const char* aFormat,
Args&&... aArgs)
{
EagerLogPrintf(DDLoggedTypeTraits<Subject>::Name(),
aSubject,
aCategory,
aLabel,
aFormat,
- Forward<Args>(aArgs)...);
+ std::forward<Args>(aArgs)...);
}
static void MozLogPrintf(const char* aSubjectTypeName,
const void* aSubjectPointer,
const LogModule* aLogModule,
LogLevel aLogLevel,
const char* aString)
{
@@ -204,17 +204,17 @@ public:
template<typename... Args>
static void MozLogPrintf(const char* aSubjectTypeName,
const void* aSubjectPointer,
const LogModule* aLogModule,
LogLevel aLogLevel,
const char* aFormat,
Args&&... aArgs)
{
- nsCString printed = nsPrintfCString(aFormat, Forward<Args>(aArgs)...);
+ nsCString printed = nsPrintfCString(aFormat, std::forward<Args>(aArgs)...);
Log(aSubjectTypeName,
aSubjectPointer,
CategoryForMozLogLevel(aLogLevel),
aLogModule->Name(), // LogModule name as label.
DDLogValue{ printed });
MOZ_LOG(aLogModule,
aLogLevel,
("%s[%p] %s", aSubjectTypeName, aSubjectPointer, printed.get()));
@@ -240,17 +240,17 @@ public:
const char* aFormat,
Args&&... aArgs)
{
MozLogPrintf(DDLoggedTypeTraits<Subject>::Name(),
aSubject,
aLogModule,
aLogLevel,
aFormat,
- Forward<Args>(aArgs)...);
+ std::forward<Args>(aArgs)...);
}
// Special logging functions. Consider using DecoderDoctorLifeLogger to
// automatically capture constructions & destructions.
static void LogConstruction(const char* aSubjectTypeName,
const void* aSubjectPointer)
{
--- a/dom/media/gmp/ChromiumCDMCallbackProxy.cpp
+++ b/dom/media/gmp/ChromiumCDMCallbackProxy.cpp
@@ -16,17 +16,17 @@ void ChromiumCDMCallbackProxy::DispatchT
Args&&... aArgs)
{
mMainThread->Dispatch(
// Use Decay to ensure all the types are passed by value not by reference.
NewRunnableMethod<typename Decay<Args>::Type...>(
aLabel,
mProxy,
aFunc,
- Forward<Args>(aArgs)...),
+ std::forward<Args>(aArgs)...),
NS_DISPATCH_NORMAL);
}
void
ChromiumCDMCallbackProxy::SetSessionId(uint32_t aPromiseId,
const nsCString& aSessionId)
{
DispatchToMainThread("ChromiumCDMProxy::OnSetSessionId",
--- a/dom/media/gmp/ChromiumCDMChild.cpp
+++ b/dom/media/gmp/ChromiumCDMChild.cpp
@@ -192,39 +192,39 @@ ChromiumCDMChild::GetCurrentWallTime()
template <typename MethodType, typename... ParamType>
void
ChromiumCDMChild::CallMethod(MethodType aMethod, ParamType&&... aParams)
{
MOZ_ASSERT(IsOnMessageLoopThread());
// Avoid calling member function after destroy.
if (!mDestroyed) {
- Unused << (this->*aMethod)(Forward<ParamType>(aParams)...);
+ Unused << (this->*aMethod)(std::forward<ParamType>(aParams)...);
}
}
template<typename MethodType, typename... ParamType>
void
ChromiumCDMChild::CallOnMessageLoopThread(const char* const aName,
MethodType aMethod,
ParamType&&... aParams)
{
if (IsOnMessageLoopThread()) {
- CallMethod(aMethod, Forward<ParamType>(aParams)...);
+ CallMethod(aMethod, std::forward<ParamType>(aParams)...);
} else {
auto m = &ChromiumCDMChild::CallMethod<
decltype(aMethod), const typename RemoveReference<ParamType>::Type&...>;
RefPtr<mozilla::Runnable> t =
NewRunnableMethod<decltype(aMethod),
const typename RemoveReference<ParamType>::Type...>(
aName,
this,
m,
aMethod,
- Forward<ParamType>(aParams)...);
+ std::forward<ParamType>(aParams)...);
mPlugin->GMPMessageLoop()->PostTask(t.forget());
}
}
// cdm::Host_9 interface
void
ChromiumCDMChild::OnResolveKeyStatusPromise(uint32_t aPromiseId,
cdm::KeyStatus aKeyStatus) {
--- a/dom/media/mp4/MP4Metadata.h
+++ b/dom/media/mp4/MP4Metadata.h
@@ -62,17 +62,17 @@ public:
// Simple template class containing a MediaResult and another type.
template <typename T>
class ResultAndType
{
public:
template <typename M2, typename T2>
ResultAndType(M2&& aM, T2&& aT)
- : mResult(Forward<M2>(aM)), mT(Forward<T2>(aT))
+ : mResult(std::forward<M2>(aM)), mT(std::forward<T2>(aT))
{
}
ResultAndType(const ResultAndType&) = default;
ResultAndType& operator=(const ResultAndType&) = default;
ResultAndType(ResultAndType&&) = default;
ResultAndType& operator=(ResultAndType&&) = default;
mozilla::MediaResult& Result() { return mResult; }
--- a/dom/media/platforms/PDMFactory.cpp
+++ b/dom/media/platforms/PDMFactory.cpp
@@ -108,17 +108,17 @@ public:
Reason mReason;
MediaResult mMediaResult;
};
template<class Func>
void
AddToCheckList(Func&& aChecker)
{
- mCheckerList.AppendElement(mozilla::Forward<Func>(aChecker));
+ mCheckerList.AppendElement(std::forward<Func>(aChecker));
}
void
AddMediaFormatChecker(const TrackInfo& aTrackConfig)
{
if (aTrackConfig.IsVideo()) {
auto mimeType = aTrackConfig.GetAsVideoInfo()->mMimeType;
RefPtr<MediaByteBuffer> extraData =
--- a/dom/media/platforms/PlatformDecoderModule.h
+++ b/dom/media/platforms/PlatformDecoderModule.h
@@ -66,17 +66,17 @@ struct MOZ_STACK_CLASS CreateDecoderPara
explicit VideoFrameRate(float aFramerate) : mValue(aFramerate) { }
float mValue = 0.0f;
};
template <typename T1, typename... Ts>
CreateDecoderParams(const TrackInfo& aConfig, T1&& a1, Ts&&... args)
: mConfig(aConfig)
{
- Set(mozilla::Forward<T1>(a1), mozilla::Forward<Ts>(args)...);
+ Set(std::forward<T1>(a1), std::forward<Ts>(args)...);
}
const VideoInfo& VideoConfig() const
{
MOZ_ASSERT(mConfig.IsVideo());
return *mConfig.GetAsVideoInfo();
}
@@ -135,18 +135,18 @@ private:
}
void Set(MediaEventProducer<TrackInfo::TrackType>* aOnWaitingForKey)
{
mOnWaitingForKeyEvent = aOnWaitingForKey;
}
template <typename T1, typename T2, typename... Ts>
void Set(T1&& a1, T2&& a2, Ts&&... args)
{
- Set(mozilla::Forward<T1>(a1));
- Set(mozilla::Forward<T2>(a2), mozilla::Forward<Ts>(args)...);
+ Set(std::forward<T1>(a1));
+ Set(std::forward<T2>(a2), std::forward<Ts>(args)...);
}
};
// The PlatformDecoderModule interface is used by the MediaFormatReader to
// abstract access to decoders provided by various
// platforms.
// Each platform (Windows, MacOSX, Linux, B2G etc) must implement a
// PlatformDecoderModule to provide access to its decoders in order to get
--- a/dom/media/systemservices/CamerasChild.h
+++ b/dom/media/systemservices/CamerasChild.h
@@ -137,17 +137,17 @@ void Shutdown(void);
// Obtain the CamerasChild object (if possible, i.e. not shutting down),
// and maintain a grip on the object for the duration of the call.
template <class MEM_FUN, class... ARGS>
int GetChildAndCall(MEM_FUN&& f, ARGS&&... args)
{
OffTheBooksMutexAutoLock lock(CamerasSingleton::Mutex());
CamerasChild* child = GetCamerasChild();
if (child) {
- return (child->*f)(mozilla::Forward<ARGS>(args)...);
+ return (child->*f)(std::forward<ARGS>(args)...);
} else {
return -1;
}
}
class CamerasChild final : public PCamerasChild
,public DeviceChangeCallback
{
--- a/dom/media/systemservices/MediaTaskUtils.h
+++ b/dom/media/systemservices/MediaTaskUtils.h
@@ -40,16 +40,16 @@ private:
OnRunType mOnRun;
};
template<typename OnRunType>
already_AddRefed<LambdaTask<OnRunType>>
NewTaskFrom(OnRunType&& aOnRun)
{
typedef LambdaTask<OnRunType> LambdaType;
- RefPtr<LambdaType> lambda = new LambdaType(Forward<OnRunType>(aOnRun));
+ RefPtr<LambdaType> lambda = new LambdaType(std::forward<OnRunType>(aOnRun));
return lambda.forget();
}
} // namespace media
} // namespace mozilla
#endif // mozilla_MediaTaskUtils_h
--- a/dom/media/systemservices/MediaUtils.h
+++ b/dom/media/systemservices/MediaUtils.h
@@ -76,17 +76,17 @@ class Pledge : public PledgeBase
public:
explicit Pledge() : mDone(false), mRejected(false) {}
Pledge(const Pledge& aOther) = delete;
Pledge& operator = (const Pledge&) = delete;
template<typename OnSuccessType>
void Then(OnSuccessType&& aOnSuccess)
{
- Then(Forward<OnSuccessType>(aOnSuccess), [](ErrorType&){});
+ Then(std::forward<OnSuccessType>(aOnSuccess), [](ErrorType&){});
}
template<typename OnSuccessType, typename OnFailureType>
void Then(OnSuccessType&& aOnSuccess, OnFailureType&& aOnFailure)
{
class Functors : public FunctorsBase
{
public:
@@ -100,18 +100,18 @@ public:
void Fail(ErrorType& error)
{
mOnFailure(error);
};
OnSuccessType mOnSuccess;
OnFailureType mOnFailure;
};
- mFunctors = MakeUnique<Functors>(Forward<OnSuccessType>(aOnSuccess),
- Forward<OnFailureType>(aOnFailure));
+ mFunctors = MakeUnique<Functors>(std::forward<OnSuccessType>(aOnSuccess),
+ std::forward<OnFailureType>(aOnFailure));
if (mDone) {
if (!mRejected) {
mFunctors->Succeed(mValue);
} else {
mFunctors->Fail(mError);
}
}
}
@@ -211,17 +211,17 @@ private:
OnRunType mOnRun;
};
template<typename OnRunType>
already_AddRefed<LambdaRunnable<OnRunType>>
NewRunnableFrom(OnRunType&& aOnRun)
{
typedef LambdaRunnable<OnRunType> LambdaType;
- RefPtr<LambdaType> lambda = new LambdaType(Forward<OnRunType>(aOnRun));
+ RefPtr<LambdaType> lambda = new LambdaType(std::forward<OnRunType>(aOnRun));
return lambda.forget();
}
/* media::CoatCheck - There and back again. Park an object in exchange for an id.
*
* A common problem with calling asynchronous functions that do work on other
* threads or processes is how to pass in a heap object for use once the
* function completes, without requiring that object to have threadsafe
@@ -443,23 +443,23 @@ Await(
// We can't use a Monitor allocated on the stack (see bug 1426067)
Monitor& mon = taskQueue->Monitor();
bool done = false;
aPromise->Then(taskQueue,
__func__,
[&](ResolveValueType&& aResolveValue) {
MonitorAutoLock lock(mon);
- aResolveFunction(Forward<ResolveValueType>(aResolveValue));
+ aResolveFunction(std::forward<ResolveValueType>(aResolveValue));
done = true;
mon.Notify();
},
[&](RejectValueType&& aRejectValue) {
MonitorAutoLock lock(mon);
- aRejectFunction(Forward<RejectValueType>(aRejectValue));
+ aRejectFunction(std::forward<RejectValueType>(aRejectValue));
done = true;
mon.Notify();
});
MonitorAutoLock lock(mon);
while (!done) {
mon.Wait();
}
--- a/dom/media/webrtc/MediaEngineRemoteVideoSource.h
+++ b/dom/media/webrtc/MediaEngineRemoteVideoSource.h
@@ -66,17 +66,17 @@ enum DistanceCalculation {
class MediaEngineRemoteVideoSource : public MediaEngineSource,
public camera::FrameRelay
{
~MediaEngineRemoteVideoSource() = default;
struct CapabilityCandidate {
explicit CapabilityCandidate(webrtc::CaptureCapability&& aCapability,
uint32_t aDistance = 0)
- : mCapability(Forward<webrtc::CaptureCapability>(aCapability))
+ : mCapability(std::forward<webrtc::CaptureCapability>(aCapability))
, mDistance(aDistance) {}
const webrtc::CaptureCapability mCapability;
uint32_t mDistance;
};
class CapabilityComparator {
public:
--- a/dom/serviceworkers/ServiceWorkerEvents.cpp
+++ b/dom/serviceworkers/ServiceWorkerEvents.cpp
@@ -82,17 +82,17 @@ AsyncLog(nsIInterceptedChannel* aInterce
uint32_t aRespondWithLineNumber, uint32_t aRespondWithColumnNumber,
// We have to list one explicit string so that calls with an
// nsTArray of params won't end up in here.
const nsACString& aMessageName, const nsAString& aFirstParam,
Params&&... aParams)
{
nsTArray<nsString> paramsList(sizeof...(Params) + 1);
StringArrayAppender::Append(paramsList, sizeof...(Params) + 1,
- aFirstParam, Forward<Params>(aParams)...);
+ aFirstParam, std::forward<Params>(aParams)...);
AsyncLog(aInterceptedChannel, aRespondWithScriptSpec, aRespondWithLineNumber,
aRespondWithColumnNumber, aMessageName, paramsList);
}
} // anonymous namespace
namespace mozilla {
namespace dom {
@@ -554,17 +554,17 @@ public:
void SetCancelMessage(const nsACString& aMessageName, Params&&... aParams)
{
MOZ_ASSERT(mOwner);
MOZ_ASSERT(mMessageName.EqualsLiteral("InterceptionFailedWithURL"));
MOZ_ASSERT(mParams.Length() == 1);
mMessageName = aMessageName;
mParams.Clear();
StringArrayAppender::Append(mParams, sizeof...(Params),
- Forward<Params>(aParams)...);
+ std::forward<Params>(aParams)...);
}
template<typename... Params>
void SetCancelMessageAndLocation(const nsACString& aSourceSpec,
uint32_t aLine, uint32_t aColumn,
const nsACString& aMessageName,
Params&&... aParams)
{
@@ -574,17 +574,17 @@ public:
mSourceSpec = aSourceSpec;
mLine = aLine;
mColumn = aColumn;
mMessageName = aMessageName;
mParams.Clear();
StringArrayAppender::Append(mParams, sizeof...(Params),
- Forward<Params>(aParams)...);
+ std::forward<Params>(aParams)...);
}
void Reset()
{
mOwner = nullptr;
}
};
--- a/gfx/2d/DrawingJob.h
+++ b/gfx/2d/DrawingJob.h
@@ -69,17 +69,17 @@ public:
/// Build the CommandBuffer, command after command.
/// This must be used between BeginCommandBuffer and EndCommandBuffer.
template<typename T, typename... Args>
ptrdiff_t AddCommand(Args&&... aArgs)
{
static_assert(IsBaseOf<DrawingCommand, T>::value,
"T must derive from DrawingCommand");
- return mCommands->mStorage.Alloc<T>(Forward<Args>(aArgs)...);
+ return mCommands->mStorage.Alloc<T>(std::forward<Args>(aArgs)...);
}
bool HasCommands() const { return !!mCommands; }
protected:
RefPtr<CommandBuffer> mCommands;
};
--- a/gfx/2d/IterableArena.h
+++ b/gfx/2d/IterableArena.h
@@ -73,17 +73,17 @@ public:
ptrdiff_t
Alloc(Args&&... aArgs)
{
void* storage = nullptr;
auto offset = AllocRaw(sizeof(T), &storage);
if (offset < 0) {
return offset;
}
- new (storage) T(Forward<Args>(aArgs)...);
+ new (storage) T(std::forward<Args>(aArgs)...);
return offset;
}
ptrdiff_t AllocRaw(size_t aSize, void** aOutPtr = nullptr)
{
const size_t blocSize = AlignedSize(sizeof(Header) + aSize);
if (AlignedSize(mCursor + blocSize) > mSize) {
--- a/image/DecoderFactory.cpp
+++ b/image/DecoderFactory.cpp
@@ -305,17 +305,17 @@ DecoderFactory::CreateDecoderForICOResou
MOZ_ASSERT_UNREACHABLE("Invalid ICO resource decoder type");
return nullptr;
}
MOZ_ASSERT(decoder);
// Initialize the decoder, copying settings from @aICODecoder.
decoder->SetMetadataDecode(aIsMetadataDecode);
- decoder->SetIterator(Forward<SourceBufferIterator>(aIterator));
+ decoder->SetIterator(std::forward<SourceBufferIterator>(aIterator));
if (!aIsMetadataDecode) {
decoder->SetOutputSize(aICODecoder->OutputSize());
}
if (aExpectedSize) {
decoder->SetExpectedSize(*aExpectedSize);
}
decoder->SetDecoderFlags(aICODecoder->GetDecoderFlags());
decoder->SetSurfaceFlags(aICODecoder->GetSurfaceFlags());
--- a/image/SurfacePipe.h
+++ b/image/SurfacePipe.h
@@ -167,17 +167,17 @@ public:
* @return A WriteState value indicating the lambda generator's state.
* WritePixels() itself will return WriteState::FINISHED if writing
* has finished, regardless of the lambda's internal state.
*/
template <typename PixelType, typename Func>
WriteState WritePixels(Func aFunc)
{
Maybe<WriteState> result;
- while (!(result = DoWritePixelsToRow<PixelType>(Forward<Func>(aFunc)))) { }
+ while (!(result = DoWritePixelsToRow<PixelType>(std::forward<Func>(aFunc)))) { }
return *result;
}
/**
* Write pixels to the surface by calling a lambda which may write as many
* pixels as there is remaining to complete the row. It is not completely
* memory safe as it trusts the underlying decoder not to overrun the given
@@ -204,17 +204,17 @@ public:
* @return A WriteState value indicating the lambda generator's state.
* WritePixelBlocks() itself will return WriteState::FINISHED if
* writing has finished, regardless of the lambda's internal state.
*/
template <typename PixelType, typename Func>
WriteState WritePixelBlocks(Func aFunc)
{
Maybe<WriteState> result;
- while (!(result = DoWritePixelBlockToRow<PixelType>(Forward<Func>(aFunc)))) { }
+ while (!(result = DoWritePixelBlockToRow<PixelType>(std::forward<Func>(aFunc)))) { }
return *result;
}
/**
* A variant of WritePixels() that writes a single row of pixels to the
* surface one at a time by repeatedly calling a lambda that yields pixels.
* WritePixelsToRow() is completely memory safe.
@@ -241,17 +241,17 @@ public:
* WritePixels() itself will return WriteState::FINISHED if writing
* the entire surface has finished, or WriteState::NEED_MORE_DATA if
* writing the row has finished, regardless of the lambda's internal
* state.
*/
template <typename PixelType, typename Func>
WriteState WritePixelsToRow(Func aFunc)
{
- return DoWritePixelsToRow<PixelType>(Forward<Func>(aFunc))
+ return DoWritePixelsToRow<PixelType>(std::forward<Func>(aFunc))
.valueOr(WriteState::NEED_MORE_DATA);
}
/**
* Write a row to the surface by copying from a buffer. This is bounds checked
* and memory safe with respect to the surface, but care must still be taken
* by the caller not to overread the source buffer. This variant of
* WriteBuffer() requires a source buffer which contains |mInputSize.width|
@@ -634,45 +634,45 @@ public:
* that yields pixels. WritePixels() is completely memory safe.
*
* @see SurfaceFilter::WritePixels() for the canonical documentation.
*/
template <typename PixelType, typename Func>
WriteState WritePixels(Func aFunc)
{
MOZ_ASSERT(mHead, "Use before configured!");
- return mHead->WritePixels<PixelType>(Forward<Func>(aFunc));
+ return mHead->WritePixels<PixelType>(std::forward<Func>(aFunc));
}
/**
* A variant of WritePixels() that writes up to a single row of pixels to the
* surface in blocks by repeatedly calling a lambda that yields up to the
* requested number of pixels.
*
* @see SurfaceFilter::WritePixelBlocks() for the canonical documentation.
*/
template <typename PixelType, typename Func>
WriteState WritePixelBlocks(Func aFunc)
{
MOZ_ASSERT(mHead, "Use before configured!");
- return mHead->WritePixelBlocks<PixelType>(Forward<Func>(aFunc));
+ return mHead->WritePixelBlocks<PixelType>(std::forward<Func>(aFunc));
}
/**
* A variant of WritePixels() that writes a single row of pixels to the
* surface one at a time by repeatedly calling a lambda that yields pixels.
* WritePixelsToRow() is completely memory safe.
*
* @see SurfaceFilter::WritePixelsToRow() for the canonical documentation.
*/
template <typename PixelType, typename Func>
WriteState WritePixelsToRow(Func aFunc)
{
MOZ_ASSERT(mHead, "Use before configured!");
- return mHead->WritePixelsToRow<PixelType>(Forward<Func>(aFunc));
+ return mHead->WritePixelsToRow<PixelType>(std::forward<Func>(aFunc));
}
/**
* Write a row to the surface by copying from a buffer. This is bounds checked
* and memory safe with respect to the surface, but care must still be taken
* by the caller not to overread the source buffer. This variant of
* WriteBuffer() requires a source buffer which contains |mInputSize.width|
* pixels.
--- a/image/test/gtest/TestADAM7InterpolatingFilter.cpp
+++ b/image/test/gtest/TestADAM7InterpolatingFilter.cpp
@@ -26,17 +26,17 @@ using std::generate;
using std::vector;
template <typename Func> void
WithADAM7InterpolatingFilter(const IntSize& aSize, Func aFunc)
{
RefPtr<Decoder> decoder = CreateTrivialDecoder();
ASSERT_TRUE(bool(decoder));
- WithFilterPipeline(decoder, Forward<Func>(aFunc),
+ WithFilterPipeline(decoder, std::forward<Func>(aFunc),
ADAM7InterpolatingConfig { },
SurfaceConfig { decoder, aSize,
SurfaceFormat::B8G8R8A8, false });
}
void
AssertConfiguringADAM7InterpolatingFilterFails(const IntSize& aSize)
{
--- a/image/test/gtest/TestDeinterlacingFilter.cpp
+++ b/image/test/gtest/TestDeinterlacingFilter.cpp
@@ -21,30 +21,30 @@ using namespace mozilla::image;
template <typename Func> void
WithDeinterlacingFilter(const IntSize& aSize,
bool aProgressiveDisplay,
Func aFunc)
{
RefPtr<Decoder> decoder = CreateTrivialDecoder();
ASSERT_TRUE(bool(decoder));
- WithFilterPipeline(decoder, Forward<Func>(aFunc),
+ WithFilterPipeline(decoder, std::forward<Func>(aFunc),
DeinterlacingConfig<uint32_t> { aProgressiveDisplay },
SurfaceConfig { decoder, aSize,
SurfaceFormat::B8G8R8A8, false });
}
template <typename Func> void
WithPalettedDeinterlacingFilter(const IntSize& aSize,
Func aFunc)
{
RefPtr<Decoder> decoder = CreateTrivialDecoder();
ASSERT_TRUE(decoder != nullptr);
- WithFilterPipeline(decoder, Forward<Func>(aFunc),
+ WithFilterPipeline(decoder, std::forward<Func>(aFunc),
DeinterlacingConfig<uint8_t> { /* mProgressiveDisplay = */ true },
PalettedSurfaceConfig { decoder, aSize,
IntRect(0, 0, 100, 100),
SurfaceFormat::B8G8R8A8, 8,
false });
}
void
--- a/image/test/gtest/TestDownscalingFilter.cpp
+++ b/image/test/gtest/TestDownscalingFilter.cpp
@@ -21,17 +21,17 @@ using namespace mozilla::image;
template <typename Func> void
WithDownscalingFilter(const IntSize& aInputSize,
const IntSize& aOutputSize,
Func aFunc)
{
RefPtr<Decoder> decoder = CreateTrivialDecoder();
ASSERT_TRUE(decoder != nullptr);
- WithFilterPipeline(decoder, Forward<Func>(aFunc),
+ WithFilterPipeline(decoder, std::forward<Func>(aFunc),
DownscalingConfig { aInputSize,
SurfaceFormat::B8G8R8A8 },
SurfaceConfig { decoder, aOutputSize,
SurfaceFormat::B8G8R8A8, false });
}
void
AssertConfiguringDownscalingFilterFails(const IntSize& aInputSize,
--- a/image/test/gtest/TestRemoveFrameRectFilter.cpp
+++ b/image/test/gtest/TestRemoveFrameRectFilter.cpp
@@ -21,17 +21,17 @@ using namespace mozilla::image;
template <typename Func> void
WithRemoveFrameRectFilter(const IntSize& aSize,
const IntRect& aFrameRect,
Func aFunc)
{
RefPtr<Decoder> decoder = CreateTrivialDecoder();
ASSERT_TRUE(decoder != nullptr);
- WithFilterPipeline(decoder, Forward<Func>(aFunc),
+ WithFilterPipeline(decoder, std::forward<Func>(aFunc),
RemoveFrameRectConfig { aFrameRect },
SurfaceConfig { decoder, aSize,
SurfaceFormat::B8G8R8A8, false });
}
void
AssertConfiguringRemoveFrameRectFilterFails(const IntSize& aSize,
const IntRect& aFrameRect)
--- a/image/test/gtest/TestSurfaceSink.cpp
+++ b/image/test/gtest/TestSurfaceSink.cpp
@@ -26,28 +26,28 @@ enum class Orient
template <Orient Orientation, typename Func> void
WithSurfaceSink(Func aFunc)
{
RefPtr<Decoder> decoder = CreateTrivialDecoder();
ASSERT_TRUE(decoder != nullptr);
const bool flipVertically = Orientation == Orient::FLIP_VERTICALLY;
- WithFilterPipeline(decoder, Forward<Func>(aFunc),
+ WithFilterPipeline(decoder, std::forward<Func>(aFunc),
SurfaceConfig { decoder, IntSize(100, 100),
SurfaceFormat::B8G8R8A8, flipVertically });
}
template <typename Func> void
WithPalettedSurfaceSink(const IntRect& aFrameRect, Func aFunc)
{
RefPtr<Decoder> decoder = CreateTrivialDecoder();
ASSERT_TRUE(decoder != nullptr);
- WithFilterPipeline(decoder, Forward<Func>(aFunc),
+ WithFilterPipeline(decoder, std::forward<Func>(aFunc),
PalettedSurfaceConfig { decoder, IntSize(100, 100),
aFrameRect, SurfaceFormat::B8G8R8A8,
8, false });
}
void
ResetForNextPass(SurfaceFilter* aSink)
{
--- a/ipc/chromium/src/base/task.h
+++ b/ipc/chromium/src/base/task.h
@@ -145,34 +145,34 @@ class ScopedRunnableMethodFactory : publ
template <class Method, typename... Elements>
inline already_AddRefed<mozilla::Runnable>
NewRunnableMethod(Method method, Elements&&... elements) {
typedef mozilla::Tuple<typename mozilla::Decay<Elements>::Type...> ArgsTuple;
typedef RunnableMethod<Method, ArgsTuple> Runnable;
typedef typename ScopedTaskFactory<Runnable>::TaskWrapper TaskWrapper;
RefPtr<TaskWrapper> task = new TaskWrapper(this);
- task->Init(object_, method, mozilla::MakeTuple(mozilla::Forward<Elements>(elements)...));
+ task->Init(object_, method, mozilla::MakeTuple(std::forward<Elements>(elements)...));
return task.forget();
}
protected:
template <class Method, class Params>
class RunnableMethod : public mozilla::Runnable {
public:
RunnableMethod()
: mozilla::Runnable("ScopedRunnableMethodFactory::RunnableMethod")
{
}
void Init(T* obj, Method meth, Params&& params)
{
obj_ = obj;
meth_ = meth;
- params_ = mozilla::Forward<Params>(params);
+ params_ = std::forward<Params>(params);
}
NS_IMETHOD Run() override {
DispatchTupleToMethod(obj_, meth_, params_);
return NS_OK;
}
private:
@@ -275,17 +275,17 @@ struct RunnableMethodTraits<const T> {
template <class T, class Method, class Params>
class RunnableMethod : public mozilla::CancelableRunnable,
public RunnableMethodTraits<T> {
public:
RunnableMethod(T* obj, Method meth, Params&& params)
: mozilla::CancelableRunnable("RunnableMethod")
, obj_(obj)
, meth_(meth)
- , params_(mozilla::Forward<Params>(params))
+ , params_(std::forward<Params>(params))
{
this->RetainCallee(obj_);
}
~RunnableMethod() {
ReleaseCallee();
}
NS_IMETHOD Run() override {
@@ -318,31 +318,31 @@ namespace dont_add_new_uses_of_this {
// Don't add new uses of this!!!!
template <class T, class Method, typename... Args>
inline already_AddRefed<mozilla::Runnable>
NewRunnableMethod(T* object, Method method, Args&&... args) {
typedef mozilla::Tuple<typename mozilla::Decay<Args>::Type...> ArgsTuple;
RefPtr<mozilla::Runnable> t =
new RunnableMethod<T, Method, ArgsTuple>(object, method,
- mozilla::MakeTuple(mozilla::Forward<Args>(args)...));
+ mozilla::MakeTuple(std::forward<Args>(args)...));
return t.forget();
}
} // namespace dont_add_new_uses_of_this
// RunnableFunction and NewRunnableFunction implementation ---------------------
template <class Function, class Params>
class RunnableFunction : public mozilla::CancelableRunnable {
public:
RunnableFunction(const char* name, Function function, Params&& params)
: mozilla::CancelableRunnable(name)
, function_(function)
- , params_(mozilla::Forward<Params>(params))
+ , params_(std::forward<Params>(params))
{
}
~RunnableFunction() {
}
NS_IMETHOD Run() override {
if (function_)
@@ -360,23 +360,23 @@ class RunnableFunction : public mozilla:
};
template <class Function, typename... Args>
inline already_AddRefed<mozilla::CancelableRunnable>
NewCancelableRunnableFunction(const char* name, Function function, Args&&... args) {
typedef mozilla::Tuple<typename mozilla::Decay<Args>::Type...> ArgsTuple;
RefPtr<mozilla::CancelableRunnable> t =
new RunnableFunction<Function, ArgsTuple>(name, function,
- mozilla::MakeTuple(mozilla::Forward<Args>(args)...));
+ mozilla::MakeTuple(std::forward<Args>(args)...));
return t.forget();
}
template <class Function, typename... Args>
inline already_AddRefed<mozilla::Runnable>
NewRunnableFunction(const char* name, Function function, Args&&... args) {
typedef mozilla::Tuple<typename mozilla::Decay<Args>::Type...> ArgsTuple;
RefPtr<mozilla::Runnable> t =
new RunnableFunction<Function, ArgsTuple>(name, function,
- mozilla::MakeTuple(mozilla::Forward<Args>(args)...));
+ mozilla::MakeTuple(std::forward<Args>(args)...));
return t.forget();
}
#endif // BASE_TASK_H_
--- a/ipc/chromium/src/chrome/common/ipc_message_utils.h
+++ b/ipc/chromium/src/chrome/common/ipc_message_utils.h
@@ -127,17 +127,17 @@ template<typename T>
struct ParamTraitsSelector
: public detail::StripPointers<typename mozilla::Decay<T>::Type>
{};
template<typename P>
static inline void
WriteParam(Message* m, P&& p) {
ParamTraits<typename ParamTraitsSelector<P>::Type>
- ::Write(m, mozilla::Forward<P>(p));
+ ::Write(m, std::forward<P>(p));
}
template<typename P>
static inline bool WARN_UNUSED_RESULT
ReadParam(const Message* m, PickleIterator* iter,
P* p)
{
return ParamTraits<typename ParamTraitsSelector<P>::Type>::Read(m, iter, p);
--- a/ipc/glue/IPDLParamTraits.h
+++ b/ipc/glue/IPDLParamTraits.h
@@ -26,17 +26,17 @@ struct IPDLParamTraits
// ParamTraits. Types which want to use the actor parameter must specialize
// IPDLParamTraits.
template<typename R>
static inline void Write(IPC::Message* aMsg, IProtocol*, R&& aParam)
{
static_assert(IsSame<P, typename IPC::ParamTraitsSelector<R>::Type>::value,
"IPDLParamTraits::Write only forwards calls which work via WriteParam");
- IPC::ParamTraits<P>::Write(aMsg, Forward<R>(aParam));
+ IPC::ParamTraits<P>::Write(aMsg, std::forward<R>(aParam));
}
template<typename R>
static inline bool Read(const IPC::Message* aMsg, PickleIterator* aIter,
IProtocol*, R* aResult) {
static_assert(IsSame<P, typename IPC::ParamTraitsSelector<R>::Type>::value,
"IPDLParamTraits::Read only forwards calls which work via ReadParam");
@@ -56,17 +56,17 @@ struct IPDLParamTraits
//
template<typename P>
static MOZ_NEVER_INLINE void
WriteIPDLParam(IPC::Message* aMsg,
IProtocol* aActor,
P&& aParam)
{
IPDLParamTraits<typename IPC::ParamTraitsSelector<P>::Type>
- ::Write(aMsg, aActor, Forward<P>(aParam));
+ ::Write(aMsg, aActor, std::forward<P>(aParam));
}
template<typename P>
static MOZ_NEVER_INLINE bool
ReadIPDLParam(const IPC::Message* aMsg,
PickleIterator* aIter,
IProtocol* aActor,
P* aResult)
--- a/ipc/glue/TaskFactory.h
+++ b/ipc/glue/TaskFactory.h
@@ -28,17 +28,17 @@ class TaskFactory : public RevocableStor
{
private:
template<class TaskType>
class TaskWrapper : public TaskType
{
public:
template<typename... Args>
explicit TaskWrapper(RevocableStore* store, Args&&... args)
- : TaskType(mozilla::Forward<Args>(args)...)
+ : TaskType(std::forward<Args>(args)...)
, revocable_(store)
{
}
NS_IMETHOD Run() override {
if (!revocable_.revoked())
TaskType::Run();
return NS_OK;
@@ -51,30 +51,30 @@ private:
public:
explicit TaskFactory(T* object) : object_(object) { }
template <typename TaskParamType, typename... Args>
inline already_AddRefed<TaskParamType> NewTask(Args&&... args)
{
typedef TaskWrapper<TaskParamType> TaskWrapper;
RefPtr<TaskWrapper> task =
- new TaskWrapper(this, mozilla::Forward<Args>(args)...);
+ new TaskWrapper(this, std::forward<Args>(args)...);
return task.forget();
}
template <class Method, typename... Args>
inline already_AddRefed<Runnable>
NewRunnableMethod(Method method, Args&&... args) {
- typedef decltype(base::MakeTuple(mozilla::Forward<Args>(args)...)) ArgTuple;
+ typedef decltype(base::MakeTuple(std::forward<Args>(args)...)) ArgTuple;
typedef RunnableMethod<Method, ArgTuple> RunnableMethod;
typedef TaskWrapper<RunnableMethod> TaskWrapper;
RefPtr<TaskWrapper> task =
new TaskWrapper(this, object_, method,
- base::MakeTuple(mozilla::Forward<Args>(args)...));
+ base::MakeTuple(std::forward<Args>(args)...));
return task.forget();
}
protected:
template <class Method, class Params>
class RunnableMethod : public Runnable {
public:
--- a/ipc/mscom/ActivationContext.h
+++ b/ipc/mscom/ActivationContext.h
@@ -60,17 +60,17 @@ private:
friend class ActivationContextRegion;
};
class MOZ_NON_TEMPORARY_CLASS ActivationContextRegion final
{
public:
template <typename... Args>
explicit ActivationContextRegion(Args... aArgs)
- : mActCtx(Forward<Args>(aArgs)...)
+ : mActCtx(std::forward<Args>(aArgs)...)
, mActCookie(0)
{
Activate();
}
ActivationContextRegion();
explicit ActivationContextRegion(const ActivationContext& aActCtx);
--- a/ipc/mscom/AsyncInvoker.h
+++ b/ipc/mscom/AsyncInvoker.h
@@ -298,31 +298,31 @@ public:
* the synchronous interface.
* @param aAsyncMethod Pointer to the method that we would like to invoke on
* the asynchronous interface.
*/
template <typename SyncMethod, typename AsyncMethod, typename... Args>
HRESULT Invoke(SyncMethod aSyncMethod, AsyncMethod aAsyncMethod, Args... aArgs)
{
if (mSyncObj) {
- return (mSyncObj->*aSyncMethod)(Forward<Args>(aArgs)...);
+ return (mSyncObj->*aSyncMethod)(std::forward<Args>(aArgs)...);
}
MOZ_ASSERT(mAsyncCall);
if (!mAsyncCall) {
return E_POINTER;
}
AsyncInterface* asyncInterface = mAsyncCall->GetInterface();
MOZ_ASSERT(asyncInterface);
if (!asyncInterface) {
return E_POINTER;
}
- return (asyncInterface->*aAsyncMethod)(Forward<Args>(aArgs)...);
+ return (asyncInterface->*aAsyncMethod)(std::forward<Args>(aArgs)...);
}
AsyncInvoker(const AsyncInvoker& aOther) = delete;
AsyncInvoker(AsyncInvoker&& aOther) = delete;
AsyncInvoker& operator=(const AsyncInvoker& aOther) = delete;
AsyncInvoker& operator=(AsyncInvoker&& aOther) = delete;
private:
--- a/ipc/mscom/COMPtrHolder.h
+++ b/ipc/mscom/COMPtrHolder.h
@@ -31,39 +31,39 @@ public:
COMPtrHolder() {}
MOZ_IMPLICIT COMPtrHolder(decltype(nullptr))
{
}
explicit COMPtrHolder(COMPtrType&& aPtr)
- : mPtr(Forward<COMPtrType>(aPtr))
+ : mPtr(std::forward<COMPtrType>(aPtr))
{
}
COMPtrHolder(COMPtrType&& aPtr, const ActivationContext& aActCtx)
- : mPtr(Forward<COMPtrType>(aPtr))
+ : mPtr(std::forward<COMPtrType>(aPtr))
, mActCtx(aActCtx)
{
}
Interface* Get() const
{
return mPtr.get();
}
MOZ_MUST_USE Interface* Release()
{
return mPtr.release();
}
void Set(COMPtrType&& aPtr)
{
- mPtr = Forward<COMPtrType>(aPtr);
+ mPtr = std::forward<COMPtrType>(aPtr);
}
void SetActCtx(const ActivationContext& aActCtx)
{
mActCtx = aActCtx;
}
#if defined(MOZ_CONTENT_SANDBOX)
--- a/ipc/mscom/MainThreadInvoker.h
+++ b/ipc/mscom/MainThreadInvoker.h
@@ -42,17 +42,17 @@ private:
template <typename Class, typename... Args>
inline bool
InvokeOnMainThread(const char* aName,
Class* aObject, void (Class::*aMethod)(Args...),
Args... aArgs)
{
nsCOMPtr<nsIRunnable> runnable(
NewNonOwningRunnableMethod<Args...>(aName, aObject, aMethod,
- Forward<Args>(aArgs)...));
+ std::forward<Args>(aArgs)...));
MainThreadInvoker invoker;
return invoker.Invoke(runnable.forget());
}
} // namespace mscom
} // namespace mozilla
--- a/ipc/mscom/Registration.cpp
+++ b/ipc/mscom/Registration.cpp
@@ -333,17 +333,17 @@ RegisteredProxy::~RegisteredProxy()
}
if (mModule) {
::FreeLibrary(reinterpret_cast<HMODULE>(mModule));
}
}
RegisteredProxy::RegisteredProxy(RegisteredProxy&& aOther)
{
- *this = mozilla::Forward<RegisteredProxy>(aOther);
+ *this = std::forward<RegisteredProxy>(aOther);
}
RegisteredProxy&
RegisteredProxy::operator=(RegisteredProxy&& aOther)
{
mModule = aOther.mModule;
aOther.mModule = 0;
mClassObject = aOther.mClassObject;
--- a/ipc/mscom/oop/Factory.h
+++ b/ipc/mscom/oop/Factory.h
@@ -36,17 +36,17 @@ class MOZ_NONHEAP_CLASS Factory : public
{
MOZ_DIAGNOSTIC_ASSERT(false, "This should not be executed");
return E_NOTIMPL;
}
template <typename... Args>
HRESULT DoCreate(HRESULT (*aFnPtr)(IUnknown*, REFIID, void**), Args... args)
{
- return aFnPtr(mozilla::Forward<Args>(args)...);
+ return aFnPtr(std::forward<Args>(args)...);
}
public:
// IUnknown
STDMETHODIMP QueryInterface(REFIID aIid, void** aOutInterface) override
{
if (!aOutInterface) {
return E_INVALIDARG;
--- a/js/public/GCHashTable.h
+++ b/js/public/GCHashTable.h
@@ -186,39 +186,39 @@ class MutableWrappedPtrOperations<JS::GC
bool init(uint32_t len = 16) { return map().init(len); }
void clear() { map().clear(); }
void finish() { map().finish(); }
void remove(Ptr p) { map().remove(p); }
template<typename KeyInput, typename ValueInput>
bool add(AddPtr& p, KeyInput&& k, ValueInput&& v) {
- return map().add(p, mozilla::Forward<KeyInput>(k), mozilla::Forward<ValueInput>(v));
+ return map().add(p, std::forward<KeyInput>(k), std::forward<ValueInput>(v));
}
template<typename KeyInput>
bool add(AddPtr& p, KeyInput&& k) {
- return map().add(p, mozilla::Forward<KeyInput>(k), Map::Value());
+ return map().add(p, std::forward<KeyInput>(k), Map::Value());
}
template<typename KeyInput, typename ValueInput>
bool relookupOrAdd(AddPtr& p, KeyInput&& k, ValueInput&& v) {
return map().relookupOrAdd(p, k,
- mozilla::Forward<KeyInput>(k),
- mozilla::Forward<ValueInput>(v));
+ std::forward<KeyInput>(k),
+ std::forward<ValueInput>(v));
}
template<typename KeyInput, typename ValueInput>
bool put(KeyInput&& k, ValueInput&& v) {
- return map().put(mozilla::Forward<KeyInput>(k), mozilla::Forward<ValueInput>(v));
+ return map().put(std::forward<KeyInput>(k), std::forward<ValueInput>(v));
}
template<typename KeyInput, typename ValueInput>
bool putNew(KeyInput&& k, ValueInput&& v) {
- return map().putNew(mozilla::Forward<KeyInput>(k), mozilla::Forward<ValueInput>(v));
+ return map().putNew(std::forward<KeyInput>(k), std::forward<ValueInput>(v));
}
};
} // namespace js
namespace JS {
// A GCHashSet is a HashSet with an additional trace method that knows
@@ -331,37 +331,37 @@ class MutableWrappedPtrOperations<JS::GC
bool init(uint32_t len = 16) { return set().init(len); }
void clear() { set().clear(); }
void finish() { set().finish(); }
void remove(Ptr p) { set().remove(p); }
void remove(const Lookup& l) { set().remove(l); }
template<typename TInput>
bool add(AddPtr& p, TInput&& t) {
- return set().add(p, mozilla::Forward<TInput>(t));
+ return set().add(p, std::forward<TInput>(t));
}
template<typename TInput>
bool relookupOrAdd(AddPtr& p, const Lookup& l, TInput&& t) {
- return set().relookupOrAdd(p, l, mozilla::Forward<TInput>(t));
+ return set().relookupOrAdd(p, l, std::forward<TInput>(t));
}
template<typename TInput>
bool put(TInput&& t) {
- return set().put(mozilla::Forward<TInput>(t));
+ return set().put(std::forward<TInput>(t));
}
template<typename TInput>
bool putNew(TInput&& t) {
- return set().putNew(mozilla::Forward<TInput>(t));
+ return set().putNew(std::forward<TInput>(t));
}
template<typename TInput>
bool putNew(const Lookup& l, TInput&& t) {
- return set().putNew(l, mozilla::Forward<TInput>(t));
+ return set().putNew(l, std::forward<TInput>(t));
}
};
} /* namespace js */
namespace JS {
// Specialize WeakCache for GCHashMap to provide a barriered map that does not
@@ -375,21 +375,21 @@ class WeakCache<GCHashMap<Key, Value, Ha
using Self = WeakCache<Map>;
Map map;
bool needsBarrier;
public:
template <typename... Args>
explicit WeakCache(Zone* zone, Args&&... args)
- : WeakCacheBase(zone), map(mozilla::Forward<Args>(args)...), needsBarrier(false)
+ : WeakCacheBase(zone), map(std::forward<Args>(args)...), needsBarrier(false)
{}
template <typename... Args>
explicit WeakCache(JSRuntime* rt, Args&&... args)
- : WeakCacheBase(rt), map(mozilla::Forward<Args>(args)...), needsBarrier(false)
+ : WeakCacheBase(rt), map(std::forward<Args>(args)...), needsBarrier(false)
{}
~WeakCache() {
MOZ_ASSERT(!needsBarrier);
}
bool needsSweep() override {
return map.needsSweep();
}
@@ -553,42 +553,37 @@ class WeakCache<GCHashMap<Key, Value, Ha
void remove(const Lookup& l) {
Ptr p = lookup(l);
if (p)
remove(p);
}
template<typename KeyInput>
bool add(AddPtr& p, KeyInput&& k) {
- using mozilla::Forward;
- return map.add(p, Forward<KeyInput>(k));
+ return map.add(p, std::forward<KeyInput>(k));
}
template<typename KeyInput, typename ValueInput>
bool add(AddPtr& p, KeyInput&& k, ValueInput&& v) {
- using mozilla::Forward;
- return map.add(p, Forward<KeyInput>(k), Forward<ValueInput>(v));
+ return map.add(p, std::forward<KeyInput>(k), std::forward<ValueInput>(v));
}
template<typename KeyInput, typename ValueInput>
bool relookupOrAdd(AddPtr& p, KeyInput&& k, ValueInput&& v) {
- using mozilla::Forward;
- return map.relookupOrAdd(p, Forward<KeyInput>(k), Forward<ValueInput>(v));
+ return map.relookupOrAdd(p, std::forward<KeyInput>(k), std::forward<ValueInput>(v));
}
template<typename KeyInput, typename ValueInput>
bool put(KeyInput&& k, ValueInput&& v) {
- using mozilla::Forward;
- return map.put(Forward<KeyInput>(k), Forward<ValueInput>(v));
+ return map.put(std::forward<KeyInput>(k), std::forward<ValueInput>(v));
}
template<typename KeyInput, typename ValueInput>
bool putNew(KeyInput&& k, ValueInput&& v) {
- using mozilla::Forward;
- return map.putNew(Forward<KeyInput>(k), Forward<ValueInput>(v));
+ return map.putNew(std::forward<KeyInput>(k), std::forward<ValueInput>(v));
}
};
// Specialize WeakCache for GCHashSet to provide a barriered set that does not
// need to be swept immediately.
template <typename T, typename HashPolicy, typename AllocPolicy>
class WeakCache<GCHashSet<T, HashPolicy, AllocPolicy>>
: protected detail::WeakCacheBase
@@ -599,21 +594,21 @@ class WeakCache<GCHashSet<T, HashPolicy,
Set set;
bool needsBarrier;
public:
using Entry = typename Set::Entry;
template <typename... Args>
explicit WeakCache(Zone* zone, Args&&... args)
- : WeakCacheBase(zone), set(mozilla::Forward<Args>(args)...), needsBarrier(false)
+ : WeakCacheBase(zone), set(std::forward<Args>(args)...), needsBarrier(false)
{}
template <typename... Args>
explicit WeakCache(JSRuntime* rt, Args&&... args)
- : WeakCacheBase(rt), set(mozilla::Forward<Args>(args)...), needsBarrier(false)
+ : WeakCacheBase(rt), set(std::forward<Args>(args)...), needsBarrier(false)
{}
size_t sweep() override {
if (!this->initialized())
return 0;
size_t steps = set.count();
set.sweep();
@@ -770,35 +765,35 @@ class WeakCache<GCHashSet<T, HashPolicy,
void remove(const Lookup& l) {
Ptr p = lookup(l);
if (p)
remove(p);
}
template<typename TInput>
bool add(AddPtr& p, TInput&& t) {
- return set.add(p, mozilla::Forward<TInput>(t));
+ return set.add(p, std::forward<TInput>(t));
}
template<typename TInput>
bool relookupOrAdd(AddPtr& p, const Lookup& l, TInput&& t) {
- return set.relookupOrAdd(p, l, mozilla::Forward<TInput>(t));
+ return set.relookupOrAdd(p, l, std::forward<TInput>(t));
}
template<typename TInput>
bool put(TInput&& t) {
- return set.put(mozilla::Forward<TInput>(t));
+ return set.put(std::forward<TInput>(t));
}
template<typename TInput>
bool putNew(TInput&& t) {
- return set.putNew(mozilla::Forward<TInput>(t));
+ return set.putNew(std::forward<TInput>(t));
}
template<typename TInput>
bool putNew(const Lookup& l, TInput&& t) {
- return set.putNew(l, mozilla::Forward<TInput>(t));
+ return set.putNew(l, std::forward<TInput>(t));
}
};
} // namespace JS
#endif /* GCHashTable_h */
--- a/js/public/GCVector.h
+++ b/js/public/GCVector.h
@@ -71,27 +71,27 @@ class GCVector
MOZ_MUST_USE bool reserve(size_t req) { return vector.reserve(req); }
void shrinkBy(size_t amount) { return vector.shrinkBy(amount); }
MOZ_MUST_USE bool growBy(size_t amount) { return vector.growBy(amount); }
MOZ_MUST_USE bool resize(size_t newLen) { return vector.resize(newLen); }
void clear() { return vector.clear(); }
void clearAndFree() { return vector.clearAndFree(); }
- template<typename U> bool append(U&& item) { return vector.append(mozilla::Forward<U>(item)); }
+ template<typename U> bool append(U&& item) { return vector.append(std::forward<U>(item)); }
template<typename... Args>
MOZ_MUST_USE bool
emplaceBack(Args&&... args) {
- return vector.emplaceBack(mozilla::Forward<Args>(args)...);
+ return vector.emplaceBack(std::forward<Args>(args)...);
}
template<typename U>
void infallibleAppend(U&& aU) {
- return vector.infallibleAppend(mozilla::Forward<U>(aU));
+ return vector.infallibleAppend(std::forward<U>(aU));
}
void infallibleAppendN(const T& aT, size_t aN) {
return vector.infallibleAppendN(aT, aN);
}
template<typename U> void
infallibleAppend(const U* aBegin, const U* aEnd) {
return vector.infallibleAppend(aBegin, aEnd);
}
@@ -209,46 +209,46 @@ class MutableWrappedPtrOperations<JS::GC
MOZ_MUST_USE bool growBy(size_t aIncr) { return vec().growBy(aIncr); }
MOZ_MUST_USE bool resize(size_t aNewLength) { return vec().resize(aNewLength); }
MOZ_MUST_USE bool growByUninitialized(size_t aIncr) { return vec().growByUninitialized(aIncr); }
void infallibleGrowByUninitialized(size_t aIncr) { vec().infallibleGrowByUninitialized(aIncr); }
MOZ_MUST_USE bool resizeUninitialized(size_t aNewLength) { return vec().resizeUninitialized(aNewLength); }
void clear() { vec().clear(); }
void clearAndFree() { vec().clearAndFree(); }
template<typename U>
- MOZ_MUST_USE bool append(U&& aU) { return vec().append(mozilla::Forward<U>(aU)); }
+ MOZ_MUST_USE bool append(U&& aU) { return vec().append(std::forward<U>(aU)); }
template<typename... Args>
MOZ_MUST_USE bool emplaceBack(Args&&... aArgs) {
- return vec().emplaceBack(mozilla::Forward<Args...>(aArgs...));
+ return vec().emplaceBack(std::forward<Args...>(aArgs...));
}
template<typename U>
MOZ_MUST_USE bool appendAll(const U& aU) { return vec().appendAll(aU); }
MOZ_MUST_USE bool appendN(const T& aT, size_t aN) { return vec().appendN(aT, aN); }
template<typename U>
MOZ_MUST_USE bool append(const U* aBegin, const U* aEnd) {
return vec().append(aBegin, aEnd);
}
template<typename U>
MOZ_MUST_USE bool append(const U* aBegin, size_t aLength) {
return vec().append(aBegin, aLength);
}
template<typename U> void infallibleAppend(U&& aU) {
- vec().infallibleAppend(mozilla::Forward<U>(aU));
+ vec().infallibleAppend(std::forward<U>(aU));
}
void infallibleAppendN(const T& aT, size_t aN) { vec().infallibleAppendN(aT, aN); }
template<typename U> void infallibleAppend(const U* aBegin, const U* aEnd) {
vec().infallibleAppend(aBegin, aEnd);
}
template<typename U> void infallibleAppend(const U* aBegin, size_t aLength) {
vec().infallibleAppend(aBegin, aLength);
}
void popBack() { vec().popBack(); }
T popCopy() { return vec().popCopy(); }
template<typename U> T* insert(T* aP, U&& aVal) {
- return vec().insert(aP, mozilla::Forward<U>(aVal));
+ return vec().insert(aP, std::forward<U>(aVal));
}
void erase(T* aT) { vec().erase(aT); }
void erase(T* aBegin, T* aEnd) { vec().erase(aBegin, aEnd); }
};
} // namespace js
namespace JS {
--- a/js/public/HashTable.h
+++ b/js/public/HashTable.h
@@ -150,30 +150,30 @@ class HashMap
typedef typename Impl::AddPtr AddPtr;
MOZ_ALWAYS_INLINE AddPtr lookupForAdd(const Lookup& l) const {
return impl.lookupForAdd(l);
}
template<typename KeyInput, typename ValueInput>
MOZ_MUST_USE bool add(AddPtr& p, KeyInput&& k, ValueInput&& v) {
return impl.add(p,
- mozilla::Forward<KeyInput>(k),
- mozilla::Forward<ValueInput>(v));
+ std::forward<KeyInput>(k),
+ std::forward<ValueInput>(v));
}
template<typename KeyInput>
MOZ_MUST_USE bool add(AddPtr& p, KeyInput&& k) {
- return impl.add(p, mozilla::Forward<KeyInput>(k), Value());
+ return impl.add(p, std::forward<KeyInput>(k), Value());
}
template<typename KeyInput, typename ValueInput>
MOZ_MUST_USE bool relookupOrAdd(AddPtr& p, KeyInput&& k, ValueInput&& v) {
return impl.relookupOrAdd(p, k,
- mozilla::Forward<KeyInput>(k),
- mozilla::Forward<ValueInput>(v));
+ std::forward<KeyInput>(k),
+ std::forward<ValueInput>(v));
}
// |all()| returns a Range containing |count()| elements. E.g.:
//
// typedef HashMap<int,char> HM;
// HM h;
// for (HM::Range r = h.all(); !r.empty(); r.popFront())
// char c = r.front().value();
@@ -236,32 +236,32 @@ class HashMap
return impl.lookup(l).found();
}
// Overwrite existing value with v. Return false on oom.
template<typename KeyInput, typename ValueInput>
MOZ_MUST_USE bool put(KeyInput&& k, ValueInput&& v) {
AddPtr p = lookupForAdd(k);
if (p) {
- p->value() = mozilla::Forward<ValueInput>(v);
+ p->value() = std::forward<ValueInput>(v);
return true;
}
- return add(p, mozilla::Forward<KeyInput>(k), mozilla::Forward<ValueInput>(v));
+ return add(p, std::forward<KeyInput>(k), std::forward<ValueInput>(v));
}
// Like put, but assert that the given key is not already present.
template<typename KeyInput, typename ValueInput>
MOZ_MUST_USE bool putNew(KeyInput&& k, ValueInput&& v) {
- return impl.putNew(k, mozilla::Forward<KeyInput>(k), mozilla::Forward<ValueInput>(v));
+ return impl.putNew(k, std::forward<KeyInput>(k), std::forward<ValueInput>(v));
}
// Only call this to populate an empty map after reserving space with init().
template<typename KeyInput, typename ValueInput>
void putNewInfallible(KeyInput&& k, ValueInput&& v) {
- impl.putNewInfallible(k, mozilla::Forward<KeyInput>(k), mozilla::Forward<ValueInput>(v));
+ impl.putNewInfallible(k, std::forward<KeyInput>(k), std::forward<ValueInput>(v));
}
// Add (k,defaultValue) if |k| is not found. Return a false-y Ptr on oom.
Ptr lookupWithDefault(const Key& k, const Value& defaultValue) {
AddPtr p = lookupForAdd(k);
if (p)
return p;
bool ok = add(p, k, defaultValue);
@@ -405,22 +405,22 @@ class HashSet
// entry |t|, where the caller ensures match(l,t).
typedef typename Impl::AddPtr AddPtr;
MOZ_ALWAYS_INLINE AddPtr lookupForAdd(const Lookup& l) const {
return impl.lookupForAdd(l);
}
template <typename U>
MOZ_MUST_USE bool add(AddPtr& p, U&& u) {
- return impl.add(p, mozilla::Forward<U>(u));
+ return impl.add(p, std::forward<U>(u));
}
template <typename U>
MOZ_MUST_USE bool relookupOrAdd(AddPtr& p, const Lookup& l, U&& u) {
- return impl.relookupOrAdd(p, l, mozilla::Forward<U>(u));
+ return impl.relookupOrAdd(p, l, std::forward<U>(u));
}
// |all()| returns a Range containing |count()| elements:
//
// typedef HashSet<int> HS;
// HS h;
// for (HS::Range r = h.all(); !r.empty(); r.popFront())
// int i = r.front();
@@ -482,34 +482,34 @@ class HashSet
bool has(const Lookup& l) const {
return impl.lookup(l).found();
}
// Add |u| if it is not present already. Return false on oom.
template <typename U>
MOZ_MUST_USE bool put(U&& u) {
AddPtr p = lookupForAdd(u);
- return p ? true : add(p, mozilla::Forward<U>(u));
+ return p ? true : add(p, std::forward<U>(u));
}
// Like put, but assert that the given key is not already present.
template <typename U>
MOZ_MUST_USE bool putNew(U&& u) {
- return impl.putNew(u, mozilla::Forward<U>(u));
+ return impl.putNew(u, std::forward<U>(u));
}
template <typename U>
MOZ_MUST_USE bool putNew(const Lookup& l, U&& u) {
- return impl.putNew(l, mozilla::Forward<U>(u));
+ return impl.putNew(l, std::forward<U>(u));
}
// Only call this to populate an empty set after reserving space with init().
template <typename U>
void putNewInfallible(const Lookup& l, U&& u) {
- impl.putNewInfallible(l, mozilla::Forward<U>(u));
+ impl.putNewInfallible(l, std::forward<U>(u));
}
void remove(const Lookup& l) {
if (Ptr p = lookup(l))
remove(p);
}
// Infallibly rekey one entry, if present.
@@ -707,23 +707,23 @@ struct FallibleHashMethods
// Fallible method to ensure a hashcode exists for its argument and create
// one if not. Returns false on error, e.g. out of memory.
template <typename Lookup> static bool ensureHash(Lookup&& l) { return true; }
};
template <typename HashPolicy, typename Lookup>
static bool
HasHash(Lookup&& l) {
- return FallibleHashMethods<typename HashPolicy::Base>::hasHash(mozilla::Forward<Lookup>(l));
+ return FallibleHashMethods<typename HashPolicy::Base>::hasHash(std::forward<Lookup>(l));
}
template <typename HashPolicy, typename Lookup>
static bool
EnsureHash(Lookup&& l) {
- return FallibleHashMethods<typename HashPolicy::Base>::ensureHash(mozilla::Forward<Lookup>(l));
+ return FallibleHashMethods<typename HashPolicy::Base>::ensureHash(std::forward<Lookup>(l));
}
/*****************************************************************************/
// Both HashMap and HashSet are implemented by a single HashTable that is even
// more heavily parameterized than the other two. This leaves HashTable gnarly
// and extremely coupled to HashMap and HashSet; thus code should not use
// HashTable directly.
@@ -736,18 +736,18 @@ class HashMapEntry
template <class, class, class> friend class detail::HashTable;
template <class> friend class detail::HashTableEntry;
template <class, class, class, class> friend class HashMap;
public:
template<typename KeyInput, typename ValueInput>
HashMapEntry(KeyInput&& k, ValueInput&& v)
- : key_(mozilla::Forward<KeyInput>(k)),
- value_(mozilla::Forward<ValueInput>(v))
+ : key_(std::forward<KeyInput>(k)),
+ value_(std::forward<ValueInput>(v))
{}
HashMapEntry(HashMapEntry&& rhs)
: key_(std::move(rhs.key_)),
value_(std::move(rhs.value_))
{}
void operator=(HashMapEntry&& rhs) {
@@ -915,17 +915,17 @@ class HashTableEntry
return keyHash & ~sCollisionBit;
}
template <typename... Args>
void setLive(HashNumber hn, Args&&... args)
{
MOZ_ASSERT(!isLive());
keyHash = hn;
- new (valuePtr()) T(mozilla::Forward<Args>(args)...);
+ new (valuePtr()) T(std::forward<Args>(args)...);
MOZ_ASSERT(isLive());
}
};
template <class T, class HashPolicy, class AllocPolicy>
class HashTable : private AllocPolicy
{
friend class mozilla::ReentrancyGuard;
@@ -1724,17 +1724,17 @@ class HashTable : private AllocPolicy
MOZ_ASSERT(entry);
if (entry->isRemoved()) {
METER(stats.addOverRemoved++);
removedCount--;
keyHash |= sCollisionBit;
}
- entry->setLive(keyHash, mozilla::Forward<Args>(args)...);
+ entry->setLive(keyHash, std::forward<Args>(args)...);
entryCount++;
#ifdef JS_DEBUG
mutationCount++;
#endif
}
public:
void clear()
@@ -1875,51 +1875,51 @@ class HashTable : private AllocPolicy
if (status == RehashFailed)
return false;
if (status == NotOverloaded && !this->checkSimulatedOOM())
return false;
if (status == Rehashed)
p.entry_ = &findFreeEntry(p.keyHash);
}
- p.entry_->setLive(p.keyHash, mozilla::Forward<Args>(args)...);
+ p.entry_->setLive(p.keyHash, std::forward<Args>(args)...);
entryCount++;
#ifdef JS_DEBUG
mutationCount++;
p.generation = generation();
p.mutationCount = mutationCount;
#endif
return true;
}
// Note: |l| may be a reference to a piece of |u|, so this function
// must take care not to use |l| after moving |u|.
template <typename... Args>
void putNewInfallible(const Lookup& l, Args&&... args)
{
MOZ_ASSERT(!lookup(l).found());
mozilla::ReentrancyGuard g(*this);
- putNewInfallibleInternal(l, mozilla::Forward<Args>(args)...);
+ putNewInfallibleInternal(l, std::forward<Args>(args)...);
}
// Note: |l| may be alias arguments in |args|, so this function must take
// care not to use |l| after moving |args|.
template <typename... Args>
MOZ_MUST_USE bool putNew(const Lookup& l, Args&&... args)
{
if (!this->checkSimulatedOOM())
return false;
if (!EnsureHash<HashPolicy>(l))
return false;
if (checkOverloaded() == RehashFailed)
return false;
- putNewInfallible(l, mozilla::Forward<Args>(args)...);
+ putNewInfallible(l, std::forward<Args>(args)...);
return true;
}
// Note: |l| may be a reference to a piece of |u|, so this function
// must take care not to use |l| after moving |u|.
template <typename... Args>
MOZ_MUST_USE bool relookupOrAdd(AddPtr& p, const Lookup& l, Args&&... args)
{
@@ -1931,17 +1931,17 @@ class HashTable : private AllocPolicy
p.generation = generation();
p.mutationCount = mutationCount;
#endif
{
mozilla::ReentrancyGuard g(*this);
MOZ_ASSERT(prepareHash(l) == p.keyHash); // l has not been destroyed
p.entry_ = &lookup(l, p.keyHash, sCollisionBit);
}
- return p.found() || add(p, mozilla::Forward<Args>(args)...);
+ return p.found() || add(p, std::forward<Args>(args)...);
}
void remove(Ptr p)
{
MOZ_ASSERT(table);
mozilla::ReentrancyGuard g(*this);
MOZ_ASSERT(p.found());
MOZ_ASSERT(p.generation == generation());
--- a/js/public/HeapAPI.h
+++ b/js/public/HeapAPI.h
@@ -342,22 +342,22 @@ class JS_FRIEND_API(GCCellPtr)
uintptr_t ptr;
};
// Unwraps the given GCCellPtr and calls the given functor with a template
// argument of the actual type of the pointer.
template <typename F, typename... Args>
auto
DispatchTyped(F f, GCCellPtr thing, Args&&... args)
- -> decltype(f(static_cast<JSObject*>(nullptr), mozilla::Forward<Args>(args)...))
+ -> decltype(f(static_cast<JSObject*>(nullptr), std::forward<Args>(args)...))
{
switch (thing.kind()) {
#define JS_EXPAND_DEF(name, type, _) \
case JS::TraceKind::name: \
- return f(&thing.as<type>(), mozilla::Forward<Args>(args)...);
+ return f(&thing.as<type>(), std::forward<Args>(args)...);
JS_FOR_EACH_TRACEKIND(JS_EXPAND_DEF);
#undef JS_EXPAND_DEF
default:
MOZ_CRASH("Invalid trace kind in DispatchTyped for GCCellPtr.");
}
}
} /* namespace JS */
--- a/js/public/Id.h
+++ b/js/public/Id.h
@@ -224,22 +224,22 @@ struct BarrierMethods<jsid>
}
};
// If the jsid is a GC pointer type, convert to that type and call |f| with
// the pointer. If the jsid is not a GC type, calls F::defaultValue.
template <typename F, typename... Args>
auto
DispatchTyped(F f, const jsid& id, Args&&... args)
- -> decltype(f(static_cast<JSString*>(nullptr), mozilla::Forward<Args>(args)...))
+ -> decltype(f(static_cast<JSString*>(nullptr), std::forward<Args>(args)...))
{
if (JSID_IS_STRING(id))
- return f(JSID_TO_STRING(id), mozilla::Forward<Args>(args)...);
+ return f(JSID_TO_STRING(id), std::forward<Args>(args)...);
if (JSID_IS_SYMBOL(id))
- return f(JSID_TO_SYMBOL(id), mozilla::Forward<Args>(args)...);
+ return f(JSID_TO_SYMBOL(id), std::forward<Args>(args)...);
MOZ_ASSERT(!JSID_IS_GCTHING(id));
return F::defaultValue(id);
}
#undef id
} // namespace js
--- a/js/public/RootingAPI.h
+++ b/js/public/RootingAPI.h
@@ -763,20 +763,20 @@ struct JS_PUBLIC_API(MovableCellHasher<J
}
static void rekey(Key& k, const Key& newKey) { k.unsafeSet(newKey); }
};
template <typename T>
struct FallibleHashMethods<MovableCellHasher<T>>
{
template <typename Lookup> static bool hasHash(Lookup&& l) {
- return MovableCellHasher<T>::hasHash(mozilla::Forward<Lookup>(l));
+ return MovableCellHasher<T>::hasHash(std::forward<Lookup>(l));
}
template <typename Lookup> static bool ensureHash(Lookup&& l) {
- return MovableCellHasher<T>::ensureHash(mozilla::Forward<Lookup>(l));
+ return MovableCellHasher<T>::ensureHash(std::forward<Lookup>(l));
}
};
} /* namespace js */
namespace js {
// The alignment must be set because the Rooted and PersistentRooted ptr fields
@@ -796,17 +796,17 @@ class alignas(8) DispatchWrapper
using TraceFn = void (*)(JSTracer*, T*, const char*);
TraceFn tracer;
alignas(gc::CellAlignBytes) T storage;
public:
template <typename U>
MOZ_IMPLICIT DispatchWrapper(U&& initial)
: tracer(&JS::GCPolicy<T>::trace),
- storage(mozilla::Forward<U>(initial))
+ storage(std::forward<U>(initial))
{ }
// Mimic a pointer type, so that we can drop into Rooted.
T* operator &() { return &storage; }
const T* operator &() const { return &storage; }
operator T&() { return storage; }
operator const T&() const { return storage; }
@@ -990,17 +990,17 @@ class MOZ_RAII Rooted : public js::Roote
explicit Rooted(const RootingContext& cx)
: ptr(SafelyInitialized<T>())
{
registerWithRootLists(rootLists(cx));
}
template <typename RootingContext, typename S>
Rooted(const RootingContext& cx, S&& initial)
- : ptr(mozilla::Forward<S>(initial))
+ : ptr(std::forward<S>(initial))
{
MOZ_ASSERT(GCPolicy<T>::isValid(ptr));
registerWithRootLists(rootLists(cx));
}
~Rooted() {
MOZ_ASSERT(*stack == reinterpret_cast<Rooted<void*>*>(this));
*stack = prev;
@@ -1274,37 +1274,37 @@ class PersistentRooted : public js::Root
explicit PersistentRooted(JSContext* cx)
: ptr(SafelyInitialized<T>())
{
registerWithRootLists(RootingContext::get(cx));
}
template <typename U>
PersistentRooted(RootingContext* cx, U&& initial)
- : ptr(mozilla::Forward<U>(initial))
+ : ptr(std::forward<U>(initial))
{
registerWithRootLists(cx);
}
template <typename U>
PersistentRooted(JSContext* cx, U&& initial)
- : ptr(mozilla::Forward<U>(initial))
+ : ptr(std::forward<U>(initial))
{
registerWithRootLists(RootingContext::get(cx));
}
explicit PersistentRooted(JSRuntime* rt)
: ptr(SafelyInitialized<T>())
{
registerWithRootLists(rt);
}
template <typename U>
PersistentRooted(JSRuntime* rt, U&& initial)
- : ptr(mozilla::Forward<U>(initial))
+ : ptr(std::forward<U>(initial))
{
registerWithRootLists(rt);
}
PersistentRooted(const PersistentRooted& rhs)
: mozilla::LinkedListElement<PersistentRooted<T>>(),
ptr(rhs.ptr)
{
@@ -1324,17 +1324,17 @@ class PersistentRooted : public js::Root
}
void init(JSContext* cx) {
init(cx, SafelyInitialized<T>());
}
template <typename U>
void init(JSContext* cx, U&& initial) {
- ptr = mozilla::Forward<U>(initial);
+ ptr = std::forward<U>(initial);
registerWithRootLists(RootingContext::get(cx));
}
void reset() {
if (initialized()) {
set(SafelyInitialized<T>());
ListBase::remove();
}
@@ -1355,17 +1355,17 @@ class PersistentRooted : public js::Root
MOZ_ASSERT(initialized());
return ptr;
}
private:
template <typename U>
void set(U&& value) {
MOZ_ASSERT(initialized());
- ptr = mozilla::Forward<U>(value);
+ ptr = std::forward<U>(value);
}
detail::MaybeWrapped<T> ptr;
} JS_HAZ_ROOTED;
class JS_PUBLIC_API(ObjectPtr)
{
Heap<JSObject*> value;
--- a/js/public/SweepingAPI.h
+++ b/js/public/SweepingAPI.h
@@ -61,21 +61,21 @@ class WeakCache : protected detail::Weak
{
T cache;
public:
using Type = T;
template <typename... Args>
explicit WeakCache(Zone* zone, Args&&... args)
- : WeakCacheBase(zone), cache(mozilla::Forward<Args>(args)...)
+ : WeakCacheBase(zone), cache(std::forward<Args>(args)...)
{}
template <typename... Args>
explicit WeakCache(JSRuntime* rt, Args&&... args)
- : WeakCacheBase(rt), cache(mozilla::Forward<Args>(args)...)
+ : WeakCacheBase(rt), cache(std::forward<Args>(args)...)
{}
const T& get() const { return cache; }
T& get() { return cache; }
size_t sweep() override {
GCPolicy<T>::sweep(&cache);
return 0;
--- a/js/public/TraceKind.h
+++ b/js/public/TraceKind.h
@@ -191,39 +191,39 @@ template <> struct MapTypeToRootKind<JSF
#if (defined(_MSC_VER) && _MSC_VER < 1910) && !defined(__clang__)
# define JS_DEPENDENT_TEMPLATE_HINT
#else
# define JS_DEPENDENT_TEMPLATE_HINT template
#endif
template <typename F, typename... Args>
auto
DispatchTraceKindTyped(F f, JS::TraceKind traceKind, Args&&... args)
- -> decltype(f. JS_DEPENDENT_TEMPLATE_HINT operator()<JSObject>(mozilla::Forward<Args>(args)...))
+ -> decltype(f. JS_DEPENDENT_TEMPLATE_HINT operator()<JSObject>(std::forward<Args>(args)...))
{
switch (traceKind) {
#define JS_EXPAND_DEF(name, type, _) \
case JS::TraceKind::name: \
- return f. JS_DEPENDENT_TEMPLATE_HINT operator()<type>(mozilla::Forward<Args>(args)...);
+ return f. JS_DEPENDENT_TEMPLATE_HINT operator()<type>(std::forward<Args>(args)...);
JS_FOR_EACH_TRACEKIND(JS_EXPAND_DEF);
#undef JS_EXPAND_DEF
default:
MOZ_CRASH("Invalid trace kind in DispatchTraceKindTyped.");
}
}
#undef JS_DEPENDENT_TEMPLATE_HINT
template <typename F, typename... Args>
auto
DispatchTraceKindTyped(F f, void* thing, JS::TraceKind traceKind, Args&&... args)
- -> decltype(f(static_cast<JSObject*>(nullptr), mozilla::Forward<Args>(args)...))
+ -> decltype(f(static_cast<JSObject*>(nullptr), std::forward<Args>(args)...))
{
switch (traceKind) {
#define JS_EXPAND_DEF(name, type, _) \
case JS::TraceKind::name: \
- return f(static_cast<type*>(thing), mozilla::Forward<Args>(args)...);
+ return f(static_cast<type*>(thing), std::forward<Args>(args)...);
JS_FOR_EACH_TRACEKIND(JS_EXPAND_DEF);
#undef JS_EXPAND_DEF
default:
MOZ_CRASH("Invalid trace kind in DispatchTraceKindTyped.");
}
}
} // namespace JS
--- a/js/public/UbiNode.h
+++ b/js/public/UbiNode.h
@@ -171,17 +171,16 @@ class EdgeRange;
class StackFrame;
} // namespace ubi
} // namespace JS
namespace JS {
namespace ubi {
-using mozilla::Forward;
using mozilla::Maybe;
using mozilla::RangedPtr;
using mozilla::Variant;
template <typename T>
using Vector = mozilla::Vector<T, 0, js::SystemAllocPolicy>;
/*** ubi::StackFrame ******************************************************************************/
@@ -191,23 +190,23 @@ using Vector = mozilla::Vector<T, 0, js:
// heap snapshots store their strings as const char16_t*. In order to provide
// zero-cost accessors to these strings in a single interface that works with
// both cases, we use this variant type.
class JS_PUBLIC_API(AtomOrTwoByteChars) : public Variant<JSAtom*, const char16_t*> {
using Base = Variant<JSAtom*, const char16_t*>;
public:
template<typename T>
- MOZ_IMPLICIT AtomOrTwoByteChars(T&& rhs) : Base(Forward<T>(rhs)) { }
+ MOZ_IMPLICIT AtomOrTwoByteChars(T&& rhs) : Base(std::forward<T>(rhs)) { }
template<typename T>
AtomOrTwoByteChars& operator=(T&& rhs) {
MOZ_ASSERT(this != &rhs, "self-move disallowed");
this->~AtomOrTwoByteChars();
- new (this) AtomOrTwoByteChars(Forward<T>(rhs));
+ new (this) AtomOrTwoByteChars(std::forward<T>(rhs));
return *this;
}
// Return the length of the given AtomOrTwoByteChars string.
size_t length();
// Copy the given AtomOrTwoByteChars string into the destination buffer,
// inflating if necessary. Does NOT null terminate. Returns the number of
--- a/js/public/UniquePtr.h
+++ b/js/public/UniquePtr.h
@@ -40,17 +40,17 @@ struct UniqueSelector<T[N]>
} // namespace detail
// Replacement for mozilla::MakeUnique that correctly calls js_new and produces
// a js::UniquePtr.
template<typename T, typename... Args>
typename detail::UniqueSelector<T>::SingleObject
MakeUnique(Args&&... aArgs)
{
- return UniquePtr<T>(js_new<T>(mozilla::Forward<Args>(aArgs)...));
+ return UniquePtr<T>(js_new<T>(std::forward<Args>(aArgs)...));
}
template<typename T>
typename detail::UniqueSelector<T>::UnknownBound
MakeUnique(decltype(sizeof(int)) aN) = delete;
template<typename T, typename... Args>
typename detail::UniqueSelector<T>::KnownBound
--- a/js/public/Utility.h
+++ b/js/public/Utility.h
@@ -474,17 +474,17 @@ JS_PUBLIC_API(char*) js_strdup(const cha
* or the build will break.
*/
#define JS_DECLARE_NEW_METHODS(NEWNAME, ALLOCATOR, QUALIFIERS) \
template <class T, typename... Args> \
QUALIFIERS T * \
NEWNAME(Args&&... args) MOZ_HEAP_ALLOCATOR { \
void* memory = ALLOCATOR(sizeof(T)); \
return MOZ_LIKELY(memory) \
- ? new(memory) T(mozilla::Forward<Args>(args)...) \
+ ? new(memory) T(std::forward<Args>(args)...) \
: nullptr; \
}
/*
* Given a class which should provide 'make' methods, add
* JS_DECLARE_MAKE_METHODS (see js::MallocProvider for an example). This
* method is functionally the same as JS_DECLARE_NEW_METHODS: it just declares
* methods that return mozilla::UniquePtr instances that will singly-manage
@@ -492,17 +492,17 @@ JS_PUBLIC_API(char*) js_strdup(const cha
*
* Note: Do not add a ; at the end of a use of JS_DECLARE_MAKE_METHODS,
* or the build will break.
*/
#define JS_DECLARE_MAKE_METHODS(MAKENAME, NEWNAME, QUALIFIERS)\
template <class T, typename... Args> \
QUALIFIERS mozilla::UniquePtr<T, JS::DeletePolicy<T>> \
MAKENAME(Args&&... args) MOZ_HEAP_ALLOCATOR { \
- T* ptr = NEWNAME<T>(mozilla::Forward<Args>(args)...); \
+ T* ptr = NEWNAME<T>(std::forward<Args>(args)...); \
return mozilla::UniquePtr<T, JS::DeletePolicy<T>>(ptr); \
}
JS_DECLARE_NEW_METHODS(js_new, js_malloc, static MOZ_ALWAYS_INLINE)
namespace js {
/*
--- a/js/public/Value.h
+++ b/js/public/Value.h
@@ -1424,43 +1424,43 @@ class HeapBase<JS::Value, Wrapper> : pub
/*
* If the Value is a GC pointer type, convert to that type and call |f| with
* the pointer. If the Value is not a GC type, calls F::defaultValue.
*/
template <typename F, typename... Args>
auto
DispatchTyped(F f, const JS::Value& val, Args&&... args)
- -> decltype(f(static_cast<JSObject*>(nullptr), mozilla::Forward<Args>(args)...))
+ -> decltype(f(static_cast<JSObject*>(nullptr), std::forward<Args>(args)...))
{
if (val.isString()) {
JSString* str = val.toString();
MOZ_ASSERT(gc::IsCellPointerValid(str));
- return f(str, mozilla::Forward<Args>(args)...);
+ return f(str, std::forward<Args>(args)...);
}
if (val.isObject()) {
JSObject* obj = &val.toObject();
MOZ_ASSERT(gc::IsCellPointerValid(obj));
- return f(obj, mozilla::Forward<Args>(args)...);
+ return f(obj, std::forward<Args>(args)...);
}
if (val.isSymbol()) {
JS::Symbol* sym = val.toSymbol();
MOZ_ASSERT(gc::IsCellPointerValid(sym));
- return f(sym, mozilla::Forward<Args>(args)...);
+ return f(sym, std::forward<Args>(args)...);
}
#ifdef ENABLE_BIGINT
if (val.isBigInt()) {
JS::BigInt* bi = val.toBigInt();
MOZ_ASSERT(gc::IsCellPointerValid(bi));
- return f(bi, mozilla::Forward<Args>(args)...);
+ return f(bi, std::forward<Args>(args)...);
}
#endif
if (MOZ_UNLIKELY(val.isPrivateGCThing())) {
MOZ_ASSERT(gc::IsCellPointerValid(val.toGCThing()));
- return DispatchTyped(f, val.toGCCellPtr(), mozilla::Forward<Args>(args)...);
+ return DispatchTyped(f, val.toGCCellPtr(), std::forward<Args>(args)...);
}
MOZ_ASSERT(!val.isGCThing());
return F::defaultValue(val);
}
template <class S> struct VoidDefaultAdaptor { static void defaultValue(const S&) {} };
template <class S> struct IdentityDefaultAdaptor { static S defaultValue(const S& v) {return v;} };
template <class S, bool v> struct BoolDefaultAdaptor { static bool defaultValue(const S&) { return v; } };
--- a/js/src/builtin/ReflectParse.cpp
+++ b/js/src/builtin/ReflectParse.cpp
@@ -26,17 +26,16 @@
#include "frontend/ParseNode-inl.h"
#include "vm/JSObject-inl.h"
using namespace js;
using namespace js::frontend;
using JS::AutoValueArray;
using mozilla::DebugOnly;
-using mozilla::Forward;
enum ASTType {
AST_ERROR = -1,
#define ASTDEF(ast, str, method) ast,
#include "jsast.tbl"
#undef ASTDEF
AST_LIMIT
};
@@ -317,30 +316,30 @@ class NodeBuilder
// just variadic.
template <typename... Arguments>
MOZ_MUST_USE bool callbackHelper(HandleValue fun, const InvokeArgs& args, size_t i,
HandleValue head, Arguments&&... tail)
{
// Recursive loop to store the arguments into args. This eventually
// bottoms out in a call to the non-template callbackHelper() above.
args[i].set(head);
- return callbackHelper(fun, args, i + 1, Forward<Arguments>(tail)...);
+ return callbackHelper(fun, args, i + 1, std::forward<Arguments>(tail)...);
}
// Invoke a user-defined callback. The actual signature is:
//
// bool callback(HandleValue fun, HandleValue... args, TokenPos* pos,
// MutableHandleValue dst);
template <typename... Arguments>
MOZ_MUST_USE bool callback(HandleValue fun, Arguments&&... args) {
InvokeArgs iargs(cx);
if (!iargs.init(cx, sizeof...(args) - 2 + size_t(saveLoc)))
return false;
- return callbackHelper(fun, iargs, 0, Forward<Arguments>(args)...);
+ return callbackHelper(fun, iargs, 0, std::forward<Arguments>(args)...);
}
// WARNING: Returning a Handle is non-standard, but it works in this case
// because both |v| and |UndefinedHandleValue| are definitely rooted on a
// previous stack frame (i.e. we're just choosing between two
// already-rooted values).
HandleValue opt(HandleValue v) {
MOZ_ASSERT_IF(v.isMagic(), v.whyMagic() == JS_SERIALIZE_NO_NODE);
@@ -383,31 +382,31 @@ class NodeBuilder
MOZ_MUST_USE bool newNodeHelper(HandleObject obj, const char *name, HandleValue value,
Arguments&&... rest)
{
// Recursive loop to define properties. Note that the newNodeHelper()
// call below passes two fewer arguments than we received, as we omit
// `name` and `value`. This eventually bottoms out in a call to the
// non-template newNodeHelper() above.
return defineProperty(obj, name, value)
- && newNodeHelper(obj, Forward<Arguments>(rest)...);
+ && newNodeHelper(obj, std::forward<Arguments>(rest)...);
}
// Create a node object with "type" and "loc" properties, as well as zero
// or more properties passed in as arguments. The signature is really more
// like:
//
// bool newNode(ASTType type, TokenPos* pos,
// {const char *name0, HandleValue value0,}...
// MutableHandleValue dst);
template <typename... Arguments>
MOZ_MUST_USE bool newNode(ASTType type, TokenPos* pos, Arguments&&... args) {
RootedObject node(cx);
return createNode(type, pos, &node) &&
- newNodeHelper(node, Forward<Arguments>(args)...);
+ newNodeHelper(node, std::forward<Arguments>(args)...);
}
MOZ_MUST_USE bool listNode(ASTType type, const char* propName, NodeVector& elts, TokenPos* pos,
MutableHandleValue dst) {
RootedValue array(cx);
if (!newArray(elts, &array))
return false;
--- a/js/src/ds/Fifo.h
+++ b/js/src/ds/Fifo.h
@@ -119,26 +119,26 @@ class Fifo
ConstIterator end() const {
return ConstIterator(*this, length());
}
// Push an element to the back of the queue. This method can take either a
// |const T&| or a |T&&|.
template <typename U>
MOZ_MUST_USE bool pushBack(U&& u) {
- if (!rear_.append(mozilla::Forward<U>(u)))
+ if (!rear_.append(std::forward<U>(u)))
return false;
fixup();
return true;
}
// Construct a T in-place at the back of the queue.
template <typename... Args>
MOZ_MUST_USE bool emplaceBack(Args&&... args) {
- if (!rear_.emplaceBack(mozilla::Forward<Args>(args)...))
+ if (!rear_.emplaceBack(std::forward<Args>(args)...))
return false;
fixup();
return true;
}
// Access the element at the front of the queue.
T& front() {
MOZ_ASSERT(!empty());
--- a/js/src/ds/InlineTable.h
+++ b/js/src/ds/InlineTable.h
@@ -293,36 +293,36 @@ class InlineTable : private AllocPolicy
if (p.isInlinePtr_) {
InlineEntry* addPtr = p.inlAddPtr_;
MOZ_ASSERT(addPtr == inlineEnd());
// Switching to table mode before we add this pointer.
if (addPtr == inlineStart() + InlineEntries) {
if (!switchToTable())
return false;
- return table_.putNew(mozilla::Forward<KeyInput>(key),
- mozilla::Forward<Args>(args)...);
+ return table_.putNew(std::forward<KeyInput>(key),
+ std::forward<Args>(args)...);
}
MOZ_ASSERT(!p.found());
MOZ_ASSERT(uintptr_t(inlineEnd()) == uintptr_t(p.inlAddPtr_));
if (!this->checkSimulatedOOM())
return false;
- addPtr->update(mozilla::Forward<KeyInput>(key),
- mozilla::Forward<Args>(args)...);
+ addPtr->update(std::forward<KeyInput>(key),
+ std::forward<Args>(args)...);
++inlCount_;
++inlNext_;
return true;
}
return table_.add(p.tableAddPtr_,
- mozilla::Forward<KeyInput>(key),
- mozilla::Forward<Args>(args)...);
+ std::forward<KeyInput>(key),
+ std::forward<Args>(args)...);
}
void remove(Ptr& p) {
MOZ_ASSERT(p);
if (p.isInlinePtr_) {
MOZ_ASSERT(inlCount_ > 0);
MOZ_ASSERT(p.inlPtr_->key != nullptr);
p.inlPtr_->key = nullptr;
@@ -435,18 +435,18 @@ class InlineMap
struct InlineEntry
{
Key key;
Value value;
template <typename KeyInput, typename ValueInput>
void update(KeyInput&& key, ValueInput&& value) {
- this->key = mozilla::Forward<KeyInput>(key);
- this->value = mozilla::Forward<ValueInput>(value);
+ this->key = std::forward<KeyInput>(key);
+ this->value = std::forward<ValueInput>(value);
}
MOZ_MUST_USE bool moveTo(Map& map) {
return map.putNew(std::move(key), std::move(value));
}
};
class Entry
@@ -532,27 +532,27 @@ class InlineMap
MOZ_ALWAYS_INLINE
AddPtr lookupForAdd(const Lookup& l) {
return impl_.lookupForAdd(l);
}
template <typename KeyInput, typename ValueInput>
MOZ_ALWAYS_INLINE
MOZ_MUST_USE bool add(AddPtr& p, KeyInput&& key, ValueInput&& value) {
- return impl_.add(p, mozilla::Forward<KeyInput>(key), mozilla::Forward<ValueInput>(value));
+ return impl_.add(p, std::forward<KeyInput>(key), std::forward<ValueInput>(value));
}
template <typename KeyInput, typename ValueInput>
MOZ_MUST_USE bool put(KeyInput&& key, ValueInput&& value) {
AddPtr p = lookupForAdd(key);
if (p) {
- p->value() = mozilla::Forward<ValueInput>(value);
+ p->value() = std::forward<ValueInput>(value);
return true;
}
- return add(p, mozilla::Forward<KeyInput>(key), mozilla::Forward<ValueInput>(value));
+ return add(p, std::forward<KeyInput>(key), std::forward<ValueInput>(value));
}
void remove(Ptr& p) {
impl_.remove(p);
}
void remove(const Lookup& l) {
impl_.remove(l);
@@ -574,17 +574,17 @@ class InlineSet
using Set = HashSet<T, HashPolicy, AllocPolicy>;
struct InlineEntry
{
T key;
template <typename TInput>
void update(TInput&& key) {
- this->key = mozilla::Forward<TInput>(key);
+ this->key = std::forward<TInput>(key);
}
MOZ_MUST_USE bool moveTo(Set& set) {
return set.putNew(std::move(key));
}
};
class Entry
@@ -663,23 +663,23 @@ class InlineSet
MOZ_ALWAYS_INLINE
AddPtr lookupForAdd(const Lookup& l) {
return impl_.lookupForAdd(l);
}
template <typename TInput>
MOZ_ALWAYS_INLINE
MOZ_MUST_USE bool add(AddPtr& p, TInput&& key) {
- return impl_.add(p, mozilla::Forward<TInput>(key));
+ return impl_.add(p, std::forward<TInput>(key));
}
template <typename TInput>
MOZ_MUST_USE bool put(TInput&& key) {
AddPtr p = lookupForAdd(key);
- return p ? true : add(p, mozilla::Forward<TInput>(key));
+ return p ? true : add(p, std::forward<TInput>(key));
}
void remove(Ptr& p) {
impl_.remove(p);
}
void remove(const Lookup& l) {
impl_.remove(l);
--- a/js/src/ds/LifoAlloc.h
+++ b/js/src/ds/LifoAlloc.h
@@ -601,17 +601,17 @@ class LifoAlloc
{
MOZ_ASSERT(n >= sizeof(T), "must request enough space to store a T");
static_assert(alignof(T) <= detail::LIFO_ALLOC_ALIGN,
"LifoAlloc must provide enough alignment to store T");
void* ptr = alloc(n);
if (!ptr)
return nullptr;
- return new (ptr) T(mozilla::Forward<Args>(args)...);
+ return new (ptr) T(std::forward<Args>(args)...);
}
MOZ_ALWAYS_INLINE
void* allocInfallible(size_t n) {
AutoEnterOOMUnsafeRegion oomUnsafe;
if (void* result = allocImpl(n))
return result;
oomUnsafe.crash("LifoAlloc::allocInfallible");
--- a/js/src/ds/OrderedHashTable.h
+++ b/js/src/ds/OrderedHashTable.h
@@ -35,18 +35,16 @@
* following static member functions:
* bool isEmpty(const Key&);
* void makeEmpty(Key*);
*/
#include "mozilla/HashFunctions.h"
#include "mozilla/Move.h"
-using mozilla::Forward;
-
namespace js {
namespace detail {
/*
* detail::OrderedHashTable is the underlying data structure used to implement both
* OrderedHashMap and OrderedHashSet. Programs should use one of those two
* templates rather than OrderedHashTable.
@@ -171,32 +169,32 @@ class OrderedHashTable
* On success, return true, whether there was already a matching element or
* not. On allocation failure, return false. If this returns false, it
* means the element was not added to the table.
*/
template <typename ElementInput>
MOZ_MUST_USE bool put(ElementInput&& element) {
HashNumber h = prepareHash(Ops::getKey(element));
if (Data* e = lookup(Ops::getKey(element), h)) {
- e->element = Forward<ElementInput>(element);
+ e->element = std::forward<ElementInput>(element);
return true;
}
if (dataLength == dataCapacity) {
// If the hashTable is more than 1/4 deleted data, simply rehash in
// place to free up some space. Otherwise, grow the table.
uint32_t newHashShift = liveCount >= dataCapacity * 0.75 ? hashShift - 1 : hashShift;
if (!rehash(newHashShift))
return false;
}
h >>= hashShift;
liveCount++;
Data* e = &data[dataLength++];
- new (e) Data(Forward<ElementInput>(element), hashTable[h]);
+ new (e) Data(std::forward<ElementInput>(element), hashTable[h]);
hashTable[h] = e;
return true;
}
/*
* If the table contains an element matching l, remove it and set *foundp
* to true. Otherwise set *foundp to false.
*
@@ -756,17 +754,17 @@ class OrderedHashMap
MOZ_ASSERT(this != &rhs, "self-move assignment is prohibited");
const_cast<Key&>(key) = std::move(rhs.key);
value = std::move(rhs.value);
}
public:
Entry() : key(), value() {}
template <typename V>
- Entry(const Key& k, V&& v) : key(k), value(Forward<V>(v)) {}
+ Entry(const Key& k, V&& v) : key(k), value(std::forward<V>(v)) {}
Entry(Entry&& rhs) : key(std::move(rhs.key)), value(std::move(rhs.value)) {}
const Key key;
Value value;
static size_t offsetOfKey() {
return offsetof(Entry, key);
}
@@ -803,17 +801,17 @@ class OrderedHashMap
Range all() { return impl.all(); }
const Entry* get(const Key& key) const { return impl.get(key); }
Entry* get(const Key& key) { return impl.get(key); }
bool remove(const Key& key, bool* foundp) { return impl.remove(key, foundp); }
MOZ_MUST_USE bool clear() { return impl.clear(); }
template <typename V>
MOZ_MUST_USE bool put(const Key& key, V&& value) {
- return impl.put(Entry(key, Forward<V>(value)));
+ return impl.put(Entry(key, std::forward<V>(value)));
}
HashNumber hash(const Key& key) const { return impl.prepareHash(key); }
void rekeyOneEntry(const Key& current, const Key& newKey) {
const Entry* e = get(current);
if (!e)
return;
--- a/js/src/ds/TraceableFifo.h
+++ b/js/src/ds/TraceableFifo.h
@@ -69,19 +69,19 @@ class MutableWrappedPtrOperations<Tracea
: public WrappedPtrOperations<TraceableFifo<T, Capacity, AllocPolicy>, Wrapper>
{
using TF = TraceableFifo<T, Capacity, AllocPolicy>;
TF& fifo() { return static_cast<Wrapper*>(this)->get(); }
public:
T& front() { return fifo().front(); }
- template<typename U> bool pushBack(U&& u) { return fifo().pushBack(mozilla::Forward<U>(u)); }
+ template<typename U> bool pushBack(U&& u) { return fifo().pushBack(std::forward<U>(u)); }
template<typename... Args> bool emplaceBack(Args&&... args) {
- return fifo().emplaceBack(mozilla::Forward<Args...>(args...));
+ return fifo().emplaceBack(std::forward<Args...>(args...));
}
void popFront() { fifo().popFront(); }
void clear() { fifo().clear(); }
};
} // namespace js
--- a/js/src/frontend/EitherParser.h
+++ b/js/src/frontend/EitherParser.h
@@ -41,17 +41,17 @@ struct InvokeMemberFunction
-> 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)... }
+ : args { std::forward<ActualArgs>(actualArgs)... }
{}
template<class Parser>
auto
match(Parser* parser)
-> decltype(this->matchInternal(GetThis<Parser>::get(parser),
std::index_sequence_for<Args...>{}))
{
--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -6247,17 +6247,17 @@ struct IncrementalIter
State& maybeIter;
public:
template <typename... Args>
explicit IncrementalIter(State& maybeIter, Args&&... args)
: maybeIter(maybeIter)
{
if (maybeIter.isNothing())
- maybeIter.emplace(mozilla::Forward<Args>(args)...);
+ maybeIter.emplace(std::forward<Args>(args)...);
}
~IncrementalIter() {
if (done())
maybeIter.reset();
}
bool done() const {
--- a/js/src/gc/Marking.cpp
+++ b/js/src/gc/Marking.cpp
@@ -1461,39 +1461,39 @@ CallTraceHook(Functor f, JSTracer* trc,
MOZ_ASSERT(clasp);
MOZ_ASSERT(obj->isNative() == clasp->isNative());
if (!clasp->hasTrace())
return &obj->as<NativeObject>();
if (clasp->isTrace(InlineTypedObject::obj_trace)) {
Shape** pshape = obj->as<InlineTypedObject>().addressOfShapeFromGC();
- f(pshape, mozilla::Forward<Args>(args)...);
+ f(pshape, std::forward<Args>(args)...);
InlineTypedObject& tobj = obj->as<InlineTypedObject>();
if (tobj.typeDescr().hasTraceList()) {
VisitTraceList(f, tobj.typeDescr().traceList(), tobj.inlineTypedMemForGC(),
- mozilla::Forward<Args>(args)...);
+ std::forward<Args>(args)...);
}
return nullptr;
}
if (clasp == &UnboxedPlainObject::class_) {
JSObject** pexpando = obj->as<UnboxedPlainObject>().addressOfExpando();
if (*pexpando)
- f(pexpando, mozilla::Forward<Args>(args)...);
+ f(pexpando, std::forward<Args>(args)...);
UnboxedPlainObject& unboxed = obj->as<UnboxedPlainObject>();
const UnboxedLayout& layout = check == CheckGeneration::DoChecks
? unboxed.layout()
: unboxed.layoutDontCheckGeneration();
if (layout.traceList()) {
VisitTraceList(f, layout.traceList(), unboxed.data(),
- mozilla::Forward<Args>(args)...);
+ std::forward<Args>(args)...);
}
return nullptr;
}
clasp->doTrace(trc, obj);
if (!clasp->isNative())
@@ -1501,29 +1501,29 @@ CallTraceHook(Functor f, JSTracer* trc,
return &obj->as<NativeObject>();
}
template <typename F, typename... Args>
static void
VisitTraceList(F f, const int32_t* traceList, uint8_t* memory, Args&&... args)
{
while (*traceList != -1) {
- f(reinterpret_cast<JSString**>(memory + *traceList), mozilla::Forward<Args>(args)...);
+ f(reinterpret_cast<JSString**>(memory + *traceList), std::forward<Args>(args)...);
traceList++;
}
traceList++;
while (*traceList != -1) {
JSObject** objp = reinterpret_cast<JSObject**>(memory + *traceList);
if (*objp)
- f(objp, mozilla::Forward<Args>(args)...);
+ f(objp, std::forward<Args>(args)...);
traceList++;
}
traceList++;
while (*traceList != -1) {
- f(reinterpret_cast<Value*>(memory + *traceList), mozilla::Forward<Args>(args)...);
+ f(reinterpret_cast<Value*>(memory + *traceList), std::forward<Args>(args)...);
traceList++;
}
}
/*** Mark-stack Marking ***************************************************************************/
bool
--- a/js/src/gc/Zone.h
+++ b/js/src/gc/Zone.h
@@ -202,17 +202,17 @@ struct Zone : public JS::shadow::Zone,
size_t* uniqueIdMap,
size_t* shapeTables,
size_t* atomsMarkBitmaps);
// Iterate over all cells in the zone. See the definition of ZoneCellIter
// in gc/GC-inl.h for the possible arguments and documentation.
template <typename T, typename... Args>
js::gc::ZoneCellIter<T> cellIter(Args&&... args) {
- return js::gc::ZoneCellIter<T>(const_cast<Zone*>(this), mozilla::Forward<Args>(args)...);
+ return js::gc::ZoneCellIter<T>(const_cast<Zone*>(this), std::forward<Args>(args)...);
}
MOZ_MUST_USE void* onOutOfMemory(js::AllocFunction allocFunc, size_t nbytes,
void* reallocPtr = nullptr) {
if (!js::CurrentThreadCanAccessRuntime(runtime_))
return nullptr;
return runtimeFromMainThread()->onOutOfMemory(allocFunc, nbytes, reallocPtr);
}
--- a/js/src/jit/IonControlFlow.h
+++ b/js/src/jit/IonControlFlow.h
@@ -20,22 +20,22 @@ namespace jit {
class CFGControlInstruction;
// Adds MFoo::New functions which are mirroring the arguments of the
// constructors. Opcodes which are using this macro can be called with a
// TempAllocator, or the fallible version of the TempAllocator.
#define TRIVIAL_CFG_NEW_WRAPPERS \
template <typename... Args> \
static CFGThisOpcode* New(TempAllocator& alloc, Args&&... args) { \
- return new(alloc) CFGThisOpcode(mozilla::Forward<Args>(args)...); \
+ return new(alloc) CFGThisOpcode(std::forward<Args>(args)...); \
} \
template <typename... Args> \
static CFGThisOpcode* New(TempAllocator::Fallible alloc, Args&&... args) \
{ \
- return new(alloc) CFGThisOpcode(mozilla::Forward<Args>(args)...); \
+ return new(alloc) CFGThisOpcode(std::forward<Args>(args)...); \
}
class CFGSpace
{
static const size_t DEFAULT_CHUNK_SIZE = 4096;
protected:
LifoAlloc allocator_;
--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -1246,33 +1246,33 @@ class MInstruction
}
// Adds MFoo::New functions which are mirroring the arguments of the
// constructors. Opcodes which are using this macro can be called with a
// TempAllocator, or the fallible version of the TempAllocator.
#define TRIVIAL_NEW_WRAPPERS \
template <typename... Args> \
static MThisOpcode* New(TempAllocator& alloc, Args&&... args) { \
- return new(alloc) MThisOpcode(mozilla::Forward<Args>(args)...); \
+ return new(alloc) MThisOpcode(std::forward<Args>(args)...); \
} \
template <typename... Args> \
static MThisOpcode* New(TempAllocator::Fallible alloc, Args&&... args) \
{ \
- return new(alloc) MThisOpcode(mozilla::Forward<Args>(args)...); \
+ return new(alloc) MThisOpcode(std::forward<Args>(args)...); \
}
#define TRIVIAL_NEW_WRAPPERS_WITH_ALLOC \
template <typename... Args> \
static MThisOpcode* New(TempAllocator& alloc, Args&&... args) { \
- return new(alloc) MThisOpcode(alloc, mozilla::Forward<Args>(args)...); \
+ return new(alloc) MThisOpcode(alloc, std::forward<Args>(args)...); \
} \
template <typename... Args> \
static MThisOpcode* New(TempAllocator::Fallible alloc, Args&&... args) \
{ \
- return new(alloc) MThisOpcode(alloc, mozilla::Forward<Args>(args)...); \
+ return new(alloc) MThisOpcode(alloc, std::forward<Args>(args)...); \
}
// These macros are used as a syntactic sugar for writting getOperand
// accessors. They are meant to be used in the body of MIR Instructions as
// follows:
//
// public:
// INSTRUCTION_HEADER(Foo)
--- a/js/src/jit/SharedIC.h
+++ b/js/src/jit/SharedIC.h
@@ -531,17 +531,17 @@ class ICStub
void traceCode(JSTracer* trc, const char* name);
void updateCode(JitCode* stubCode);
void trace(JSTracer* trc);
template <typename T, typename... Args>
static T* New(JSContext* cx, ICStubSpace* space, JitCode* code, Args&&... args) {
if (!code)
return nullptr;
- T* result = space->allocate<T>(code, mozilla::Forward<Args>(args)...);
+ T* result = space->allocate<T>(code, std::forward<Args>(args)...);
if (!result)
ReportOutOfMemory(cx);
return result;
}
protected:
// The raw jitcode to call for this stub.
uint8_t* stubCode_;
@@ -1125,17 +1125,17 @@ class ICStubCompiler
}
return regs;
}
protected:
template <typename T, typename... Args>
T* newStub(Args&&... args) {
- return ICStub::New<T>(cx, mozilla::Forward<Args>(args)...);
+ return ICStub::New<T>(cx, std::forward<Args>(args)...);
}
public:
virtual ICStub* getStub(ICStubSpace* space) = 0;
static ICStubSpace* StubSpaceForStub(bool makesGCCalls, JSScript* outerScript, Engine engine) {
if (makesGCCalls) {
if (engine == ICStubCompiler::Engine::Baseline)
--- a/js/src/jit/shared/Assembler-shared.h
+++ b/js/src/jit/shared/Assembler-shared.h
@@ -922,17 +922,17 @@ class AssemblerShared
}
// WebAssembly metadata emitted by masm operations accumulated on the
// MacroAssembler, and swapped into a wasm::CompiledCode after finish().
template <typename... Args>
void append(const wasm::CallSiteDesc& desc, CodeOffset retAddr, Args&&... args) {
enoughMemory_ &= callSites_.emplaceBack(desc, retAddr.offset());
- enoughMemory_ &= callSiteTargets_.emplaceBack(mozilla::Forward<Args>(args)...);
+ enoughMemory_ &= callSiteTargets_.emplaceBack(std::forward<Args>(args)...);
}
void append(wasm::Trap trap, wasm::TrapSite site) {
enoughMemory_ &= trapSites_[trap].append(site);
}
void append(wasm::CallFarJump jmp) {
enoughMemory_ &= callFarJumps_.append(jmp);
}
void append(const wasm::MemoryAccessDesc& access, uint32_t pcOffset) {
--- a/js/src/jit/shared/CodeGenerator-shared.h
+++ b/js/src/jit/shared/CodeGenerator-shared.h
@@ -648,33 +648,33 @@ class ArgSeq<HeadType, TailTypes...> : p
{
private:
using RawHeadType = typename mozilla::RemoveReference<HeadType>::Type;
RawHeadType head_;
public:
template <typename ProvidedHead, typename... ProvidedTail>
explicit ArgSeq(ProvidedHead&& head, ProvidedTail&&... tail)
- : ArgSeq<TailTypes...>(mozilla::Forward<ProvidedTail>(tail)...),
- head_(mozilla::Forward<ProvidedHead>(head))
+ : ArgSeq<TailTypes...>(std::forward<ProvidedTail>(tail)...),
+ head_(std::forward<ProvidedHead>(head))
{ }
// Arguments are pushed in reverse order, from last argument to first
// argument.
inline void generate(CodeGeneratorShared* codegen) const {
this->ArgSeq<TailTypes...>::generate(codegen);
codegen->pushArg(head_);
}
};
template <typename... ArgTypes>
inline ArgSeq<ArgTypes...>
ArgList(ArgTypes&&... args)
{
- return ArgSeq<ArgTypes...>(mozilla::Forward<ArgTypes>(args)...);
+ return ArgSeq<ArgTypes...>(std::forward<ArgTypes>(args)...);
}
// Store wrappers, to generate the right move of data after the VM call.
struct StoreNothing
{
inline void generate(CodeGeneratorShared* codegen) const {
}
--- a/js/src/jit/shared/Lowering-shared-inl.h
+++ b/js/src/jit/shared/Lowering-shared-inl.h
@@ -475,17 +475,17 @@ LClass*
LIRGeneratorShared::allocateVariadic(uint32_t numOperands, Args&&... args)
{
size_t numBytes = sizeof(LClass) + numOperands * sizeof(LAllocation);
void* buf = alloc().allocate(numBytes);
if (!buf)
return nullptr;
LClass* ins = static_cast<LClass*>(buf);
- new(ins) LClass(numOperands, mozilla::Forward<Args>(args)...);
+ new(ins) LClass(numOperands, std::forward<Args>(args)...);
ins->initOperandsOffset(sizeof(LClass));
for (uint32_t i = 0; i < numOperands; i++)
ins->setOperand(i, LAllocation());
return ins;
}
--- a/js/src/threading/ExclusiveData.h
+++ b/js/src/threading/ExclusiveData.h
@@ -94,26 +94,26 @@ class ExclusiveData
public:
/**
* Create a new `ExclusiveData`, with perfect forwarding of the protected
* value.
*/
template <typename U>
explicit ExclusiveData(const MutexId& id, U&& u)
: lock_(id),
- value_(mozilla::Forward<U>(u))
+ value_(std::forward<U>(u))
{}
/**
* Create a new `ExclusiveData`, constructing the protected value in place.
*/
template <typename... Args>
explicit ExclusiveData(const MutexId& id, Args&&... args)
: lock_(id),
- value_(mozilla::Forward<Args>(args)...)
+ value_(std::forward<Args>(args)...)
{}
ExclusiveData(ExclusiveData&& rhs)
: lock_(std::move(rhs.lock)),
value_(std::move(rhs.value_))
{
MOZ_ASSERT(&rhs != this, "self-move disallowed!");
}
@@ -191,22 +191,22 @@ class ExclusiveWaitableData : public Exc
{
typedef ExclusiveData<T> Base;
mutable ConditionVariable condVar_;
public:
template <typename U>
explicit ExclusiveWaitableData(const MutexId& id, U&& u)
- : Base(id, mozilla::Forward<U>(u))
+ : Base(id, std::forward<U>(u))
{}
template <typename... Args>
explicit ExclusiveWaitableData(const MutexId& id, Args&&... args)
- : Base(id, mozilla::Forward<Args>(args)...)
+ : Base(id, std::forward<Args>(args)...)
{}
class MOZ_STACK_CLASS Guard : public ExclusiveData<T>::Guard
{
typedef typename ExclusiveData<T>::Guard Base;
public:
explicit Guard(const ExclusiveWaitableData& parent)
--- a/js/src/threading/ProtectedData.h
+++ b/js/src/threading/ProtectedData.h
@@ -67,17 +67,17 @@ class MOZ_RAII AutoNoteSingleThreadedReg
template <typename Check, typename T>
class ProtectedData
{
typedef ProtectedData<Check, T> ThisType;
public:
template <typename... Args>
explicit ProtectedData(const Check& check, Args&&... args)
- : value(mozilla::Forward<Args>(args)...)
+ : value(std::forward<Args>(args)...)
#ifdef JS_HAS_PROTECTED_DATA_CHECKS
, check(check)
#endif
{}
DECLARE_BOOL_OPERATORS(T)
operator const T&() const { return ref(); }
@@ -131,33 +131,33 @@ class ProtectedData
template <typename Check, typename T>
class ProtectedDataNoCheckArgs : public ProtectedData<Check, T>
{
typedef ProtectedDataNoCheckArgs<Check, T> ThisType;
public:
template <typename... Args>
explicit ProtectedDataNoCheckArgs(Args&&... args)
- : ProtectedData<Check, T>(Check(), mozilla::Forward<Args>(args)...)
+ : ProtectedData<Check, T>(Check(), std::forward<Args>(args)...)
{}
template <typename U>
ThisType& operator=(const U& p) { this->ref() = p; return *this; }
};
// Intermediate class for protected data whose checks take a Zone constructor argument.
template <typename Check, typename T>
class ProtectedDataZoneArg : public ProtectedData<Check, T>
{
typedef ProtectedDataZoneArg<Check, T> ThisType;
public:
template <typename... Args>
explicit ProtectedDataZoneArg(JS::Zone* zone, Args&&... args)
- : ProtectedData<Check, T>(Check(zone), mozilla::Forward<Args>(args)...)
+ : ProtectedData<Check, T>(Check(zone), std::forward<Args>(args)...)
{}
template <typename U>
ThisType& operator=(const U& p) { this->ref() = p; return *this; }
};
class CheckUnprotected
{
@@ -310,17 +310,17 @@ using HelperThreadLockData =
template <typename Check, typename T>
class ProtectedDataWriteOnce
{
typedef ProtectedDataWriteOnce<Check, T> ThisType;
public:
template <typename... Args>
explicit ProtectedDataWriteOnce(Args&&... args)
- : value(mozilla::Forward<Args>(args)...)
+ : value(std::forward<Args>(args)...)
#ifdef JS_HAS_PROTECTED_DATA_CHECKS
, nwrites(0)
#endif
{}
DECLARE_BOOL_OPERATORS(T)
operator const T&() const { return ref(); }
--- a/js/src/threading/Thread.h
+++ b/js/src/threading/Thread.h
@@ -96,34 +96,34 @@ public:
// constructor as an Options and vice versa.
typename NonConstO = typename mozilla::RemoveConst<O>::Type,
typename DerefO = typename mozilla::RemoveReference<NonConstO>::Type,
typename = typename mozilla::EnableIf<mozilla::IsSame<DerefO, Options>::value,
void*>::Type>
explicit Thread(O&& options = Options())
: idMutex_(mutexid::ThreadId)
, id_(Id())
- , options_(mozilla::Forward<O>(options))
+ , options_(std::forward<O>(options))
{
MOZ_ASSERT(js::IsInitialized());
}
// Start a thread of execution at functor |f| with parameters |args|. This
// method will return false if thread creation fails. This Thread must not
// already have been created. Note that the arguments must be either POD or
// rvalue references (std::move). Attempting to pass a reference will
// result in the value being copied, which may not be the intended behavior.
// See the comment below on ThreadTrampoline::args for an explanation.
template <typename F, typename... Args>
MOZ_MUST_USE bool init(F&& f, Args&&... args) {
MOZ_RELEASE_ASSERT(id_ == Id());
using Trampoline = detail::ThreadTrampoline<F, Args...>;
AutoEnterOOMUnsafeRegion oom;
- auto trampoline = js_new<Trampoline>(mozilla::Forward<F>(f),
- mozilla::Forward<Args>(args)...);
+ auto trampoline = js_new<Trampoline>(std::forward<F>(f),
+ std::forward<Args>(args)...);
if (!trampoline)
oom.crash("js::Thread::init");
return create(Trampoline::Start, trampoline);
}
// The thread must be joined or detached before destruction.
~Thread();
@@ -220,18 +220,18 @@ class ThreadTrampoline
public:
// Note that this template instatiation duplicates and is identical to the
// class template instantiation. It is required for perfect forwarding of
// rvalue references, which is only enabled for calls to a function template,
// even if the class template arguments are correct.
template <typename G, typename... ArgsT>
explicit ThreadTrampoline(G&& aG, ArgsT&&... aArgsT)
- : f(mozilla::Forward<F>(aG)),
- args(mozilla::Forward<Args>(aArgsT)...)
+ : f(std::forward<F>(aG)),
+ args(std::forward<Args>(aArgsT)...)
{
}
static THREAD_RETURN_TYPE THREAD_CALL_API Start(void* aPack) {
auto* pack = static_cast<ThreadTrampoline<F, Args...>*>(aPack);
pack->callMain(std::index_sequence_for<Args...>{});
js_delete(pack);
return 0;
--- a/js/src/vm/DebuggerMemory.cpp
+++ b/js/src/vm/DebuggerMemory.cpp
@@ -26,17 +26,16 @@
#include "vm/JSContext.h"
#include "vm/SavedStacks.h"
#include "vm/Debugger-inl.h"
#include "vm/NativeObject-inl.h"
using namespace js;
-using mozilla::Forward;
using mozilla::Maybe;
using mozilla::Nothing;
/* static */ DebuggerMemory*
DebuggerMemory::create(JSContext* cx, Debugger* dbg)
{
Value memoryProtoValue = dbg->object->getReservedSlot(Debugger::JSSLOT_DEBUG_MEMORY_PROTO);
RootedObject memoryProto(cx, &memoryProtoValue.toObject());
--- a/js/src/vm/ObjectGroup.cpp
+++ b/js/src/vm/ObjectGroup.cpp
@@ -429,20 +429,20 @@ struct ObjectGroupRealm::NewEntry
}
};
namespace js {
template <>
struct FallibleHashMethods<ObjectGroupRealm::NewEntry>
{
template <typename Lookup> static bool hasHash(Lookup&& l) {
- return ObjectGroupRealm::NewEntry::hasHash(mozilla::Forward<Lookup>(l));
+ return ObjectGroupRealm::NewEntry::hasHash(std::forward<Lookup>(l));
}
template <typename Lookup> static bool ensureHash(Lookup&& l) {
- return ObjectGroupRealm::NewEntry::ensureHash(mozilla::Forward<Lookup>(l));
+ return ObjectGroupRealm::NewEntry::ensureHash(std::forward<Lookup>(l));
}
};
} // namespace js
class ObjectGroupRealm::NewTable : public JS::WeakCache<js::GCHashSet<NewEntry, NewEntry,
SystemAllocPolicy>>
{
using Table = js::GCHashSet<NewEntry, NewEntry, SystemAllocPolicy>;
--- a/js/src/vm/SavedFrame.h
+++ b/js/src/vm/SavedFrame.h
@@ -171,20 +171,20 @@ struct SavedFrame::HashPolicy
typedef ReadBarriered<SavedFrame*> Key;
static void rekey(Key& key, const Key& newKey);
};
template <>
struct FallibleHashMethods<SavedFrame::HashPolicy>
{
template <typename Lookup> static bool hasHash(Lookup&& l) {
- return SavedFrame::HashPolicy::hasHash(mozilla::Forward<Lookup>(l));
+ return SavedFrame::HashPolicy::hasHash(std::forward<Lookup>(l));
}
template <typename Lookup> static bool ensureHash(Lookup&& l) {
- return SavedFrame::HashPolicy::ensureHash(mozilla::Forward<Lookup>(l));
+ return SavedFrame::HashPolicy::ensureHash(std::forward<Lookup>(l));
}
};
// Assert that if the given object is not null, that it must be either a
// SavedFrame object or wrapper (Xray or CCW) around a SavedFrame object.
inline void AssertObjectIsSavedFrameOrWrapper(JSContext* cx, HandleObject stack);
// When we reconstruct a SavedFrame stack from a JS::ubi::StackFrame, we may not
--- a/js/src/vm/TaggedProto.h
+++ b/js/src/vm/TaggedProto.h
@@ -132,20 +132,20 @@ class WrappedPtrOperations<TaggedProto,
uint64_t uniqueId() const { return value().uniqueId(); }
};
// If the TaggedProto is a JSObject pointer, convert to that type and call |f|
// with the pointer. If the TaggedProto is lazy, calls F::defaultValue.
template <typename F, typename... Args>
auto
DispatchTyped(F f, const TaggedProto& proto, Args&&... args)
- -> decltype(f(static_cast<JSObject*>(nullptr), mozilla::Forward<Args>(args)...))
+ -> decltype(f(static_cast<JSObject*>(nullptr), std::forward<Args>(args)...))
{
if (proto.isObject())
- return f(proto.toObject(), mozilla::Forward<Args>(args)...);
+ return f(proto.toObject(), std::forward<Args>(args)...);
return F::defaultValue(proto);
}
// Since JSObject pointers are either nullptr or a valid object and since the
// object layout of TaggedProto is identical to a bare object pointer, we can
// safely treat a pointer to an already-rooted object (e.g. HandleObject) as a
// pointer to a TaggedProto.
inline Handle<TaggedProto>
--- a/js/src/wasm/WasmBaselineCompile.cpp
+++ b/js/src/wasm/WasmBaselineCompile.cpp
@@ -2303,17 +2303,17 @@ class BaseCompiler final : public BaseCo
uint32_t slot() const { MOZ_ASSERT(kind_ > MemLast && kind_ <= LocalLast); return slot_; }
uint32_t offs() const { MOZ_ASSERT(isMem()); return offs_; }
};
Vector<Stk, 8, SystemAllocPolicy> stk_;
template<typename... Args>
void push(Args&&... args) {
- stk_.infallibleEmplaceBack(Stk(Forward<Args>(args)...));
+ stk_.infallibleEmplaceBack(Stk(std::forward<Args>(args)...));
}
void pushConstRef(intptr_t v) {
stk_.infallibleEmplaceBack(Stk::StkRef(v));
}
void loadConstI32(const Stk& src, RegI32 dest) {
moveImm32(src.i32val(), dest);
--- a/js/xpconnect/loader/ScriptPreloader.cpp
+++ b/js/xpconnect/loader/ScriptPreloader.cpp
@@ -804,17 +804,17 @@ ScriptPreloader::NoteScript(const nsCStr
}
auto script = mScripts.LookupOrAdd(cachePath, *this, url, cachePath, nullptr);
if (!script->HasRange()) {
MOZ_ASSERT(!script->HasArray());
script->mSize = xdrData.Length();
- script->mXDRData.construct<nsTArray<uint8_t>>(Forward<nsTArray<uint8_t>>(xdrData));
+ script->mXDRData.construct<nsTArray<uint8_t>>(std::forward<nsTArray<uint8_t>>(xdrData));
auto& data = script->Array();
script->mXDRRange.emplace(data.Elements(), data.Length());
}
if (!script->mSize && !script->mScript) {
// If the content process is sending us a script entry for a script
// which was in the cache at startup, it expects us to already have this
--- a/layout/painting/nsDisplayList.h
+++ b/layout/painting/nsDisplayList.h
@@ -2006,17 +2006,17 @@ class nsDisplayWrapList;
#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
void AssertUniqueItem(nsDisplayItem* aItem);
#endif
template<typename T, typename... Args>
MOZ_ALWAYS_INLINE T*
MakeDisplayItem(nsDisplayListBuilder* aBuilder, Args&&... aArgs)
{
- T* item = new (aBuilder) T(aBuilder, mozilla::Forward<Args>(aArgs)...);
+ T* item = new (aBuilder) T(aBuilder, std::forward<Args>(aArgs)...);
const mozilla::SmallPointerArray<mozilla::DisplayItemData>& array =
item->Frame()->DisplayItemData();
for (uint32_t i = 0; i < array.Length(); i++) {
mozilla::DisplayItemData* did = array.ElementAt(i);
if (did->GetDisplayItemKey() == item->GetPerFrameKey()) {
if (!did->HasMergedFrames()) {
item->SetDisplayItemData(did);
--- a/media/mtransport/runnable_utils.h
+++ b/media/mtransport/runnable_utils.h
@@ -91,43 +91,43 @@ struct RunnableMethodCallHelper<void>
template<typename FunType, typename... Args>
class runnable_args_func : public detail::runnable_args_base<detail::NoResult>
{
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)...)
+ : mFunc(f), mArgs(std::forward<Arguments>(args)...)
{}
NS_IMETHOD Run() override {
detail::RunnableFunctionCallHelper<void>::apply(mFunc, mArgs, std::index_sequence_for<Args...>{});
return NS_OK;
}
private:
FunType mFunc;
Tuple<Args...> mArgs;
};
template<typename FunType, typename... Args>
runnable_args_func<FunType, typename mozilla::Decay<Args>::Type...>*
WrapRunnableNM(FunType f, Args&&... args)
{
- return new runnable_args_func<FunType, typename mozilla::Decay<Args>::Type...>(f, Forward<Args>(args)...);
+ return new runnable_args_func<FunType, typename mozilla::Decay<Args>::Type...>(f, std::forward<Args>(args)...);
}
template<typename Ret, typename FunType, typename... Args>
class runnable_args_func_ret : public detail::runnable_args_base<detail::ReturnsResult>
{
public:
template<typename... Arguments>
runnable_args_func_ret(Ret* ret, FunType f, Arguments&&... args)
- : mReturn(ret), mFunc(f), mArgs(Forward<Arguments>(args)...)
+ : mReturn(ret), mFunc(f), mArgs(std::forward<Arguments>(args)...)
{}
NS_IMETHOD Run() override {
*mReturn = detail::RunnableFunctionCallHelper<Ret>::apply(mFunc, mArgs, std::index_sequence_for<Args...>{});
return NS_OK;
}
private:
@@ -135,26 +135,26 @@ private:
FunType mFunc;
Tuple<Args...> mArgs;
};
template<typename R, typename FunType, typename... Args>
runnable_args_func_ret<R, FunType, typename mozilla::Decay<Args>::Type...>*
WrapRunnableNMRet(R* ret, FunType f, Args&&... args)
{
- return new runnable_args_func_ret<R, FunType, typename mozilla::Decay<Args>::Type...>(ret, f, Forward<Args>(args)...);
+ return new runnable_args_func_ret<R, FunType, typename mozilla::Decay<Args>::Type...>(ret, f, std::forward<Args>(args)...);
}
template<typename Class, typename M, typename... Args>
class runnable_args_memfn : public detail::runnable_args_base<detail::NoResult>
{
public:
template<typename... Arguments>
runnable_args_memfn(Class obj, M method, Arguments&&... args)
- : mObj(obj), mMethod(method), mArgs(Forward<Arguments>(args)...)
+ : mObj(obj), mMethod(method), mArgs(std::forward<Arguments>(args)...)
{}
NS_IMETHOD Run() override {
detail::RunnableMethodCallHelper<void>::apply(mObj, mMethod, mArgs, std::index_sequence_for<Args...>{});
return NS_OK;
}
private:
@@ -162,26 +162,26 @@ private:
M mMethod;
Tuple<Args...> mArgs;
};
template<typename Class, typename M, typename... Args>
runnable_args_memfn<Class, M, typename mozilla::Decay<Args>::Type...>*
WrapRunnable(Class obj, M method, Args&&... args)
{
- return new runnable_args_memfn<Class, M, typename mozilla::Decay<Args>::Type...>(obj, method, Forward<Args>(args)...);
+ return new runnable_args_memfn<Class, M, typename mozilla::Decay<Args>::Type...>(obj, method, std::forward<Args>(args)...);
}
template<typename Ret, typename Class, typename M, typename... Args>
class runnable_args_memfn_ret : public detail::runnable_args_base<detail::ReturnsResult>
{
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)...)
+ : mReturn(ret), mObj(obj), mMethod(method), mArgs(std::forward<Arguments>(args)...)
{}
NS_IMETHOD Run() override {
*mReturn = detail::RunnableMethodCallHelper<Ret>::apply(mObj, mMethod, mArgs, std::index_sequence_for<Args...>{});
return NS_OK;
}
private:
@@ -190,17 +190,17 @@ private:
M mMethod;
Tuple<Args...> mArgs;
};
template<typename R, typename Class, typename M, typename... Args>
runnable_args_memfn_ret<R, Class, M, typename mozilla::Decay<Args>::Type...>*
WrapRunnableRet(R* ret, Class obj, M method, Args&&... args)
{
- return new runnable_args_memfn_ret<R, Class, M, typename mozilla::Decay<Args>::Type...>(ret, obj, method, Forward<Args>(args)...);
+ return new runnable_args_memfn_ret<R, Class, M, typename mozilla::Decay<Args>::Type...>(ret, obj, method, std::forward<Args>(args)...);
}
static inline nsresult RUN_ON_THREAD(nsIEventTarget *thread, detail::runnable_args_base<detail::NoResult> *runnable, uint32_t flags) {
return detail::RunOnThreadInternal(thread, static_cast<nsIRunnable *>(runnable), flags);
}
static inline nsresult
RUN_ON_THREAD(nsIEventTarget *thread, detail::runnable_args_base<detail::ReturnsResult> *runnable)
--- a/mfbt/Array.h
+++ b/mfbt/Array.h
@@ -23,17 +23,17 @@ class Array
{
T mArr[Length];
public:
Array() {}
template <typename... Args>
MOZ_IMPLICIT Array(Args&&... aArgs)
- : mArr{mozilla::Forward<Args>(aArgs)...}
+ : mArr{std::forward<Args>(aArgs)...}
{
static_assert(sizeof...(aArgs) == Length,
"The number of arguments should be equal to the template parameter Length");
}
T& operator[](size_t aIndex)
{
MOZ_ASSERT(aIndex < Length);
--- a/mfbt/EnumeratedArray.h
+++ b/mfbt/EnumeratedArray.h
@@ -51,17 +51,17 @@ private:
ArrayType mArray;
public:
EnumeratedArray() {}
template <typename... Args>
MOZ_IMPLICIT EnumeratedArray(Args&&... aArgs)
- : mArray{mozilla::Forward<Args>(aArgs)...}
+ : mArray{std::forward<Args>(aArgs)...}
{}
explicit EnumeratedArray(const EnumeratedArray& aOther)
{
for (size_t i = 0; i < kSize; i++) {
mArray[i] = aOther.mArray[i];
}
}
--- a/mfbt/LinkedList.h
+++ b/mfbt/LinkedList.h
@@ -654,17 +654,17 @@ class AutoCleanLinkedList : public Linke
public:
~AutoCleanLinkedList()
{
clear();
}
AutoCleanLinkedList& operator=(AutoCleanLinkedList&& aOther)
{
- LinkedList<T>::operator=(Forward<LinkedList<T>>(aOther));
+ LinkedList<T>::operator=(std::forward<LinkedList<T>>(aOther));
return *this;
}
void clear()
{
while (T* element = this->popFirst()) {
delete element;
}
--- a/mfbt/Maybe.h
+++ b/mfbt/Maybe.h
@@ -322,17 +322,17 @@ public:
* the default value provided.
*/
template<typename V>
T valueOr(V&& aDefault) const
{
if (isSome()) {
return ref();
}
- return Forward<V>(aDefault);
+ return std::forward<V>(aDefault);
}
/*
* Returns the contents of this Maybe<T> by value. If |isNothing()|, returns
* the value returned from the function or functor provided.
*/
template<typename F>
T valueOrFrom(F&& aFunc) const
@@ -591,17 +591,17 @@ Maybe<T>::operator*() const
}
template<typename T>
template<typename... Args>
void
Maybe<T>::emplace(Args&&... aArgs)
{
MOZ_DIAGNOSTIC_ASSERT(!mIsSome);
- ::new (KnownNotNull, data()) T(Forward<Args>(aArgs)...);
+ ::new (KnownNotNull, data()) T(std::forward<Args>(aArgs)...);
mIsSome = true;
}
/*
* Some() creates a Maybe<T> value containing the provided T value. If T has a
* move constructor, it's used to make this as efficient as possible.
*
* Some() selects the type of Maybe it returns by removing any const, volatile,
@@ -612,17 +612,17 @@ Maybe<T>::emplace(Args&&... aArgs)
*/
template<typename T,
typename U = typename std::remove_cv<
typename std::remove_reference<T>::type>::type>
Maybe<U>
Some(T&& aValue)
{
Maybe<U> value;
- value.emplace(Forward<T>(aValue));
+ value.emplace(std::forward<T>(aValue));
return value;
}
template<typename T>
Maybe<typename RemoveCV<typename RemoveReference<T>::Type>::Type>
ToMaybe(T* aPtr)
{
if (aPtr) {
--- a/mfbt/MaybeOneOf.h
+++ b/mfbt/MaybeOneOf.h
@@ -101,17 +101,17 @@ public:
template <class T>
bool constructed() const { return state == Type2State<T>::result; }
template <class T, class... Args>
void construct(Args&&... aArgs)
{
MOZ_ASSERT(state == None);
state = Type2State<T>::result;
- ::new (KnownNotNull, data()) T(Forward<Args>(aArgs)...);
+ ::new (KnownNotNull, data()) T(std::forward<Args>(aArgs)...);
}
template <class T>
T& ref()
{
return as<T>();
}
--- a/mfbt/Move.h
+++ b/mfbt/Move.h
@@ -132,17 +132,17 @@ namespace mozilla {
* C::C(X&& x, Y& y) : x(std::move(x)), y(y) { }
* C::C(X&& x, Y&& y) : x(std::move(x)), y(std::move(y)) { }
*
* To avoid this, C++11 has tweaks to make it possible to write what you mean.
* The four constructor overloads above can be written as one constructor
* template like so[0]:
*
* template <typename XArg, typename YArg>
- * C::C(XArg&& x, YArg&& y) : x(Forward<XArg>(x)), y(Forward<YArg>(y)) { }
+ * C::C(XArg&& x, YArg&& y) : x(std::forward<XArg>(x)), y(std::forward<YArg>(y)) { }
*
* ("'Don't Repeat Yourself'? What's that?")
*
* This takes advantage of two new rules in C++11:
*
* - First, when a function template takes an argument that is an rvalue
* reference to a template argument (like 'XArg&& x' and 'YArg&& y' above),
* then when the argument is applied to an lvalue, the template argument
@@ -160,17 +160,17 @@ namespace mozilla {
* 'collapsing rules': 'T& &', 'T&& &', and 'T& &&' (that is, any combination
* involving an lvalue reference) now collapse to simply 'T&'; and 'T&& &&'
* collapses to 'T&&'.
*
* Thus, in the call above, 'XArg&&' is 'X&&'; and 'YArg&&' is 'Y& &&', which
* collapses to 'Y&'. Because the arguments are declared as rvalue references
* to template arguments, the lvalue-ness "shines through" where present.
*
- * Then, the 'Forward<T>' function --- you must invoke 'Forward' with its type
+ * Then, the 'std::forward<T>' function --- you must invoke 'Forward' with its type
* argument --- returns an lvalue reference or an rvalue reference to its
* argument, depending on what T is. In our unified constructor definition, that
* means that we'll invoke either the copy or move constructors for x and y,
* depending on what we gave C's constructor. In our call, we'll move 'foo()'
* into 'x', but copy 'yy' into 'y'.
*
* This header file defines Move and Forward in the mozilla namespace. It's up
* to individual containers to annotate moves as such, by calling Move; and it's
@@ -189,36 +189,16 @@ namespace mozilla {
*
* // C is as above
* struct S { int x : 1; } s;
* C(s.x, 0); // BAD: s.x is a reference to a bit-field, can't form those
* int tmp = s.x;
* C(tmp, 0); // OK: tmp not a bit-field
*/
-/**
- * These two overloads are identical to std::forward(); they are necessary until
- * our stlport supports std::forward().
- */
-template<typename T>
-inline T&&
-Forward(typename RemoveReference<T>::Type& aX)
-{
- return static_cast<T&&>(aX);
-}
-
-template<typename T>
-inline T&&
-Forward(typename RemoveReference<T>::Type&& aX)
-{
- static_assert(!IsLvalueReference<T>::value,
- "misuse of Forward detected! try the other overload");
- return static_cast<T&&>(aX);
-}
-
/** Swap |aX| and |aY| using move-construction if possible. */
template<typename T>
inline void
Swap(T& aX, T& aY)
{
T tmp(std::move(aX));
aX = std::move(aY);
aY = std::move(tmp);
--- a/mfbt/NotNull.h
+++ b/mfbt/NotNull.h
@@ -195,17 +195,17 @@ struct PointedTo<const T*>
// and return NotNull<Ptr<Ob>>.
template<typename T, typename... Args>
constexpr NotNull<T>
MakeNotNull(Args&&... aArgs)
{
using Pointee = typename detail::PointedTo<T>::NonConstType;
static_assert(!IsArray<Pointee>::value,
"MakeNotNull cannot construct an array");
- return NotNull<T>(new Pointee(Forward<Args>(aArgs)...));
+ return NotNull<T>(new Pointee(std::forward<Args>(aArgs)...));
}
// Compare two NotNulls.
template <typename T, typename U>
constexpr bool
operator==(const NotNull<T>& aLhs, const NotNull<U>& aRhs)
{
return aLhs.get() == aRhs.get();
--- a/mfbt/Pair.h
+++ b/mfbt/Pair.h
@@ -36,18 +36,18 @@ template<typename A, typename B,
struct PairHelper;
template<typename A, typename B>
struct PairHelper<A, B, AsMember, AsMember>
{
protected:
template<typename AArg, typename BArg>
PairHelper(AArg&& aA, BArg&& aB)
- : mFirstA(Forward<AArg>(aA)),
- mSecondB(Forward<BArg>(aB))
+ : mFirstA(std::forward<AArg>(aA)),
+ mSecondB(std::forward<BArg>(aB))
{}
A& first() { return mFirstA; }
const A& first() const { return mFirstA; }
B& second() { return mSecondB; }
const B& second() const { return mSecondB; }
void swap(PairHelper& aOther)
@@ -62,18 +62,18 @@ private:
};
template<typename A, typename B>
struct PairHelper<A, B, AsMember, AsBase> : private B
{
protected:
template<typename AArg, typename BArg>
PairHelper(AArg&& aA, BArg&& aB)
- : B(Forward<BArg>(aB)),
- mFirstA(Forward<AArg>(aA))
+ : B(std::forward<BArg>(aB)),
+ mFirstA(std::forward<AArg>(aA))
{}
A& first() { return mFirstA; }
const A& first() const { return mFirstA; }
B& second() { return *this; }
const B& second() const { return *this; }
void swap(PairHelper& aOther)
@@ -87,18 +87,18 @@ private:
};
template<typename A, typename B>
struct PairHelper<A, B, AsBase, AsMember> : private A
{
protected:
template<typename AArg, typename BArg>
PairHelper(AArg&& aA, BArg&& aB)
- : A(Forward<AArg>(aA)),
- mSecondB(Forward<BArg>(aB))
+ : A(std::forward<AArg>(aA)),
+ mSecondB(std::forward<BArg>(aB))
{}
A& first() { return *this; }
const A& first() const { return *this; }
B& second() { return mSecondB; }
const B& second() const { return mSecondB; }
void swap(PairHelper& aOther)
@@ -112,18 +112,18 @@ private:
};
template<typename A, typename B>
struct PairHelper<A, B, AsBase, AsBase> : private A, private B
{
protected:
template<typename AArg, typename BArg>
PairHelper(AArg&& aA, BArg&& aB)
- : A(Forward<AArg>(aA)),
- B(Forward<BArg>(aB))
+ : A(std::forward<AArg>(aA)),
+ B(std::forward<BArg>(aB))
{}
A& first() { return static_cast<A&>(*this); }
const A& first() const { return static_cast<A&>(*this); }
B& second() { return static_cast<B&>(*this); }
const B& second() const { return static_cast<B&>(*this); }
void swap(PairHelper& aOther)
@@ -152,17 +152,17 @@ template<typename A, typename B>
struct Pair
: private detail::PairHelper<A, B>
{
typedef typename detail::PairHelper<A, B> Base;
public:
template<typename AArg, typename BArg>
Pair(AArg&& aA, BArg&& aB)
- : Base(Forward<AArg>(aA), Forward<BArg>(aB))
+ : Base(std::forward<AArg>(aA), std::forward<BArg>(aB))
{}
Pair(Pair&& aOther)
: Base(std::move(aOther.first()), std::move(aOther.second()))
{ }
Pair(const Pair& aOther) = default;
@@ -205,15 +205,15 @@ Swap(Pair<A, B>& aX, Pair<A, B>& aY)
template<typename A, typename B>
Pair<typename RemoveCV<typename RemoveReference<A>::Type>::Type,
typename RemoveCV<typename RemoveReference<B>::Type>::Type>
MakePair(A&& aA, B&& aB)
{
return
Pair<typename RemoveCV<typename RemoveReference<A>::Type>::Type,
typename RemoveCV<typename RemoveReference<B>::Type>::Type>(
- Forward<A>(aA),
- Forward<B>(aB));
+ std::forward<A>(aA),
+ std::forward<B>(aB));
}
} // namespace mozilla
#endif /* mozilla_Pair_h */
--- a/mfbt/RefPtr.h
+++ b/mfbt/RefPtr.h
@@ -338,17 +338,17 @@ public:
Proxy(T* aRawPtr, member_function aFunction)
: mRawPtr(aRawPtr),
mFunction(aFunction)
{
}
template<typename... ActualArgs>
R operator()(ActualArgs&&... aArgs)
{
- return ((*mRawPtr).*mFunction)(mozilla::Forward<ActualArgs>(aArgs)...);
+ return ((*mRawPtr).*mFunction)(std::forward<ActualArgs>(aArgs)...);
}
};
template <typename R, typename... Args>
Proxy<R, Args...> operator->*(R (T::*aFptr)(Args...)) const
{
MOZ_ASSERT(mRawPtr != nullptr,
"You can't dereference a NULL RefPtr with operator->*().");
@@ -650,29 +650,29 @@ namespace mozilla {
* {
* return MakeAndAddRef<T>(...);
* }
*/
template<typename T, typename... Args>
already_AddRefed<T>
MakeAndAddRef(Args&&... aArgs)
{
- RefPtr<T> p(new T(Forward<Args>(aArgs)...));
+ RefPtr<T> p(new T(std::forward<Args>(aArgs)...));
return p.forget();
}
/**
* Helper function to be able to conveniently write things like:
*
* auto runnable = MakeRefPtr<ErrorCallbackRunnable<nsIDOMGetUserMediaSuccessCallback>>(
* mOnSuccess, mOnFailure, *error, mWindowID);
*/
template<typename T, typename... Args>
RefPtr<T>
MakeRefPtr(Args&&... aArgs)
{
- RefPtr<T> p(new T(Forward<Args>(aArgs)...));
+ RefPtr<T> p(new T(std::forward<Args>(aArgs)...));
return p;
}
} // namespace mozilla
#endif /* mozilla_RefPtr_h */
--- a/mfbt/Result.h
+++ b/mfbt/Result.h
@@ -258,19 +258,19 @@ struct IsResult : FalseType { };
template <typename V, typename E>
struct IsResult<Result<V, E>> : TrueType { };
} // namespace detail
template <typename V, typename E>
auto
ToResult(Result<V, E>&& aValue)
- -> decltype(Forward<Result<V, E>>(aValue))
+ -> decltype(std::forward<Result<V, E>>(aValue))
{
- return Forward<Result<V, E>>(aValue);
+ return std::forward<Result<V, E>>(aValue);
}
/**
* Result<V, E> represents the outcome of an operation that can either succeed
* or fail. It contains either a success value of type V or an error value of
* type E.
*
* All Result methods are const, so results are basically immutable.
--- a/mfbt/SegmentedVector.h
+++ b/mfbt/SegmentedVector.h
@@ -84,17 +84,17 @@ class SegmentedVector : private AllocPol
template<typename U>
void Append(U&& aU)
{
MOZ_ASSERT(mLength < SegmentCapacity);
// Pre-increment mLength so that the bounds-check in operator[] passes.
mLength++;
T* elem = &(*this)[mLength - 1];
- new (elem) T(mozilla::Forward<U>(aU));
+ new (elem) T(std::forward<U>(aU));
}
void PopLast()
{
MOZ_ASSERT(mLength > 0);
(*this)[mLength - 1].~T();
mLength--;
}
@@ -170,26 +170,26 @@ public:
if (!last || last->Length() == kSegmentCapacity) {
last = this->template pod_malloc<Segment>(1);
if (!last) {
return false;
}
new (last) Segment();
mSegments.insertBack(last);
}
- last->Append(mozilla::Forward<U>(aU));
+ last->Append(std::forward<U>(aU));
return true;
}
// You should probably only use this instead of Append() if you are using an
// infallible allocation policy. It will crash if the allocation fails.
template<typename U>
void InfallibleAppend(U&& aU)
{
- bool ok = Append(mozilla::Forward<U>(aU));
+ bool ok = Append(std::forward<U>(aU));
MOZ_RELEASE_ASSERT(ok);
}
void Clear()
{
Segment* segment;
while ((segment = mSegments.popFirst())) {
segment->~Segment();
--- a/mfbt/Span.h
+++ b/mfbt/Span.h
@@ -55,17 +55,17 @@ namespace mozilla {
// Stuff from gsl_util
// narrow_cast(): a searchable way to do narrowing casts of values
template<class T, class U>
inline constexpr T
narrow_cast(U&& u)
{
- return static_cast<T>(mozilla::Forward<U>(u));
+ return static_cast<T>(std::forward<U>(u));
}
// end gsl_util
// [views.constants], constants
// This was -1 in gsl::span, but using size_t for sizes instead of ptrdiff_t
// and reserving a magic value that realistically doesn't occur in
// compile-time-constant Span sizes makes things a lot less messy in terms of
--- a/mfbt/Tuple.h
+++ b/mfbt/Tuple.h
@@ -134,27 +134,27 @@ struct TupleImpl<Index, HeadT, TailT...>
// convertible to the element types, otherwise it could become a better
// match for certain invocations than the copy constructor.
template <typename OtherHeadT, typename... OtherTailT,
typename = typename EnableIf<
CheckConvertibility<
Group<OtherHeadT, OtherTailT...>,
Group<HeadT, TailT...>>::value>::Type>
explicit TupleImpl(OtherHeadT&& aHead, OtherTailT&&... aTail)
- : Base(Forward<OtherTailT>(aTail)...), mHead(Forward<OtherHeadT>(aHead)) { }
+ : Base(std::forward<OtherTailT>(aTail)...), mHead(std::forward<OtherHeadT>(aHead)) { }
// Copy and move constructors.
// We'd like to use '= default' to implement these, but MSVC 2013's support
// for '= default' is incomplete and this doesn't work.
TupleImpl(const TupleImpl& aOther)
: Base(Tail(aOther))
, mHead(Head(aOther)) {}
TupleImpl(TupleImpl&& aOther)
: Base(std::move(Tail(aOther)))
- , mHead(Forward<HeadT>(Head(aOther))) {}
+ , mHead(std::forward<HeadT>(Head(aOther))) {}
// Assign from a tuple whose elements are convertible to the elements
// of this tuple.
template <typename... OtherElements,
typename = typename EnableIf<
sizeof...(OtherElements) == sizeof...(TailT) + 1>::Type>
TupleImpl& operator=(const TupleImpl<Index, OtherElements...>& aOther)
{
@@ -220,17 +220,17 @@ public:
// actually instantiates the constructor with an empty parameter pack -
// that's probably a bug) and we compile with warnings-as-errors.
template <typename OtherHead, typename... OtherTail,
typename = typename EnableIf<
detail::CheckConvertibility<
detail::Group<OtherHead, OtherTail...>,
detail::Group<Elements...>>::value>::Type>
explicit Tuple(OtherHead&& aHead, OtherTail&&... aTail)
- : Impl(Forward<OtherHead>(aHead), Forward<OtherTail>(aTail)...) { }
+ : Impl(std::forward<OtherHead>(aHead), std::forward<OtherTail>(aTail)...) { }
Tuple(const Tuple& aOther) : Impl(aOther) { }
Tuple(Tuple&& aOther) : Impl(std::move(aOther)) { }
template <typename... OtherElements,
typename = typename EnableIf<
sizeof...(OtherElements) == sizeof...(Elements)>::Type>
Tuple& operator=(const Tuple<OtherElements...>& aOther)
{
@@ -277,27 +277,27 @@ public:
Tuple() : Impl() { }
explicit Tuple(const A& aA, const B& aB) : Impl(aA, aB) { }
template <typename AArg, typename BArg,
typename = typename EnableIf<
detail::CheckConvertibility<
detail::Group<AArg, BArg>,
detail::Group<A, B>>::value>::Type>
explicit Tuple(AArg&& aA, BArg&& aB)
- : Impl(Forward<AArg>(aA), Forward<BArg>(aB)) { }
+ : Impl(std::forward<AArg>(aA), std::forward<BArg>(aB)) { }
Tuple(const Tuple& aOther) : Impl(aOther) { }
Tuple(Tuple&& aOther) : Impl(std::move(aOther)) { }
explicit Tuple(const Pair<A, B>& aOther)
: Impl(aOther.first(), aOther.second()) { }
- explicit Tuple(Pair<A, B>&& aOther) : Impl(Forward<A>(aOther.first()),
- Forward<B>(aOther.second())) { }
+ explicit Tuple(Pair<A, B>&& aOther) : Impl(std::forward<A>(aOther.first()),
+ std::forward<B>(aOther.second())) { }
explicit Tuple(const std::pair<A, B>& aOther)
: Impl(aOther.first, aOther.second) { }
- explicit Tuple(std::pair<A, B>&& aOther) : Impl(Forward<A>(aOther.first),
- Forward<B>(aOther.second)) { }
+ explicit Tuple(std::pair<A, B>&& aOther) : Impl(std::forward<A>(aOther.first),
+ std::forward<B>(aOther.second)) { }
template <typename AArg, typename BArg>
Tuple& operator=(const Tuple<AArg, BArg>& aOther)
{
static_cast<Impl&>(*this) = aOther;
return *this;
}
template <typename AArg, typename BArg>
@@ -321,32 +321,32 @@ public:
{
Impl::Head(*this) = aOther.first();
Impl::Tail(*this).Head(*this) = aOther.second();
return *this;
}
template <typename AArg, typename BArg>
Tuple& operator=(Pair<AArg, BArg>&& aOther)
{
- Impl::Head(*this) = Forward<AArg>(aOther.first());
- Impl::Tail(*this).Head(*this) = Forward<BArg>(aOther.second());
+ Impl::Head(*this) = std::forward<AArg>(aOther.first());
+ Impl::Tail(*this).Head(*this) = std::forward<BArg>(aOther.second());
return *this;
}
template <typename AArg, typename BArg>
Tuple& operator=(const std::pair<AArg, BArg>& aOther)
{
Impl::Head(*this) = aOther.first;
Impl::Tail(*this).Head(*this) = aOther.second;
return *this;
}
template <typename AArg, typename BArg>
Tuple& operator=(std::pair<AArg, BArg>&& aOther)
{
- Impl::Head(*this) = Forward<AArg>(aOther.first);
- Impl::Tail(*this).Head(*this) = Forward<BArg>(aOther.second);
+ Impl::Head(*this) = std::forward<AArg>(aOther.first);
+ Impl::Tail(*this).Head(*this) = std::forward<BArg>(aOther.second);
return *this;
}
};
/**
* Specialization of Tuple for zero arguments.
* This is necessary because if the primary template were instantiated with
* an empty parameter pack, the 'Tuple(Elements...)' constructors would
@@ -428,17 +428,17 @@ auto Get(Tuple<Elements...>&& aTuple)
* Example:
*
* auto tuple = MakeTuple(42, 0.5f, 'c'); // has type Tuple<int, float, char>
*/
template<typename... Elements>
inline Tuple<typename Decay<Elements>::Type...>
MakeTuple(Elements&&... aElements)
{
- return Tuple<typename Decay<Elements>::Type...>(Forward<Elements>(aElements)...);
+ return Tuple<typename Decay<Elements>::Type...>(std::forward<Elements>(aElements)...);
}
/**
* A convenience function for constructing a tuple of references to a
* sequence of variables. Since assignments to the elements of the tuple
* "go through" to the referenced variables, this can be used to "unpack"
* a tuple into individual variables.
*
--- a/mfbt/UniquePtr.h
+++ b/mfbt/UniquePtr.h
@@ -255,17 +255,17 @@ public:
typename RemoveReference<D>::Type&& aD2)
: mTuple(aPtr, std::move(aD2))
{
static_assert(!IsReference<D>::value,
"rvalue deleter can't be stored by reference");
}
UniquePtr(UniquePtr&& aOther)
- : mTuple(aOther.release(), Forward<DeleterType>(aOther.get_deleter()))
+ : mTuple(aOther.release(), std::forward<DeleterType>(aOther.get_deleter()))
{}
MOZ_IMPLICIT
UniquePtr(decltype(nullptr))
: mTuple(nullptr, DeleterType())
{
static_assert(!IsPointer<D>::value, "must provide a deleter instance");
static_assert(!IsReference<D>::value, "must provide a deleter instance");
@@ -276,40 +276,40 @@ public:
UniquePtr(UniquePtr<U, E>&& aOther,
typename EnableIf<IsConvertible<typename UniquePtr<U, E>::Pointer,
Pointer>::value &&
!IsArray<U>::value &&
(IsReference<D>::value
? IsSame<D, E>::value
: IsConvertible<E, D>::value),
int>::Type aDummy = 0)
- : mTuple(aOther.release(), Forward<E>(aOther.get_deleter()))
+ : mTuple(aOther.release(), std::forward<E>(aOther.get_deleter()))
{
}
~UniquePtr() { reset(nullptr); }
UniquePtr& operator=(UniquePtr&& aOther)
{
reset(aOther.release());
- get_deleter() = Forward<DeleterType>(aOther.get_deleter());
+ get_deleter() = std::forward<DeleterType>(aOther.get_deleter());
return *this;
}
template<typename U, typename E>
UniquePtr& operator=(UniquePtr<U, E>&& aOther)
{
static_assert(IsConvertible<typename UniquePtr<U, E>::Pointer,
Pointer>::value,
"incompatible UniquePtr pointees");
static_assert(!IsArray<U>::value,
"can't assign from UniquePtr holding an array");
reset(aOther.release());
- get_deleter() = Forward<E>(aOther.get_deleter());
+ get_deleter() = std::forward<E>(aOther.get_deleter());
return *this;
}
UniquePtr& operator=(decltype(nullptr))
{
reset(nullptr);
return *this;
}
@@ -424,33 +424,33 @@ public:
template<typename U, typename V>
UniquePtr(U&& aU, V&& aV,
typename EnableIf<IsPointer<U>::value &&
IsConvertible<U, Pointer>::value,
int>::Type aDummy = 0)
= delete;
UniquePtr(UniquePtr&& aOther)
- : mTuple(aOther.release(), Forward<DeleterType>(aOther.get_deleter()))
+ : mTuple(aOther.release(), std::forward<DeleterType>(aOther.get_deleter()))
{}
MOZ_IMPLICIT
UniquePtr(decltype(nullptr))
: mTuple(nullptr, DeleterType())
{
static_assert(!IsPointer<D>::value, "must provide a deleter instance");
static_assert(!IsReference<D>::value, "must provide a deleter instance");
}
~UniquePtr() { reset(nullptr); }
UniquePtr& operator=(UniquePtr&& aOther)
{
reset(aOther.release());
- get_deleter() = Forward<DeleterType>(aOther.get_deleter());
+ get_deleter() = std::forward<DeleterType>(aOther.get_deleter());
return *this;
}
UniquePtr& operator=(decltype(nullptr))
{
reset();
return *this;
}
@@ -672,17 +672,17 @@ struct UniqueSelector<T[N]>
* pointer is assigned to an object that will manage its ownership. UniquePtr
* ably serves this function.)
*/
template<typename T, typename... Args>
typename detail::UniqueSelector<T>::SingleObject
MakeUnique(Args&&... aArgs)
{
- return UniquePtr<T>(new T(Forward<Args>(aArgs)...));
+ return UniquePtr<T>(new T(std::forward<Args>(aArgs)...));
}
template<typename T>
typename detail::UniqueSelector<T>::UnknownBound
MakeUnique(decltype(sizeof(int)) aN)
{
typedef typename RemoveExtent<T>::Type ArrayType;
return UniquePtr<T>(new ArrayType[aN]());
--- a/mfbt/UniquePtrExtensions.h
+++ b/mfbt/UniquePtrExtensions.h
@@ -17,17 +17,17 @@ namespace mozilla {
/**
* MakeUniqueFallible works exactly like MakeUnique, except that the memory
* allocation performed is done fallibly, i.e. it can return nullptr.
*/
template<typename T, typename... Args>
typename detail::UniqueSelector<T>::SingleObject
MakeUniqueFallible(Args&&... aArgs)
{
- return UniquePtr<T>(new (fallible) T(Forward<Args>(aArgs)...));
+ return UniquePtr<T>(new (fallible) T(std::forward<Args>(aArgs)...));
}
template<typename T>
typename detail::UniqueSelector<T>::UnknownBound
MakeUniqueFallible(decltype(sizeof(int)) aN)
{
typedef typename RemoveExtent<T>::Type ArrayType;
return UniquePtr<T>(new (fallible) ArrayType[aN]());
--- a/mfbt/Variant.h
+++ b/mfbt/Variant.h
@@ -274,17 +274,17 @@ template <typename T>
struct AsVariantTemporary
{
explicit AsVariantTemporary(const T& aValue)
: mValue(aValue)
{}
template<typename U>
explicit AsVariantTemporary(U&& aValue)
- : mValue(Forward<U>(aValue))
+ : mValue(std::forward<U>(aValue))
{}
AsVariantTemporary(const AsVariantTemporary& aOther)
: mValue(aOther.mValue)
{}
AsVariantTemporary(AsVariantTemporary&& aOther)
: mValue(std::move(aOther.mValue))
@@ -523,45 +523,45 @@ public:
// when ensuring that T is a variant of this type, and getting T's
// tag, etc.
typename T = typename detail::SelectVariantType<RefT, Ts...>::Type>
explicit Variant(RefT&& aT)
: tag(Impl::template tag<T>())
{
static_assert(detail::SelectVariantType<RefT, Ts...>::count == 1,
"Variant can only be selected by type if that type is unique");
- ::new (KnownNotNull, ptr()) T(Forward<RefT>(aT));
+ ::new (KnownNotNull, ptr()) T(std::forward<RefT>(aT));
}
/**
* Perfect forwarding construction for some variant type T, by
* explicitly giving the type.
* This is necessary to construct from any number of arguments,
* or to convert from a type that is not in the Variant's type list.
*/
template<typename T, typename... Args>
MOZ_IMPLICIT Variant(const VariantType<T>&, Args&&... aTs)
: tag(Impl::template tag<T>())
{
- ::new (KnownNotNull, ptr()) T(Forward<Args>(aTs)...);
+ ::new (KnownNotNull, ptr()) T(std::forward<Args>(aTs)...);
}
/**
* Perfect forwarding construction for some variant type T, by
* explicitly giving the type index.
* This is necessary to construct from any number of arguments,
* or to convert from a type that is not in the Variant's type list,
* or to construct a type that is present more than once in the Variant.
*/
template<size_t N, typename... Args>
MOZ_IMPLICIT Variant(const VariantIndex<N>&, Args&&... aTs)
: tag(N)
{
using T = typename detail::Nth<N, Ts...>::Type;
- ::new (KnownNotNull, ptr()) T(Forward<Args>(aTs)...);
+ ::new (KnownNotNull, ptr()) T(std::forward<Args>(aTs)...);
}
/**
* Constructs this Variant from an AsVariantTemporary<T> such that T can be
* stored in one of the types allowable in this Variant. This is used in the
* implementation of AsVariant().
*/
template<typename RefT>
@@ -747,14 +747,14 @@ public:
*
* AsVariant() returns a AsVariantTemporary value which is implicitly
* convertible to any Variant that can hold a value of type T.
*/
template<typename T>
detail::AsVariantTemporary<T>
AsVariant(T&& aValue)
{
- return detail::AsVariantTemporary<T>(Forward<T>(aValue));
+ return detail::AsVariantTemporary<T>(std::forward<T>(aValue));
}
} // namespace mozilla
#endif /* mozilla_Variant_h */
--- a/mfbt/Vector.h
+++ b/mfbt/Vector.h
@@ -58,17 +58,17 @@ struct VectorImpl
{
/*
* Constructs an object in the uninitialized memory at *aDst with aArgs.
*/
template<typename... Args>
MOZ_NONNULL(1)
static inline void new_(T* aDst, Args&&... aArgs)
{
- new(KnownNotNull, aDst) T(Forward<Args>(aArgs)...);
+ new(KnownNotNull, aDst) T(std::forward<Args>(aArgs)...);
}
/* Destroys constructed objects in the range [aBegin, aEnd). */
static inline void destroy(T* aBegin, T* aEnd)
{
MOZ_ASSERT(aBegin <= aEnd);
for (T* p = aBegin; p < aEnd; ++p) {
p->~T();
@@ -163,17 +163,17 @@ struct VectorImpl<T, N, AP, true>
template<typename... Args>
MOZ_NONNULL(1)
static inline void new_(T* aDst, Args&&... aArgs)
{
// Explicitly construct a local object instead of using a temporary since
// T(args...) will be treated like a C-style cast in the unary case and
// allow unsafe conversions. Both forms should be equivalent to an
// optimizing compiler.
- T temp(Forward<Args>(aArgs)...);
+ T temp(std::forward<Args>(aArgs)...);
*aDst = temp;
}
static inline void destroy(T*, T*) {}
static inline void initialize(T* aBegin, T* aEnd)
{
/*
@@ -701,34 +701,34 @@ public:
/**
* Construct a T in-place as a new entry at the end of this vector.
*/
template<typename... Args>
MOZ_MUST_USE bool emplaceBack(Args&&... aArgs)
{
if (!growByUninitialized(1))
return false;
- Impl::new_(&back(), Forward<Args>(aArgs)...);
+ Impl::new_(&back(), std::forward<Args>(aArgs)...);
return true;
}
template<typename U, size_t O, class BP>
MOZ_MUST_USE bool appendAll(const Vector<U, O, BP>& aU);
MOZ_MUST_USE bool appendN(const T& aT, size_t aN);
template<typename U> MOZ_MUST_USE bool append(const U* aBegin, const U* aEnd);
template<typename U> MOZ_MUST_USE bool append(const U* aBegin, size_t aLength);
/*
* Guaranteed-infallible append operations for use upon vectors whose
* memory has been pre-reserved. Don't use this if you haven't reserved the
* memory!
*/
template<typename U> void infallibleAppend(U&& aU)
{
- internalAppend(Forward<U>(aU));
+ internalAppend(std::forward<U>(aU));
}
void infallibleAppendN(const T& aT, size_t aN)
{
internalAppendN(aT, aN);
}
template<typename U> void infallibleAppend(const U* aBegin, const U* aEnd)
{
internalAppend(aBegin, PointerRangeSize(aBegin, aEnd));
@@ -736,17 +736,17 @@ public:
template<typename U> void infallibleAppend(const U* aBegin, size_t aLength)
{
internalAppend(aBegin, aLength);
}
template<typename... Args>
void infallibleEmplaceBack(Args&&... aArgs)
{
infallibleGrowByUninitialized(1);
- Impl::new_(&back(), Forward<Args>(aArgs)...);
+ Impl::new_(&back(), std::forward<Args>(aArgs)...);
}
void popBack();
T popCopy();
/**
* If elements are stored in-place, return nullptr and leave this vector
@@ -1272,17 +1272,17 @@ Vector<T, N, AP>::internalAppendAll(cons
template<typename T, size_t N, class AP>
template<typename U>
MOZ_ALWAYS_INLINE void
Vector<T, N, AP>::internalAppend(U&& aU)
{
MOZ_ASSERT(mLength + 1 <= mTail.mReserved);
MOZ_ASSERT(mTail.mReserved <= mTail.mCapacity);
- Impl::new_(endNoCheck(), Forward<U>(aU));
+ Impl::new_(endNoCheck(), std::forward<U>(aU));
++mLength;
}
template<typename T, size_t N, class AP>
MOZ_ALWAYS_INLINE bool
Vector<T, N, AP>::appendN(const T& aT, size_t aNeeded)
{
MOZ_REENTRANCY_GUARD_ET_AL;
@@ -1318,28 +1318,28 @@ inline T*
Vector<T, N, AP>::insert(T* aP, U&& aVal)
{
MOZ_ASSERT(begin() <= aP);
MOZ_ASSERT(aP <= end());
size_t pos = aP - begin();
MOZ_ASSERT(pos <= mLength);
size_t oldLength = mLength;
if (pos == oldLength) {
- if (!append(Forward<U>(aVal))) {
+ if (!append(std::forward<U>(aVal))) {
return nullptr;
}
} else {
T oldBack = std::move(back());
if (!append(std::move(oldBack))) {
return nullptr;
}
for (size_t i = oldLength - 1; i > pos; --i) {
(*this)[i] = std::move((*this)[i - 1]);
}
- (*this)[pos] = Forward<U>(aVal);
+ (*this)[pos] = std::forward<U>(aVal);
}
return begin() + pos;
}
template<typename T, size_t N, class AP>
inline void
Vector<T, N, AP>::erase(T* aIt)
{
@@ -1412,17 +1412,17 @@ Vector<T, N, AP>::append(U&& aU)
} else if (!maybeCheckSimulatedOOM(mLength + 1)) {
return false;
}
#ifdef DEBUG
if (mLength + 1 > mTail.mReserved) {
mTail.mReserved = mLength + 1;
}
#endif
- internalAppend(Forward<U>(aU));
+ internalAppend(std::forward<U>(aU));
return true;
}
template<typename T, size_t N, class AP>
template<typename U, size_t O, class BP>
MOZ_ALWAYS_INLINE bool
Vector<T, N, AP>::appendAll(const Vector<U, O, BP>& aOther)
{
--- a/mozglue/misc/DynamicallyLinkedFunctionPtr.h
+++ b/mozglue/misc/DynamicallyLinkedFunctionPtr.h
@@ -49,17 +49,17 @@ public:
{
if (mModule) {
::FreeLibrary(mModule);
}
}
R operator()(Args... args) const
{
- return mFunction(mozilla::Forward<Args>(args)...);
+ return mFunction(std::forward<Args>(args)...);
}
explicit operator bool() const
{
return !!mFunction;
}
private:
--- a/mozglue/misc/interceptor/PatcherBase.h
+++ b/mozglue/misc/interceptor/PatcherBase.h
@@ -15,17 +15,17 @@ namespace interceptor {
template <typename VMPolicy>
class WindowsDllPatcherBase
{
protected:
typedef typename VMPolicy::MMPolicyT MMPolicyT;
template <typename... Args>
explicit WindowsDllPatcherBase(Args... aArgs)
- : mVMPolicy(mozilla::Forward<Args>(aArgs)...)
+ : mVMPolicy(std::forward<Args>(aArgs)...)
{
}
ReadOnlyTargetFunction<MMPolicyT>
ResolveRedirectedAddress(const void* aOriginalFunction)
{
ReadOnlyTargetFunction<MMPolicyT> origFn(mVMPolicy, aOriginalFunction);
// If function entry is jmp rel8 stub to the internal implementation, we
--- a/mozglue/misc/interceptor/PatcherDetour.h
+++ b/mozglue/misc/interceptor/PatcherDetour.h
@@ -21,17 +21,17 @@ namespace mozilla {
namespace interceptor {
template <typename VMPolicy>
class WindowsDllDetourPatcher final : public WindowsDllPatcherBase<VMPolicy>
{
public:
template <typename... Args>
explicit WindowsDllDetourPatcher(Args... aArgs)
- : WindowsDllPatcherBase<VMPolicy>(mozilla::Forward<Args>(aArgs)...)
+ : WindowsDllPatcherBase<VMPolicy>(std::forward<Args>(aArgs)...)
{
}
~WindowsDllDetourPatcher()
{
Clear();
}
--- a/mozglue/misc/interceptor/PatcherNopSpace.h
+++ b/mozglue/misc/interceptor/PatcherNopSpace.h
@@ -18,17 +18,17 @@ template <typename VMPolicy>
class WindowsDllNopSpacePatcher final : public WindowsDllPatcherBase<VMPolicy>
{
// For remembering the addresses of functions we've patched.
mozilla::Vector<void*> mPatchedFns;
public:
template <typename... Args>
explicit WindowsDllNopSpacePatcher(Args... aArgs)
- : WindowsDllPatcherBase<VMPolicy>(mozilla::Forward<Args>(aArgs)...)
+ : WindowsDllPatcherBase<VMPolicy>(std::forward<Args>(aArgs)...)
{}
~WindowsDllNopSpacePatcher()
{
Clear();
}
WindowsDllNopSpacePatcher(const WindowsDllNopSpacePatcher&) = delete;
--- a/mozglue/misc/interceptor/VMSharingPolicies.h
+++ b/mozglue/misc/interceptor/VMSharingPolicies.h
@@ -14,17 +14,17 @@ namespace mozilla {
namespace interceptor {
template <typename MMPolicy, uint32_t kChunkSize>
class VMSharingPolicyUnique : public MMPolicy
{
public:
template <typename... Args>
explicit VMSharingPolicyUnique(Args... aArgs)
- : MMPolicy(mozilla::Forward<Args>(aArgs)...)
+ : MMPolicy(std::forward<Args>(aArgs)...)
, mNextChunkIndex(0)
{
}
bool Reserve(uint32_t aCount)
{
MOZ_ASSERT(aCount);
uint32_t bytesReserved = MMPolicy::Reserve(aCount * kChunkSize);
--- a/mozglue/misc/nsWindowsDllInterceptor.h
+++ b/mozglue/misc/nsWindowsDllInterceptor.h
@@ -98,19 +98,19 @@ class WindowsDllInterceptor final
#endif // defined(_M_IX86)
HMODULE mModule;
int mNHooks;
public:
template <typename... Args>
explicit WindowsDllInterceptor(Args... aArgs)
- : mDetourPatcher(mozilla::Forward<Args>(aArgs)...)
+ : mDetourPatcher(std::forward<Args>(aArgs)...)
#if defined(_M_IX86)
- , mNopSpacePatcher(mozilla::Forward<Args>(aArgs)...)
+ , mNopSpacePatcher(std::forward<Args>(aArgs)...)
#endif // defined(_M_IX86)
, mModule(nullptr)
, mNHooks(0)
{
}
WindowsDllInterceptor(const WindowsDllInterceptor&) = delete;
WindowsDllInterceptor(WindowsDllInterceptor&&) = delete;
--- a/security/sandbox/linux/SandboxOpenedFiles.h
+++ b/security/sandbox/linux/SandboxOpenedFiles.h
@@ -64,17 +64,17 @@ class SandboxOpenedFile final {
// Because the seccomp-bpf policy exists until the process exits, this
// object must not be destroyed after the syscall filter is installed.
class SandboxOpenedFiles {
public:
SandboxOpenedFiles() = default;
template<typename... Args>
void Add(Args&&... aArgs) {
- mFiles.emplace_back(Forward<Args>(aArgs)...);
+ mFiles.emplace_back(std::forward<Args>(aArgs)...);
}
int GetDesc(const char* aPath) const;
private:
std::vector<SandboxOpenedFile> mFiles;
// We could allow destroying instances of this class that aren't
--- a/toolkit/components/extensions/MatchPattern.h
+++ b/toolkit/components/extensions/MatchPattern.h
@@ -341,17 +341,17 @@ class MatchPatternSet final : public nsI
virtual JSObject* WrapObject(JSContext* aCx, JS::HandleObject aGivenProto) override;
protected:
virtual ~MatchPatternSet() = default;
private:
explicit MatchPatternSet(nsISupports* aParent, ArrayType&& aPatterns)
: mParent(aParent)
- , mPatterns(Forward<ArrayType>(aPatterns))
+ , mPatterns(std::forward<ArrayType>(aPatterns))
{}
nsCOMPtr<nsISupports> mParent;
ArrayType mPatterns;
};
} // namespace extensions
--- a/toolkit/components/url-classifier/tests/gtest/Common.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/Common.cpp
@@ -11,17 +11,17 @@ using namespace mozilla;
using namespace mozilla::safebrowsing;
#define GTEST_SAFEBROWSING_DIR NS_LITERAL_CSTRING("safebrowsing")
#define GTEST_TABLE NS_LITERAL_CSTRING("gtest-malware-proto")
template<typename Function>
void RunTestInNewThread(Function&& aFunction) {
nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction(
- "RunTestInNewThread", mozilla::Forward<Function>(aFunction));
+ "RunTestInNewThread", std::forward<Function>(aFunction));
nsCOMPtr<nsIThread> testingThread;
nsresult rv =
NS_NewNamedThread("Testing Thread", getter_AddRefs(testingThread), r);
ASSERT_EQ(rv, NS_OK);
testingThread->Shutdown();
}
nsresult SyncApplyUpdates(Classifier* aClassifier,
--- a/widget/android/jni/Natives.h
+++ b/widget/android/jni/Natives.h
@@ -514,49 +514,49 @@ struct Dispatcher
template<class Traits, bool IsStatic = Traits::isStatic,
typename... ProxyArgs>
static typename EnableIf<
Traits::dispatchTarget == DispatchTarget::PROXY, void>::Type
Run(ProxyArgs&&... args)
{
Impl::OnNativeCall(ProxyNativeCall<
Impl, typename Traits::Owner, IsStatic,
- HasThisArg, Args...>(Forward<ProxyArgs>(args)...));
+ HasThisArg, Args...>(std::forward<ProxyArgs>(args)...));
}
template<class Traits, bool IsStatic = Traits::isStatic,
typename ThisArg, typename... ProxyArgs>
static typename EnableIf<
Traits::dispatchTarget == DispatchTarget::GECKO_PRIORITY, void>::Type
Run(ThisArg thisArg, ProxyArgs&&... args)
{
// For a static method, do not forward the "this arg" (i.e. the class
// local ref) if the implementation does not request it. This saves us
// a pair of calls to add/delete global ref.
auto proxy = ProxyNativeCall<Impl, typename Traits::Owner, IsStatic,
HasThisArg, Args...>(
(HasThisArg || !IsStatic) ? thisArg : nullptr,
- Forward<ProxyArgs>(args)...);
+ std::forward<ProxyArgs>(args)...);
DispatchToGeckoPriorityQueue(
NS_NewRunnableFunction("PriorityNativeCall", std::move(proxy)));
}
template<class Traits, bool IsStatic = Traits::isStatic,
typename ThisArg, typename... ProxyArgs>
static typename EnableIf<
Traits::dispatchTarget == DispatchTarget::GECKO, void>::Type
Run(ThisArg thisArg, ProxyArgs&&... args)
{
// For a static method, do not forward the "this arg" (i.e. the class
// local ref) if the implementation does not request it. This saves us
// a pair of calls to add/delete global ref.
auto proxy = ProxyNativeCall<Impl, typename Traits::Owner, IsStatic,
HasThisArg, Args...>(
(HasThisArg || !IsStatic) ? thisArg : nullptr,
- Forward<ProxyArgs>(args)...);
+ std::forward<ProxyArgs>(args)...);
NS_DispatchToMainThread(
NS_NewRunnableFunction("GeckoNativeCall", std::move(proxy)));
}
template<class Traits, bool IsStatic = false, typename... ProxyArgs>
static typename EnableIf<
Traits::dispatchTarget == DispatchTarget::CURRENT, void>::Type
Run(ProxyArgs&&... args)
--- a/widget/android/nsAppShell.h
+++ b/widget/android/nsAppShell.h
@@ -147,17 +147,17 @@ public:
static void SyncRunEvent(Event&& event,
mozilla::UniquePtr<Event>(*eventFactory)(
mozilla::UniquePtr<Event>&&) = nullptr);
template<typename T> static
typename mozilla::EnableIf<!mozilla::IsBaseOf<Event, T>::value, void>::Type
SyncRunEvent(T&& lambda)
{
- SyncRunEvent(LambdaEvent<T>(mozilla::Forward<T>(lambda)));
+ SyncRunEvent(LambdaEvent<T>(std::forward<T>(lambda)));
}
static already_AddRefed<nsIURI> ResolveURI(const nsCString& aUriStr);
void SetBrowserApp(nsIAndroidBrowserApp* aBrowserApp) {
mBrowserApp = aBrowserApp;
}
--- a/widget/android/nsWindow.cpp
+++ b/widget/android/nsWindow.cpp
@@ -140,17 +140,17 @@ class nsWindow::WindowEvent : public Run
Lambda mLambda;
const InstanceType mInstance;
public:
WindowEvent(Lambda&& aLambda,
InstanceType&& aInstance)
: Runnable("nsWindowEvent")
, mLambda(std::move(aLambda))
- , mInstance(Forward<InstanceType>(aInstance))
+ , mInstance(std::forward<InstanceType>(aInstance))
{}
explicit WindowEvent(Lambda&& aLambda)
: Runnable("nsWindowEvent")
, mLambda(std::move(aLambda))
, mInstance(mLambda.GetThisArg())
{}
@@ -194,17 +194,17 @@ template<class Impl>
template<class Instance, typename... Args> void
nsWindow::NativePtr<Impl>::Attach(Instance aInstance, nsWindow* aWindow,
Args&&... aArgs)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(!mPtr && !mImpl);
Impl* const impl = new Impl(
- this, aWindow, mozilla::Forward<Args>(aArgs)...);
+ this, aWindow, std::forward<Args>(aArgs)...);
mImpl = impl;
// CallAttachNative transfers ownership of impl.
CallAttachNative<Instance, Impl>(aInstance, impl);
}
template<class Impl> void
nsWindow::NativePtr<Impl>::Detach()
--- a/xpcom/base/nsAutoPtr.h
+++ b/xpcom/base/nsAutoPtr.h
@@ -211,17 +211,17 @@ public:
Proxy(T* aRawPtr, member_function aFunction)
: mRawPtr(aRawPtr),
mFunction(aFunction)
{
}
template<typename... ActualArgs>
R operator()(ActualArgs&&... aArgs)
{
- return ((*mRawPtr).*mFunction)(mozilla::Forward<ActualArgs>(aArgs)...);
+ return ((*mRawPtr).*mFunction)(std::forward<ActualArgs>(aArgs)...);
}
};
template <typename R, typename C, typename... Args>
Proxy<R, Args...> operator->*(R (C::*aFptr)(Args...)) const
{
MOZ_ASSERT(mRawPtr != 0,
"You can't dereference a NULL nsAutoPtr with operator->*().");
--- a/xpcom/ds/nsClassHashtable.h
+++ b/xpcom/ds/nsClassHashtable.h
@@ -85,17 +85,17 @@ template<class KeyClass, class T>
template<typename... Args>
T*
nsClassHashtable<KeyClass, T>::LookupOrAdd(KeyType aKey,
Args&&... aConstructionArgs)
{
auto count = this->Count();
typename base_type::EntryType* ent = this->PutEntry(aKey);
if (count != this->Count()) {
- ent->mData = new T(mozilla::Forward<Args>(aConstructionArgs)...);
+ ent->mData = new T(std::forward<Args>(aConstructionArgs)...);
}
return ent->mData;
}
template<class KeyClass, class T>
bool
nsClassHashtable<KeyClass, T>::Get(KeyType aKey, T** aRetVal) const
{
--- a/xpcom/ds/nsTArray.h
+++ b/xpcom/ds/nsTArray.h
@@ -533,17 +533,17 @@ public:
template<class A>
static inline void Construct(E* aE, A&& aArg)
{
typedef typename mozilla::RemoveCV<E>::Type E_NoCV;
typedef typename mozilla::RemoveCV<A>::Type A_NoCV;
static_assert(!mozilla::IsSame<E_NoCV*, A_NoCV>::value,
"For safety, we disallow constructing nsTArray<E> elements "
"from E* pointers. See bug 960591.");
- new (static_cast<void*>(aE)) E(mozilla::Forward<A>(aArg));
+ new (static_cast<void*>(aE)) E(std::forward<A>(aArg));
}
// Invoke the destructor in place.
static inline void Destruct(E* aE) { aE->~E(); }
};
// The default comparator used by nsTArray
template<class A, class B>
class nsDefaultComparator
@@ -1488,17 +1488,17 @@ protected:
public:
template<class Item>
MOZ_MUST_USE
elem_type* InsertElementAt(index_type aIndex, Item&& aItem,
const mozilla::fallible_t&)
{
return InsertElementAt<Item, FallibleAlloc>(aIndex,
- mozilla::Forward<Item>(aItem));
+ std::forward<Item>(aItem));
}
// Reconstruct the element at the given index, and return a pointer to the
// reconstructed element. This will destroy the existing element and
// default-construct a new one, giving you a state much like what single-arg
// InsertElementAt(), or no-arg AppendElement() does, but without changing the
// length of the array.
//
@@ -1553,46 +1553,46 @@ public:
// was previously sorted, it will remain sorted after this
// insertion.
protected:
template<class Item, class Comparator, typename ActualAlloc = Alloc>
elem_type* InsertElementSorted(Item&& aItem, const Comparator& aComp)
{
index_type index = IndexOfFirstElementGt<Item, Comparator>(aItem, aComp);
return InsertElementAt<Item, ActualAlloc>(
- index, mozilla::Forward<Item>(aItem));
+ index, std::forward<Item>(aItem));
}
public:
template<class Item, class Comparator>
MOZ_MUST_USE
elem_type* InsertElementSorted(Item&& aItem, const Comparator& aComp,
const mozilla::fallible_t&)
{
return InsertElementSorted<Item, Comparator, FallibleAlloc>(
- mozilla::Forward<Item>(aItem), aComp);
+ std::forward<Item>(aItem), aComp);
}
// A variation on the InsertElementSorted method defined above.
protected:
template<class Item, typename ActualAlloc = Alloc>
elem_type* InsertElementSorted(Item&& aItem)
{
nsDefaultComparator<elem_type, Item> comp;
return InsertElementSorted<Item, decltype(comp), ActualAlloc>(
- mozilla::Forward<Item>(aItem), comp);
+ std::forward<Item>(aItem), comp);
}
public:
template<class Item>
MOZ_MUST_USE
elem_type* InsertElementSorted(Item&& aItem, const mozilla::fallible_t&)
{
return InsertElementSorted<Item, FallibleAlloc>(
- mozilla::Forward<Item>(aItem));
+ std::forward<Item>(aItem));
}
// This method appends elements to the end of this array.
// @param aArray The elements to append to this array.
// @param aArrayLen The number of elements to append to this array.
// @return A pointer to the new elements in the array, or null if
// the operation failed due to insufficient memory.
protected:
@@ -1671,17 +1671,17 @@ protected:
public:
template<class Item>
/* MOZ_MUST_USE */
elem_type* AppendElement(Item&& aItem,
const mozilla::fallible_t&)
{
- return AppendElement<Item, FallibleAlloc>(mozilla::Forward<Item>(aItem));
+ return AppendElement<Item, FallibleAlloc>(std::forward<Item>(aItem));
}
// Append new elements without copy-constructing. This is useful to avoid
// temporaries.
// @return A pointer to the newly appended elements, or null on OOM.
protected:
template<typename ActualAlloc = Alloc>
elem_type* AppendElements(size_type aCount) {
@@ -2231,17 +2231,17 @@ nsTArray_Impl<E, Alloc>::InsertElementAt
if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
Length() + 1, sizeof(elem_type)))) {
return nullptr;
}
this->template ShiftData<ActualAlloc>(aIndex, 0, 1, sizeof(elem_type),
MOZ_ALIGNOF(elem_type));
elem_type* elem = Elements() + aIndex;
- elem_traits::Construct(elem, mozilla::Forward<Item>(aItem));
+ elem_traits::Construct(elem, std::forward<Item>(aItem));
return elem;
}
template<typename E, class Alloc>
template<class Item, typename ActualAlloc>
auto
nsTArray_Impl<E, Alloc>::AppendElements(const Item* aArray, size_type aArrayLen) -> elem_type*
{
@@ -2285,17 +2285,17 @@ template<class Item, typename ActualAllo
auto
nsTArray_Impl<E, Alloc>::AppendElement(Item&& aItem) -> elem_type*
{
if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
Length() + 1, sizeof(elem_type)))) {
return nullptr;
}
elem_type* elem = Elements() + Length();
- elem_traits::Construct(elem, mozilla::Forward<Item>(aItem));
+ elem_traits::Construct(elem, std::forward<Item>(aItem));
this->mHdr->mLength += 1;
return elem;
}
template<typename E, typename Alloc>
inline void
ImplCycleCollectionUnlink(nsTArray_Impl<E, Alloc>& aField)
{
--- a/xpcom/threads/MozPromise.h
+++ b/xpcom/threads/MozPromise.h
@@ -176,40 +176,40 @@ public:
class ResolveOrRejectValue
{
public:
template<typename ResolveValueType_>
void SetResolve(ResolveValueType_&& aResolveValue)
{
MOZ_ASSERT(IsNothing());
mValue = Storage(VariantIndex<ResolveIndex>{},
- Forward<ResolveValueType_>(aResolveValue));
+ std::forward<ResolveValueType_>(aResolveValue));
}
template<typename RejectValueType_>
void SetReject(RejectValueType_&& aRejectValue)
{
MOZ_ASSERT(IsNothing());
mValue = Storage(VariantIndex<RejectIndex>{},
- Forward<RejectValueType_>(aRejectValue));
+ std::forward<RejectValueType_>(aRejectValue));
}
template<typename ResolveValueType_>
static ResolveOrRejectValue MakeResolve(ResolveValueType_&& aResolveValue)
{
ResolveOrRejectValue val;
- val.SetResolve(Forward<ResolveValueType_>(aResolveValue));
+ val.SetResolve(std::forward<ResolveValueType_>(aResolveValue));
return val;
}
template<typename RejectValueType_>
static ResolveOrRejectValue MakeReject(RejectValueType_&& aRejectValue)
{
ResolveOrRejectValue val;
- val.SetReject(Forward<RejectValueType_>(aRejectValue));
+ val.SetReject(std::forward<RejectValueType_>(aRejectValue));
return val;
}
bool IsResolve() const { return mValue.template is<ResolveIndex>(); }
bool IsReject() const { return mValue.template is<RejectIndex>(); }
bool IsNothing() const { return mValue.template is<NothingIndex>(); }
const ResolveValueType& ResolveValue() const
@@ -260,26 +260,26 @@ public:
// NB: We can include the definition of this class inline once B2G ICS is gone.
class Private;
template<typename ResolveValueType_>
static RefPtr<MozPromise>
CreateAndResolve(ResolveValueType_&& aResolveValue, const char* aResolveSite)
{
RefPtr<typename MozPromise::Private> p = new MozPromise::Private(aResolveSite);
- p->Resolve(Forward<ResolveValueType_>(aResolveValue), aResolveSite);
+ p->Resolve(std::forward<ResolveValueType_>(aResolveValue), aResolveSite);
return p.forget();
}
template<typename RejectValueType_>
static RefPtr<MozPromise>
CreateAndReject(RejectValueType_&& aRejectValue, const char* aRejectSite)
{
RefPtr<typename MozPromise::Private> p = new MozPromise::Private(aRejectSite);
- p->Reject(Forward<RejectValueType_>(aRejectValue), aRejectSite);
+ p->Reject(std::forward<RejectValueType_>(aRejectValue), aRejectSite);
return p.forget();
}
typedef MozPromise<nsTArray<ResolveValueType>, RejectValueType, IsExclusive> AllPromiseType;
private:
class AllPromiseHolder : public MozPromiseRefcountable
{
public:
@@ -512,17 +512,17 @@ protected:
* make the resolve/reject value argument "optional".
*/
template<typename ThisType, typename MethodType, typename ValueType>
static typename EnableIf<
TakesArgument<MethodType>::value,
typename detail::MethodTrait<MethodType>::ReturnType>::Type
InvokeMethod(ThisType* aThisVal, MethodType aMethod, ValueType&& aValue)
{
- return (aThisVal->*aMethod)(Forward<ValueType>(aValue));
+ return (aThisVal->*aMethod)(std::forward<ValueType>(aValue));
}
template<typename ThisType, typename MethodType, typename ValueType>
static typename EnableIf<
!TakesArgument<MethodType>::value,
typename detail::MethodTrait<MethodType>::ReturnType>::Type
InvokeMethod(ThisType* aThisVal, MethodType aMethod, ValueType&& aValue)
{
@@ -536,17 +536,17 @@ protected:
typename ValueType,
typename CompletionPromiseType>
static typename EnableIf<SupportChaining, void>::Type InvokeCallbackMethod(
ThisType* aThisVal,
MethodType aMethod,
ValueType&& aValue,
CompletionPromiseType&& aCompletionPromise)
{
- auto p = InvokeMethod(aThisVal, aMethod, Forward<ValueType>(aValue));
+ auto p = InvokeMethod(aThisVal, aMethod, std::forward<ValueType>(aValue));
if (aCompletionPromise) {
p->ChainTo(aCompletionPromise.forget(), "<chained completion promise>");
}
}
// Called when promise chaining is not supported.
template<bool SupportChaining,
typename ThisType,
@@ -557,17 +557,17 @@ protected:
ThisType* aThisVal,
MethodType aMethod,
ValueType&& aValue,
CompletionPromiseType&& aCompletionPromise)
{
MOZ_DIAGNOSTIC_ASSERT(
!aCompletionPromise,
"Can't do promise chaining for a non-promise-returning method.");
- InvokeMethod(aThisVal, aMethod, Forward<ValueType>(aValue));
+ InvokeMethod(aThisVal, aMethod, std::forward<ValueType>(aValue));
}
template<typename>
class ThenCommand;
template<typename...>
class ThenValue;
@@ -932,20 +932,20 @@ protected:
// Note ThenInternal() might nullify mCompletionPromise before return.
// So we need to return p instead of mCompletionPromise.
mReceiver->ThenInternal(mThenValue.forget(), mCallSite);
return p;
}
template<typename... Ts>
auto Then(Ts&&... aArgs)
- -> decltype(DeclVal<PromiseType>().Then(Forward<Ts>(aArgs)...))
+ -> decltype(DeclVal<PromiseType>().Then(std::forward<Ts>(aArgs)...))
{
return static_cast<RefPtr<PromiseType>>(*this)->Then(
- Forward<Ts>(aArgs)...);
+ std::forward<Ts>(aArgs)...);
}
void Track(MozPromiseRequestHolder<MozPromise>& aRequestHolder)
{
aRequestHolder.Track(do_AddRef(mThenValue));
mReceiver->ThenInternal(mThenValue.forget(), mCallSite);
}
@@ -1110,45 +1110,45 @@ public:
{
PROMISE_ASSERT(mMagic1 == sMagic && mMagic2 == sMagic && mMagic3 == sMagic && mMagic4 == &mMutex);
MutexAutoLock lock(mMutex);
PROMISE_LOG("%s resolving MozPromise (%p created at %s)", aResolveSite, this, mCreationSite);
if (!IsPending()) {
PROMISE_LOG("%s ignored already resolved or rejected MozPromise (%p created at %s)", aResolveSite, this, mCreationSite);
return;
}
- mValue.SetResolve(Forward<ResolveValueT_>(aResolveValue));
+ mValue.SetResolve(std::forward<ResolveValueT_>(aResolveValue));
DispatchAll();
}
template<typename RejectValueT_>
void Reject(RejectValueT_&& aRejectValue, const char* aRejectSite)
{
PROMISE_ASSERT(mMagic1 == sMagic && mMagic2 == sMagic && mMagic3 == sMagic && mMagic4 == &mMutex);
MutexAutoLock lock(mMutex);
PROMISE_LOG("%s rejecting MozPromise (%p created at %s)", aRejectSite, this, mCreationSite);
if (!IsPending()) {
PROMISE_LOG("%s ignored already resolved or rejected MozPromise (%p created at %s)", aRejectSite, this, mCreationSite);
return;
}
- mValue.SetReject(Forward<RejectValueT_>(aRejectValue));
+ mValue.SetReject(std::forward<RejectValueT_>(aRejectValue));
DispatchAll();
}
template<typename ResolveOrRejectValue_>
void ResolveOrReject(ResolveOrRejectValue_&& aValue, const char* aSite)
{
PROMISE_ASSERT(mMagic1 == sMagic && mMagic2 == sMagic && mMagic3 == sMagic && mMagic4 == &mMutex);
MutexAutoLock lock(mMutex);
PROMISE_LOG("%s resolveOrRejecting MozPromise (%p created at %s)", aSite, this, mCreationSite);
if (!IsPending()) {
PROMISE_LOG("%s ignored already resolved or rejected MozPromise (%p created at %s)", aSite, this, mCreationSite);
return;
}
- mValue = Forward<ResolveOrRejectValue_>(aValue);
+ mValue = std::forward<ResolveOrRejectValue_>(aValue);
DispatchAll();
}
};
// A generic promise type that does the trick for simple use cases.
typedef MozPromise<bool, nsresult, /* IsExclusive = */ false> GenericPromise;
/*
@@ -1352,17 +1352,17 @@ template<typename PromiseType, typename
typename... Storages>
class MethodCall : public MethodCallBase
{
public:
template<typename... Args>
MethodCall(MethodType aMethod, ThisType* aThisVal, Args&&... aArgs)
: mMethod(aMethod)
, mThisVal(aThisVal)
- , mArgs(Forward<Args>(aArgs)...)
+ , mArgs(std::forward<Args>(aArgs)...)
{
static_assert(sizeof...(Storages) == sizeof...(Args), "Storages and Args should have equal sizes");
}
RefPtr<PromiseType> Invoke()
{
return mArgs.apply(mThisVal.get(), mMethod);
}
@@ -1416,17 +1416,17 @@ InvokeAsyncImpl(nsISerialEventTarget* aT
{
MOZ_ASSERT(aTarget);
typedef RefPtr<PromiseType>(ThisType::*MethodType)(ArgTypes...);
typedef detail::MethodCall<PromiseType, MethodType, ThisType, Storages...> MethodCallType;
typedef detail::ProxyRunnable<PromiseType, MethodType, ThisType, Storages...> ProxyRunnableType;
MethodCallType* methodCall =
- new MethodCallType(aMethod, aThisVal, Forward<ActualArgTypes>(aArgs)...);
+ new MethodCallType(aMethod, aThisVal, std::forward<ActualArgTypes>(aArgs)...);
RefPtr<typename PromiseType::Private> p = new (typename PromiseType::Private)(aCallerName);
RefPtr<ProxyRunnableType> r = new ProxyRunnableType(p, methodCall);
aTarget->Dispatch(r.forget());
return p.forget();
}
constexpr bool Any()
{
@@ -1459,17 +1459,17 @@ InvokeAsync(nsISerialEventTarget* aTarge
ActualArgTypes&&... aArgs)
{
static_assert(sizeof...(Storages) == sizeof...(ArgTypes),
"Provided Storages and method's ArgTypes should have equal sizes");
static_assert(sizeof...(Storages) == sizeof...(ActualArgTypes),
"Provided Storages and ActualArgTypes should have equal sizes");
return detail::InvokeAsyncImpl<Storages...>(
aTarget, aThisVal, aCallerName, aMethod,
- Forward<ActualArgTypes>(aArgs)...);
+ std::forward<ActualArgTypes>(aArgs)...);
}
// InvokeAsync with no explicitly-specified storages, will copy arguments and
// then move them out of the runnable into the target method parameters.
template<typename... Storages,
typename PromiseType, typename ThisType, typename... ArgTypes,
typename... ActualArgTypes,
typename EnableIf<sizeof...(Storages) == 0, int>::Type = 0>
@@ -1479,32 +1479,32 @@ InvokeAsync(nsISerialEventTarget* aTarge
ActualArgTypes&&... aArgs)
{
static_assert(!detail::Any(IsPointer<typename RemoveReference<ActualArgTypes>::Type>::value...),
"Cannot pass pointer types through InvokeAsync, Storages must be provided");
static_assert(sizeof...(ArgTypes) == sizeof...(ActualArgTypes),
"Method's ArgTypes and ActualArgTypes should have equal sizes");
return detail::InvokeAsyncImpl<StoreCopyPassByRRef<typename Decay<ActualArgTypes>::Type>...>(
aTarget, aThisVal, aCallerName, aMethod,
- Forward<ActualArgTypes>(aArgs)...);
+ std::forward<ActualArgTypes>(aArgs)...);
}
namespace detail {
template<typename Function, typename PromiseType>
class ProxyFunctionRunnable : public CancelableRunnable
{
typedef typename Decay<Function>::Type FunctionStorage;
public:
template<typename F>
ProxyFunctionRunnable(typename PromiseType::Private* aProxyPromise,
F&& aFunction)
: CancelableRunnable("detail::ProxyFunctionRunnable")
, mProxyPromise(aProxyPromise)
- , mFunction(new FunctionStorage(Forward<F>(aFunction)))
+ , mFunction(new FunctionStorage(std::forward<F>(aFunction)))
{
}
NS_IMETHOD Run() override
{
RefPtr<PromiseType> p = (*mFunction)();
mFunction = nullptr;
p->ChainTo(mProxyPromise.forget(), "<Proxy Promise>");
@@ -1543,17 +1543,17 @@ InvokeAsync(nsISerialEventTarget* aTarge
&& IsMozPromise<typename RemoveSmartPointer<
decltype(aFunction())>::Type>::value,
"Function object must return RefPtr<MozPromise>");
MOZ_ASSERT(aTarget);
typedef typename RemoveSmartPointer<decltype(aFunction())>::Type PromiseType;
typedef detail::ProxyFunctionRunnable<Function, PromiseType> ProxyRunnableType;
auto p = MakeRefPtr<typename PromiseType::Private>(aCallerName);
- auto r = MakeRefPtr<ProxyRunnableType>(p, Forward<Function>(aFunction));
+ auto r = MakeRefPtr<ProxyRunnableType>(p, std::forward<Function>(aFunction));
aTarget->Dispatch(r.forget());
return p.forget();
}
} // namespace detail
// Invoke a function object (e.g., lambda) asynchronously.
// Return a promise that the function should eventually resolve or reject.
@@ -1563,17 +1563,17 @@ InvokeAsync(nsISerialEventTarget* aTarge
Function&& aFunction)
-> decltype(aFunction())
{
static_assert(!IsLvalueReference<Function>::value,
"Function object must not be passed by lvalue-ref (to avoid "
"unplanned copies); Consider move()ing the object.");
return detail::InvokeAsync(aTarget, aCallerName,
detail::AllowInvokeAsyncFunctionLVRef(),
- Forward<Function>(aFunction));
+ std::forward<Function>(aFunction));
}
#undef PROMISE_LOG
#undef PROMISE_ASSERT
#undef PROMISE_DEBUG
} // namespace mozilla
--- a/xpcom/threads/nsThreadUtils.h
+++ b/xpcom/threads/nsThreadUtils.h
@@ -538,17 +538,17 @@ namespace detail {
// return void.
template<typename StoredFunction>
class RunnableFunction : public Runnable
{
public:
template <typename F>
explicit RunnableFunction(const char* aName, F&& aFunction)
: Runnable(aName)
- , mFunction(Forward<F>(aFunction))
+ , mFunction(std::forward<F>(aFunction))
{ }
NS_IMETHOD Run() override {
static_assert(IsVoid<decltype(mFunction())>::value,
"The lambda must return void!");
mFunction();
return NS_OK;
}
@@ -652,17 +652,17 @@ ToSupports(mozilla::Runnable *p)
template<typename Function>
already_AddRefed<mozilla::Runnable>
NS_NewRunnableFunction(const char* aName, Function&& aFunction)
{
// We store a non-reference in RunnableFunction, but still forward aFunction
// to move if possible.
return do_AddRef(
new mozilla::detail::RunnableFunctionImpl<Function>(
- aName, mozilla::Forward<Function>(aFunction)));
+ aName, std::forward<Function>(aFunction)));
}
namespace mozilla {
namespace detail {
template <RunnableKind Kind>
class TimerBehaviour
{
@@ -864,59 +864,59 @@ struct IsParameterStorageClass : public
template<typename T>
struct StoreCopyPassByValue
{
typedef typename mozilla::Decay<T>::Type stored_type;
typedef stored_type passed_type;
stored_type m;
template <typename A>
- MOZ_IMPLICIT StoreCopyPassByValue(A&& a) : m(mozilla::Forward<A>(a)) {}
+ MOZ_IMPLICIT StoreCopyPassByValue(A&& a) : m(std::forward<A>(a)) {}
passed_type PassAsParameter() { return m; }
};
template<typename S>
struct IsParameterStorageClass<StoreCopyPassByValue<S>>
: public mozilla::TrueType {};
template<typename T>
struct StoreCopyPassByConstLRef
{
typedef typename mozilla::Decay<T>::Type stored_type;
typedef const stored_type& passed_type;
stored_type m;
template <typename A>
- MOZ_IMPLICIT StoreCopyPassByConstLRef(A&& a) : m(mozilla::Forward<A>(a)) {}
+ MOZ_IMPLICIT StoreCopyPassByConstLRef(A&& a) : m(std::forward<A>(a)) {}
passed_type PassAsParameter() { return m; }
};
template<typename S>
struct IsParameterStorageClass<StoreCopyPassByConstLRef<S>>
: public mozilla::TrueType {};
template<typename T>
struct StoreCopyPassByLRef
{
typedef typename mozilla::Decay<T>::Type stored_type;
typedef stored_type& passed_type;
stored_type m;
template <typename A>
- MOZ_IMPLICIT StoreCopyPassByLRef(A&& a) : m(mozilla::Forward<A>(a)) {}
+ MOZ_IMPLICIT StoreCopyPassByLRef(A&& a) : m(std::forward<A>(a)) {}
passed_type PassAsParameter() { return m; }
};
template<typename S>
struct IsParameterStorageClass<StoreCopyPassByLRef<S>>
: public mozilla::TrueType {};
template<typename T>
struct StoreCopyPassByRRef
{
typedef typename mozilla::Decay<T>::Type stored_type;
typedef stored_type&& passed_type;
stored_type m;
template <typename A>
- MOZ_IMPLICIT StoreCopyPassByRRef(A&& a) : m(mozilla::Forward<A>(a)) {}
+ MOZ_IMPLICIT StoreCopyPassByRRef(A&& a) : m(std::forward<A>(a)) {}
passed_type PassAsParameter() { return std::move(m); }
};
template<typename S>
struct IsParameterStorageClass<StoreCopyPassByRRef<S>>
: public mozilla::TrueType {};
template<typename T>
struct StoreRefPassByLRef
@@ -948,17 +948,17 @@ struct IsParameterStorageClass<StoreCons
template<typename T>
struct StoreRefPtrPassByPtr
{
typedef RefPtr<T> stored_type;
typedef T* passed_type;
stored_type m;
template <typename A>
- MOZ_IMPLICIT StoreRefPtrPassByPtr(A&& a) : m(mozilla::Forward<A>(a)) {}
+ MOZ_IMPLICIT StoreRefPtrPassByPtr(A&& a) : m(std::forward<A>(a)) {}
passed_type PassAsParameter() { return m.get(); }
};
template<typename S>
struct IsParameterStorageClass<StoreRefPtrPassByPtr<S>>
: public mozilla::TrueType {};
template<typename T>
struct StorePtrPassByPtr
@@ -990,31 +990,31 @@ struct IsParameterStorageClass<StoreCons
template<typename T>
struct StoreCopyPassByConstPtr
{
typedef T stored_type;
typedef const T* passed_type;
stored_type m;
template <typename A>
- MOZ_IMPLICIT StoreCopyPassByConstPtr(A&& a) : m(mozilla::Forward<A>(a)) {}
+ MOZ_IMPLICIT StoreCopyPassByConstPtr(A&& a) : m(std::forward<A>(a)) {}
passed_type PassAsParameter() { return &m; }
};
template<typename S>
struct IsParameterStorageClass<StoreCopyPassByConstPtr<S>>
: public mozilla::TrueType {};
template<typename T>
struct StoreCopyPassByPtr
{
typedef T stored_type;
typedef T* passed_type;
stored_type m;
template <typename A>
- MOZ_IMPLICIT StoreCopyPassByPtr(A&& a) : m(mozilla::Forward<A>(a)) {}
+ MOZ_IMPLICIT StoreCopyPassByPtr(A&& a) : m(std::forward<A>(a)) {}
passed_type PassAsParameter() { return &m; }
};
template<typename S>
struct IsParameterStorageClass<StoreCopyPassByPtr<S>>
: public mozilla::TrueType {};
namespace detail {
@@ -1150,17 +1150,17 @@ namespace detail {
// struct used to store arguments and later apply them to a method.
template <typename... Ts>
struct RunnableMethodArguments final
{
Tuple<typename ::detail::ParameterStorage<Ts>::Type...> mArguments;
template <typename... As>
explicit RunnableMethodArguments(As&&... aArguments)
- : mArguments(Forward<As>(aArguments)...)
+ : mArguments(std::forward<As>(aArguments)...)
{}
template<typename C, typename M, typename... Args, size_t... Indices>
static auto
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()...);
}
@@ -1196,19 +1196,19 @@ private:
r->Run();
r->Cancel();
}
public:
template<typename ForwardedPtrType, typename... Args>
explicit RunnableMethodImpl(const char* aName, ForwardedPtrType&& aObj,
Method aMethod, Args&&... aArgs)
: BaseType(aName)
- , mReceiver(Forward<ForwardedPtrType>(aObj))
+ , mReceiver(std::forward<ForwardedPtrType>(aObj))
, mMethod(aMethod)
- , mArgs(Forward<Args>(aArgs)...)
+ , mArgs(std::forward<Args>(aArgs)...)
{
static_assert(sizeof...(Storages) == sizeof...(Args), "Storages and Args should have equal sizes");
}
NS_IMETHOD Run()
{
CancelTimer();
@@ -1408,172 +1408,172 @@ using NonOwningIdleRunnableMethodWithTim
// should be used in new code exclusively.
template<typename PtrType, typename Method>
already_AddRefed<detail::OwningRunnableMethod<PtrType, Method>>
NewRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod)
{
return do_AddRef(
new detail::OwningRunnableMethodImpl<PtrType, Method>(
- aName, Forward<PtrType>(aPtr), aMethod));
+ aName, std::forward<PtrType>(aPtr), aMethod));
}
template<typename PtrType, typename Method>
already_AddRefed<detail::CancelableRunnableMethod<PtrType, Method>>
NewCancelableRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod)
{
return do_AddRef(
new detail::CancelableRunnableMethodImpl<PtrType, Method>(
- aName, Forward<PtrType>(aPtr), aMethod));
+ aName, std::forward<PtrType>(aPtr), aMethod));
}
template<typename PtrType, typename Method>
already_AddRefed<detail::IdleRunnableMethod<PtrType, Method>>
NewIdleRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod)
{
return do_AddRef(
new detail::IdleRunnableMethodImpl<PtrType, Method>(
- aName, Forward<PtrType>(aPtr), aMethod));
+ aName, std::forward<PtrType>(aPtr), aMethod));
}
template<typename PtrType, typename Method>
already_AddRefed<detail::IdleRunnableMethodWithTimer<PtrType, Method>>
NewIdleRunnableMethodWithTimer(const char* aName,
PtrType&& aPtr,
Method aMethod)
{
return do_AddRef(
new detail::IdleRunnableMethodWithTimerImpl<PtrType, Method>(
- aName, Forward<PtrType>(aPtr), aMethod));
+ aName, std::forward<PtrType>(aPtr), aMethod));
}
template<typename PtrType, typename Method>
already_AddRefed<detail::NonOwningRunnableMethod<PtrType, Method>>
NewNonOwningRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod)
{
return do_AddRef(
new detail::NonOwningRunnableMethodImpl<PtrType, Method>(
- aName, Forward<PtrType>(aPtr), aMethod));
+ aName, std::forward<PtrType>(aPtr), aMethod));
}
template<typename PtrType, typename Method>
already_AddRefed<detail::NonOwningCancelableRunnableMethod<PtrType, Method>>
NewNonOwningCancelableRunnableMethod(const char* aName, PtrType&& aPtr,
Method aMethod)
{
return do_AddRef(
new detail::NonOwningCancelableRunnableMethodImpl<PtrType, Method>(
- aName, Forward<PtrType>(aPtr), aMethod));
+ aName, std::forward<PtrType>(aPtr), aMethod));
}
template<typename PtrType, typename Method>
already_AddRefed<detail::NonOwningIdleRunnableMethod<PtrType, Method>>
NewNonOwningIdleRunnableMethod(const char* aName,
PtrType&& aPtr,
Method aMethod)
{
return do_AddRef(
new detail::NonOwningIdleRunnableMethodImpl<PtrType, Method>(
- aName, Forward<PtrType>(aPtr), aMethod));
+ aName, std::forward<PtrType>(aPtr), aMethod));
}
template<typename PtrType, typename Method>
already_AddRefed<detail::NonOwningIdleRunnableMethodWithTimer<PtrType, Method>>
NewNonOwningIdleRunnableMethodWithTimer(const char* aName,
PtrType&& aPtr,
Method aMethod)
{
return do_AddRef(
new detail::NonOwningIdleRunnableMethodWithTimerImpl<PtrType, Method>(
- aName, Forward<PtrType>(aPtr), aMethod));
+ aName, std::forward<PtrType>(aPtr), aMethod));
}
// Similar to NewRunnableMethod. Call like so:
// nsCOMPtr<nsIRunnable> event =
// NewRunnableMethod<Types,...>(myObject, &MyClass::HandleEvent, myArg1,...);
// 'Types' are the stored type for each argument, see ParameterStorage for details.
template<typename... Storages, typename PtrType, typename Method, typename... Args>
already_AddRefed<detail::OwningRunnableMethod<PtrType, Method>>
NewRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod, Args&&... aArgs)
{
static_assert(sizeof...(Storages) == sizeof...(Args),
"<Storages...> size should be equal to number of arguments");
return do_AddRef(
new detail::OwningRunnableMethodImpl<PtrType, Method, Storages...>(
- aName, Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
+ aName, std::forward<PtrType>(aPtr), aMethod, std::forward<Args>(aArgs)...));
}
template<typename... Storages, typename PtrType, typename Method, typename... Args>
already_AddRefed<detail::NonOwningRunnableMethod<PtrType, Method>>
NewNonOwningRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod,
Args&&... aArgs)
{
static_assert(sizeof...(Storages) == sizeof...(Args),
"<Storages...> size should be equal to number of arguments");
return do_AddRef(
new detail::NonOwningRunnableMethodImpl<PtrType, Method, Storages...>(
- aName, Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
+ aName, std::forward<PtrType>(aPtr), aMethod, std::forward<Args>(aArgs)...));
}
template<typename... Storages, typename PtrType, typename Method, typename... Args>
already_AddRefed<detail::CancelableRunnableMethod<PtrType, Method>>
NewCancelableRunnableMethod(const char* aName, PtrType&& aPtr, Method aMethod,
Args&&... aArgs)
{
static_assert(sizeof...(Storages) == sizeof...(Args),
"<Storages...> size should be equal to number of arguments");
return do_AddRef(
new detail::CancelableRunnableMethodImpl<PtrType, Method, Storages...>(
- aName, Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
+ aName, std::forward<PtrType>(aPtr), aMethod, std::forward<Args>(aArgs)...));
}
template<typename... Storages, typename PtrType, typename Method, typename... Args>
already_AddRefed<detail::NonOwningCancelableRunnableMethod<PtrType, Method>>
NewNonOwningCancelableRunnableMethod(const char* aName, PtrType&& aPtr,
Method aMethod, Args&&... aArgs)
{
static_assert(sizeof...(Storages) == sizeof...(Args),
"<Storages...> size should be equal to number of arguments");
return do_AddRef(
new detail::NonOwningCancelableRunnableMethodImpl<PtrType, Method, Storages...>(
- aName, Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
+ aName, std::forward<PtrType>(aPtr), aMethod, std::forward<Args>(aArgs)...));
}
template<typename... Storages,
typename PtrType,
typename Method,
typename... Args>
already_AddRefed<detail::IdleRunnableMethod<PtrType, Method>>
NewIdleRunnableMethod(const char* aName,
PtrType&& aPtr,
Method aMethod,
Args&&... aArgs)
{
static_assert(sizeof...(Storages) == sizeof...(Args),
"<Storages...> size should be equal to number of arguments");
return do_AddRef(
new detail::IdleRunnableMethodImpl<PtrType, Method, Storages...>(
- aName, Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
+ aName, std::forward<PtrType>(aPtr), aMethod, std::forward<Args>(aArgs)...));
}
template<typename... Storages,
typename PtrType,
typename Method,
typename... Args>
already_AddRefed<detail::NonOwningIdleRunnableMethod<PtrType, Method>>
NewNonOwningIdleRunnableMethod(const char* aName,
PtrType&& aPtr,
Method aMethod,
Args&&... aArgs)
{
static_assert(sizeof...(Storages) == sizeof...(Args),
"<Storages...> size should be equal to number of arguments");
return do_AddRef(
new detail::NonOwningIdleRunnableMethodImpl<PtrType, Method, Storages...>(
- aName, Forward<PtrType>(aPtr), aMethod, mozilla::Forward<Args>(aArgs)...));
+ aName, std::forward<PtrType>(aPtr), aMethod, std::forward<Args>(aArgs)...));
}
} // namespace mozilla
#endif // XPCOM_GLUE_AVOID_NSPR
// This class is designed to be used when you have an event class E that has a
// pointer back to resource class R. If R goes away while E is still pending,