Bug 1466168: Remove mozilla::Forward in favor of std::forward. r=froydnj
authorEmilio Cobos Álvarez <emilio@crisal.io>
Fri, 01 Jun 2018 18:30:30 +0200
changeset 477694 bb85c5ee5afc151be0d07ecc48318dc69cfef446
parent 477693 4aed3a8d30d84131ff5af1900ea4e2d6a6fc7d1d
child 477695 91627f5e19c7e5722405e8098f0084c394557593
push id1757
push userffxbld-merge
push dateFri, 24 Aug 2018 17:02:43 +0000
treeherdermozilla-release@736023aebdb1 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1466168
milestone62.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
Bug 1466168: Remove mozilla::Forward in favor of std::forward. r=froydnj Same approach as the other bug, mostly replacing automatically by removing 'using mozilla::Forward;' and then: s/mozilla::Forward/std::forward/ s/Forward</std::forward</ The only file that required manual fixup was TestTreeTraversal.cpp, which had a class called TestNodeForward with template parameters :) MozReview-Commit-ID: A88qFG5AccP
accessible/xpcom/xpcAccessibleTextRange.h
devtools/shared/heapsnapshot/HeapSnapshot.cpp
dom/animation/Animation.cpp
dom/animation/EffectCompositor.cpp
dom/bindings/BindingDeclarations.h
dom/bindings/ErrorResult.h
dom/clients/manager/ClientManagerOpParent.cpp
dom/console/nsIConsoleReportCollector.h
dom/html/HTMLMediaElement.cpp
dom/media/AudioStream.cpp
dom/media/Intervals.h
dom/media/MediaDecoderStateMachine.cpp
dom/media/MediaDecoderStateMachine.h
dom/media/MediaEventSource.h
dom/media/MediaInfo.h
dom/media/MediaManager.cpp
dom/media/MediaSegment.h
dom/media/MediaTimer.h
dom/media/VideoSegment.h
dom/media/doctor/DecoderDoctorLogger.h
dom/media/gmp/ChromiumCDMCallbackProxy.cpp
dom/media/gmp/ChromiumCDMChild.cpp
dom/media/mp4/MP4Metadata.h
dom/media/platforms/PDMFactory.cpp
dom/media/platforms/PlatformDecoderModule.h
dom/media/systemservices/CamerasChild.h
dom/media/systemservices/MediaTaskUtils.h
dom/media/systemservices/MediaUtils.h
dom/media/webrtc/MediaEngineRemoteVideoSource.h
dom/serviceworkers/ServiceWorkerEvents.cpp
gfx/2d/DrawingJob.h
gfx/2d/IterableArena.h
image/DecoderFactory.cpp
image/SurfacePipe.h
image/test/gtest/TestADAM7InterpolatingFilter.cpp
image/test/gtest/TestDeinterlacingFilter.cpp
image/test/gtest/TestDownscalingFilter.cpp
image/test/gtest/TestRemoveFrameRectFilter.cpp
image/test/gtest/TestSurfaceSink.cpp
ipc/chromium/src/base/task.h
ipc/chromium/src/chrome/common/ipc_message_utils.h
ipc/glue/IPDLParamTraits.h
ipc/glue/TaskFactory.h
ipc/mscom/ActivationContext.h
ipc/mscom/AsyncInvoker.h
ipc/mscom/COMPtrHolder.h
ipc/mscom/MainThreadInvoker.h
ipc/mscom/Registration.cpp
ipc/mscom/oop/Factory.h
js/public/GCHashTable.h
js/public/GCVector.h
js/public/HashTable.h
js/public/HeapAPI.h
js/public/Id.h
js/public/RootingAPI.h
js/public/SweepingAPI.h
js/public/TraceKind.h
js/public/UbiNode.h
js/public/UniquePtr.h
js/public/Utility.h
js/public/Value.h
js/src/builtin/ReflectParse.cpp
js/src/ds/Fifo.h
js/src/ds/InlineTable.h
js/src/ds/LifoAlloc.h
js/src/ds/OrderedHashTable.h
js/src/ds/TraceableFifo.h
js/src/frontend/EitherParser.h
js/src/gc/GC.cpp
js/src/gc/Marking.cpp
js/src/gc/Zone.h
js/src/jit/IonControlFlow.h
js/src/jit/MIR.h
js/src/jit/SharedIC.h
js/src/jit/shared/Assembler-shared.h
js/src/jit/shared/CodeGenerator-shared.h
js/src/jit/shared/Lowering-shared-inl.h
js/src/threading/ExclusiveData.h
js/src/threading/ProtectedData.h
js/src/threading/Thread.h
js/src/vm/DebuggerMemory.cpp
js/src/vm/ObjectGroup.cpp
js/src/vm/SavedFrame.h
js/src/vm/TaggedProto.h
js/src/wasm/WasmBaselineCompile.cpp
js/xpconnect/loader/ScriptPreloader.cpp
layout/painting/nsDisplayList.h
media/mtransport/runnable_utils.h
mfbt/Array.h
mfbt/EnumeratedArray.h
mfbt/LinkedList.h
mfbt/Maybe.h
mfbt/MaybeOneOf.h
mfbt/Move.h
mfbt/NotNull.h
mfbt/Pair.h
mfbt/RefPtr.h
mfbt/Result.h
mfbt/SegmentedVector.h
mfbt/Span.h
mfbt/Tuple.h
mfbt/UniquePtr.h
mfbt/UniquePtrExtensions.h
mfbt/Variant.h
mfbt/Vector.h
mozglue/misc/DynamicallyLinkedFunctionPtr.h
mozglue/misc/interceptor/PatcherBase.h
mozglue/misc/interceptor/PatcherDetour.h
mozglue/misc/interceptor/PatcherNopSpace.h
mozglue/misc/interceptor/VMSharingPolicies.h
mozglue/misc/nsWindowsDllInterceptor.h
security/sandbox/linux/SandboxOpenedFiles.h
toolkit/components/extensions/MatchPattern.h
toolkit/components/url-classifier/tests/gtest/Common.cpp
widget/android/jni/Natives.h
widget/android/nsAppShell.h
widget/android/nsWindow.cpp
xpcom/base/nsAutoPtr.h
xpcom/ds/nsClassHashtable.h
xpcom/ds/nsTArray.h
xpcom/threads/MozPromise.h
xpcom/threads/nsThreadUtils.h
--- 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,