--- 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 {