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 469189 bb85c5ee5afc151be0d07ecc48318dc69cfef446
parent 469188 4aed3a8d30d84131ff5af1900ea4e2d6a6fc7d1d
child 469190 91627f5e19c7e5722405e8098f0084c394557593
push id187
push userfmarier@mozilla.com
push dateMon, 04 Jun 2018 22:28:11 +0000
reviewersfroydnj
bugs1466168
milestone62.0a1
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,