author | Emilio Cobos Álvarez <emilio@crisal.io> |
Fri, 01 Jun 2018 18:30:30 +0200 | |
changeset 420970 | bb85c5ee5afc151be0d07ecc48318dc69cfef446 |
parent 420969 | 4aed3a8d30d84131ff5af1900ea4e2d6a6fc7d1d |
child 420971 | 91627f5e19c7e5722405e8098f0084c394557593 |
push id | 34083 |
push user | apavel@mozilla.com |
push date | Sat, 02 Jun 2018 23:03:25 +0000 |
treeherder | mozilla-central@1f62ecdf59b6 [default view] [failures only] |
perfherder | [talos] [build metrics] [platform microbench] (compared to previous push) |
reviewers | froydnj |
bugs | 1466168 |
milestone | 62.0a1 |
first release with | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
last release without | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
--- 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,