Merge mozilla-central to autoland. a=merge CLOSED TREE
authorCsoregi Natalia <ncsoregi@mozilla.com>
Sat, 02 Jun 2018 01:03:45 +0300
changeset 477795 aeea710872fef737c3a4fcef9925fe7c18058f21
parent 477794 4146b1ddbb34d890b76e47584c93232171180fee (current diff)
parent 477592 cbf9ea7c5531a1ab80ab716eae4c8eb71f6ebaae (diff)
child 477796 6e7c5695e34172b4975c4ad566f6cba309a1580c
push id1757
push userffxbld-merge
push dateFri, 24 Aug 2018 17:02:43 +0000
treeherdermozilla-release@736023aebdb1 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone62.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge mozilla-central to autoland. a=merge CLOSED TREE
dom/base/nsDOMWindowUtils.cpp
dom/base/nsFrameLoader.cpp
dom/base/nsFrameMessageManager.cpp
dom/events/EventDispatcher.cpp
dom/events/EventListenerManager.cpp
dom/indexedDB/ActorsChild.cpp
dom/indexedDB/ActorsParent.cpp
dom/ipc/ContentChild.cpp
dom/ipc/TabChild.cpp
dom/ipc/TabParent.cpp
dom/workers/WorkerPrivate.cpp
gfx/layers/PaintThread.cpp
gfx/thebes/gfxWindowsPlatform.cpp
js/src/gc/GC.cpp
js/xpconnect/src/XPCJSRuntime.cpp
layout/base/PresShell.cpp
layout/base/nsRefreshDriver.cpp
netwerk/protocol/http/HttpChannelChild.cpp
security/manager/ssl/nsNSSCertificate.cpp
security/manager/ssl/nsNSSCertificateDB.cpp
security/manager/ssl/nsNSSComponent.cpp
tools/profiler/core/platform.cpp
tools/profiler/tests/gtest/GeckoProfiler.cpp
widget/android/nsAppShell.cpp
widget/cocoa/nsChildView.mm
widget/gtk/nsWindow.cpp
xpcom/base/CycleCollectedJSRuntime.cpp
xpcom/base/nsCycleCollector.cpp
xpcom/threads/Scheduler.cpp
xpcom/threads/ThreadEventQueue.cpp
xpcom/threads/nsThreadPool.cpp
--- a/accessible/base/EventTree.cpp
+++ b/accessible/base/EventTree.cpp
@@ -173,17 +173,17 @@ EventTree::Process(const RefPtr<DocAcces
   while (mFirst) {
     // Skip a node and its subtree if its container is not in the document.
     if (mFirst->mContainer->IsInDocument()) {
       mFirst->Process(aDeathGrip);
       if (aDeathGrip->IsDefunct()) {
         return;
       }
     }
-    mFirst = Move(mFirst->mNext);
+    mFirst = std::move(mFirst->mNext);
   }
 
   MOZ_ASSERT(mContainer || mDependentEvents.IsEmpty(),
              "No container, no events");
   MOZ_ASSERT(!mContainer || !mContainer->IsDefunct(),
              "Processing events for defunct container");
   MOZ_ASSERT(!mFireReorder || mContainer, "No target for reorder event");
 
@@ -324,19 +324,19 @@ EventTree::FindOrInsert(Accessible* aCon
         continue;
       }
 
       // Insert the tail node into the hierarchy between the current node and
       // its parent.
       node->mFireReorder = false;
       UniquePtr<EventTree>& nodeOwnerRef = prevNode ? prevNode->mNext : mFirst;
       UniquePtr<EventTree> newNode(new EventTree(aContainer, mDependentEvents.IsEmpty()));
-      newNode->mFirst = Move(nodeOwnerRef);
-      nodeOwnerRef = Move(newNode);
-      nodeOwnerRef->mNext = Move(node->mNext);
+      newNode->mFirst = std::move(nodeOwnerRef);
+      nodeOwnerRef = std::move(newNode);
+      nodeOwnerRef->mNext = std::move(node->mNext);
 
       // Check if a next node is contained by the given node too, and move them
       // under the given node if so.
       prevNode = nodeOwnerRef.get();
       node = nodeOwnerRef->mNext.get();
       UniquePtr<EventTree>* nodeRef = &nodeOwnerRef->mNext;
       EventTree* insNode = nodeOwnerRef->mFirst.get();
       while (node) {
@@ -345,20 +345,20 @@ EventTree::FindOrInsert(Accessible* aCon
           if (curParent->Parent() != aContainer) {
             curParent = curParent->Parent();
             continue;
           }
 
           MOZ_ASSERT(!insNode->mNext);
 
           node->mFireReorder = false;
-          insNode->mNext = Move(*nodeRef);
+          insNode->mNext = std::move(*nodeRef);
           insNode = insNode->mNext.get();
 
-          prevNode->mNext = Move(node->mNext);
+          prevNode->mNext = std::move(node->mNext);
           node = prevNode;
           break;
         }
 
         prevNode = node;
         nodeRef = &node->mNext;
         node = node->mNext.get();
       }
@@ -503,17 +503,17 @@ EventTree::Mutated(AccMutationEvent* aEv
           AccHideEvent* hideEv = downcast_accEvent(aEv);
           if (!hideEv->mNeedsShutdown) {
             for (uint32_t i = 0; i < (*node)->mDependentEvents.Length(); i++) {
               AccMutationEvent* childEv = (*node)->mDependentEvents[i];
               if (childEv->IsShow()) {
                 AccShowEvent* childShowEv = downcast_accEvent(childEv);
                 if (childShowEv->mPrecedingEvents.Length() > 0) {
                   Controller(mContainer)->StorePrecedingEvents(
-                    mozilla::Move(childShowEv->mPrecedingEvents));
+                    std::move(childShowEv->mPrecedingEvents));
                 }
               }
             }
           }
         }
         // If the new show contains existing child shows, then move preceding
         // events from the child shows to the new show.
         else if (aEv->IsShow()) {
@@ -535,17 +535,17 @@ EventTree::Mutated(AccMutationEvent* aEv
                 }
 #endif
                 showEv->mPrecedingEvents.AppendElements(showChildEv->mPrecedingEvents);
               }
             }
           }
         }
 
-        *node = Move((*node)->mNext);
+        *node = std::move((*node)->mNext);
         break;
       }
       cntr = cntr->Parent();
     }
     if (cntr == aEv->mAccessible) {
       continue;
     }
     node = &(*node)->mNext;
--- a/accessible/base/NotificationController.cpp
+++ b/accessible/base/NotificationController.cpp
@@ -787,17 +787,17 @@ NotificationController::WillRefresh(mozi
     }
 
     nsIContent* ownerContent = mDocument->DocumentNode()->
       FindContentForSubDocument(childDoc->DocumentNode());
     if (ownerContent) {
       Accessible* outerDocAcc = mDocument->GetAccessible(ownerContent);
       if (outerDocAcc && outerDocAcc->AppendChild(childDoc)) {
         if (mDocument->AppendChildDocument(childDoc)) {
-          newChildDocs.AppendElement(Move(mHangingChildDocuments[idx]));
+          newChildDocs.AppendElement(std::move(mHangingChildDocuments[idx]));
           continue;
         }
 
         outerDocAcc->RemoveChild(childDoc);
       }
 
       // Failed to bind the child document, destroy it.
       childDoc->Shutdown();
@@ -859,17 +859,17 @@ NotificationController::WillRefresh(mozi
   // events causes script to run.
   mObservingState = eRefreshProcessing;
 
   CoalesceMutationEvents();
   ProcessMutationEvents();
   mEventGeneration = 0;
 
   // Now that we are done with them get rid of the events we fired.
-  RefPtr<AccTreeMutationEvent> mutEvent = Move(mFirstMutationEvent);
+  RefPtr<AccTreeMutationEvent> mutEvent = std::move(mFirstMutationEvent);
   mLastMutationEvent = nullptr;
   mFirstMutationEvent = nullptr;
   while (mutEvent) {
     RefPtr<AccTreeMutationEvent> nextEvent = mutEvent->NextEvent();
     Accessible* target = mutEvent->GetAccessible();
 
     // We need to be careful here, while it may seem that we can simply 0 all
     // the pending event bits that is not true.  Because accessibles may be
--- a/accessible/base/NotificationController.h
+++ b/accessible/base/NotificationController.h
@@ -289,17 +289,17 @@ private:
   virtual void WillRefresh(mozilla::TimeStamp aTime) override;
 
   /**
    * Set and returns a hide event, paired with a show event, for the move.
    */
   void WithdrawPrecedingEvents(nsTArray<RefPtr<AccHideEvent>>* aEvs)
   {
     if (mPrecedingEvents.Length() > 0) {
-      aEvs->AppendElements(mozilla::Move(mPrecedingEvents));
+      aEvs->AppendElements(std::move(mPrecedingEvents));
     }
   }
   void StorePrecedingEvent(AccHideEvent* aEv)
   {
     MOZ_ASSERT(mMoveGuardOnStack, "No move guard on stack!");
     mPrecedingEvents.AppendElement(aEv);
   }
   void StorePrecedingEvents(nsTArray<RefPtr<AccHideEvent>>&& aEvs)
--- a/accessible/base/Relation.h
+++ b/accessible/base/Relation.h
@@ -30,24 +30,24 @@ public:
     mFirstIter(nullptr), mLastIter(nullptr)
     { AppendTarget(aAcc); }
 
   Relation(DocAccessible* aDocument, nsIContent* aContent) :
     mFirstIter(nullptr), mLastIter(nullptr)
     { AppendTarget(aDocument, aContent); }
 
   Relation(Relation&& aOther) :
-    mFirstIter(Move(aOther.mFirstIter)), mLastIter(aOther.mLastIter)
+    mFirstIter(std::move(aOther.mFirstIter)), mLastIter(aOther.mLastIter)
   {
     aOther.mLastIter = nullptr;
   }
 
   Relation& operator = (Relation&& aRH)
   {
-    mFirstIter = Move(aRH.mFirstIter);
+    mFirstIter = std::move(aRH.mFirstIter);
     mLastIter = aRH.mLastIter;
     aRH.mLastIter = nullptr;
     return *this;
   }
 
   inline void AppendIter(AccIterable* aIter)
   {
     if (mLastIter)
--- a/accessible/base/TextRange.h
+++ b/accessible/base/TextRange.h
@@ -44,26 +44,26 @@ struct TextPoint final
 class TextRange final
 {
 public:
   TextRange(HyperTextAccessible* aRoot,
             HyperTextAccessible* aStartContainer, int32_t aStartOffset,
             HyperTextAccessible* aEndContainer, int32_t aEndOffset);
   TextRange() : mStartOffset{0}, mEndOffset{0} {}
   TextRange(TextRange&& aRange) :
-    mRoot(mozilla::Move(aRange.mRoot)),
-    mStartContainer(mozilla::Move(aRange.mStartContainer)),
-    mEndContainer(mozilla::Move(aRange.mEndContainer)),
+    mRoot(std::move(aRange.mRoot)),
+    mStartContainer(std::move(aRange.mStartContainer)),
+    mEndContainer(std::move(aRange.mEndContainer)),
     mStartOffset(aRange.mStartOffset), mEndOffset(aRange.mEndOffset) {}
 
   TextRange& operator= (TextRange&& aRange)
   {
-    mRoot = mozilla::Move(aRange.mRoot);
-    mStartContainer = mozilla::Move(aRange.mStartContainer);
-    mEndContainer = mozilla::Move(aRange.mEndContainer);
+    mRoot = std::move(aRange.mRoot);
+    mStartContainer = std::move(aRange.mStartContainer);
+    mEndContainer = std::move(aRange.mEndContainer);
     mStartOffset = aRange.mStartOffset;
     mEndOffset = aRange.mEndOffset;
     return *this;
   }
 
   HyperTextAccessible* StartContainer() const { return mStartContainer; }
   int32_t StartOffset() const { return mStartOffset; }
   HyperTextAccessible* EndContainer() const { return mEndContainer; }
--- a/accessible/generic/HyperTextAccessible.cpp
+++ b/accessible/generic/HyperTextAccessible.cpp
@@ -1802,17 +1802,17 @@ HyperTextAccessible::SelectionRanges(nsT
       startContainer->DOMPointToOffset(DOMRange->GetStartContainer(),
                                        DOMRange->StartOffset(), false);
     int32_t endOffset =
       endContainer->DOMPointToOffset(DOMRange->GetEndContainer(),
                                      DOMRange->EndOffset(), true);
 
     TextRange tr(IsTextField() ? const_cast<HyperTextAccessible*>(this) : mDoc,
                     startContainer, startOffset, endContainer, endOffset);
-    *(aRanges->AppendElement()) = Move(tr);
+    *(aRanges->AppendElement()) = std::move(tr);
   }
 }
 
 void
 HyperTextAccessible::VisibleRanges(nsTArray<a11y::TextRange>* aRanges) const
 {
 }
 
--- a/accessible/ipc/DocAccessibleParent.cpp
+++ b/accessible/ipc/DocAccessibleParent.cpp
@@ -92,17 +92,17 @@ DocAccessibleParent::RecvShowEvent(const
   }
 
   uint32_t type = nsIAccessibleEvent::EVENT_SHOW;
   xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(target);
   xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);
   nsINode* node = nullptr;
   RefPtr<xpcAccEvent> event = new xpcAccEvent(type, xpcAcc, doc, node,
                                               aFromUser);
-  nsCoreUtils::DispatchAccEvent(Move(event));
+  nsCoreUtils::DispatchAccEvent(std::move(event));
 
   return IPC_OK();
 }
 
 uint32_t
 DocAccessibleParent::AddSubtree(ProxyAccessible* aParent,
                                 const nsTArray<a11y::AccessibleData>& aNewTree,
                                 uint32_t aIdx, uint32_t aIdxInParent)
@@ -191,17 +191,17 @@ DocAccessibleParent::RecvHideEvent(const
   }
 
   parent->RemoveChild(root);
   root->Shutdown();
 
   MOZ_ASSERT(CheckDocTree());
 
   if (event) {
-    nsCoreUtils::DispatchAccEvent(Move(event));
+    nsCoreUtils::DispatchAccEvent(std::move(event));
   }
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 DocAccessibleParent::RecvEvent(const uint64_t& aID, const uint32_t& aEventType)
 {
@@ -222,17 +222,17 @@ DocAccessibleParent::RecvEvent(const uin
   }
 
   xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(proxy);
   xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);
   nsINode* node = nullptr;
   bool fromUser = true; // XXX fix me
   RefPtr<xpcAccEvent> event = new xpcAccEvent(aEventType, xpcAcc, doc, node,
                                               fromUser);
-  nsCoreUtils::DispatchAccEvent(Move(event));
+  nsCoreUtils::DispatchAccEvent(std::move(event));
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 DocAccessibleParent::RecvStateChangeEvent(const uint64_t& aID,
                                           const uint64_t& aState,
                                           const bool& aEnabled)
@@ -258,17 +258,17 @@ DocAccessibleParent::RecvStateChangeEven
   uint32_t type = nsIAccessibleEvent::EVENT_STATE_CHANGE;
   bool extra;
   uint32_t state = nsAccUtils::To32States(aState, &extra);
   bool fromUser = true; // XXX fix this
   nsINode* node = nullptr; // XXX can we do better?
   RefPtr<xpcAccStateChangeEvent> event =
     new xpcAccStateChangeEvent(type, xpcAcc, doc, node, fromUser, state, extra,
                                aEnabled);
-  nsCoreUtils::DispatchAccEvent(Move(event));
+  nsCoreUtils::DispatchAccEvent(std::move(event));
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 DocAccessibleParent::RecvCaretMoveEvent(const uint64_t& aID,
 #if defined(XP_WIN)
                                         const LayoutDeviceIntRect& aCaretRect,
@@ -297,17 +297,17 @@ DocAccessibleParent::RecvCaretMoveEvent(
 
   xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(proxy);
   xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);
   nsINode* node = nullptr;
   bool fromUser = true; // XXX fix me
   uint32_t type = nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED;
   RefPtr<xpcAccCaretMoveEvent> event =
     new xpcAccCaretMoveEvent(type, xpcAcc, doc, node, fromUser, aOffset);
-  nsCoreUtils::DispatchAccEvent(Move(event));
+  nsCoreUtils::DispatchAccEvent(std::move(event));
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 DocAccessibleParent::RecvTextChangeEvent(const uint64_t& aID,
                                          const nsString& aStr,
                                          const int32_t& aStart,
@@ -334,17 +334,17 @@ DocAccessibleParent::RecvTextChangeEvent
   xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(target);
   xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);
   uint32_t type = aIsInsert ? nsIAccessibleEvent::EVENT_TEXT_INSERTED :
                               nsIAccessibleEvent::EVENT_TEXT_REMOVED;
   nsINode* node = nullptr;
   RefPtr<xpcAccTextChangeEvent> event =
     new xpcAccTextChangeEvent(type, xpcAcc, doc, node, aFromUser, aStart, aLen,
                               aIsInsert, aStr);
-  nsCoreUtils::DispatchAccEvent(Move(event));
+  nsCoreUtils::DispatchAccEvent(std::move(event));
 
   return IPC_OK();
 }
 
 #if defined(XP_WIN)
 
 mozilla::ipc::IPCResult
 DocAccessibleParent::RecvSyncTextChangeEvent(const uint64_t& aID,
@@ -378,17 +378,17 @@ DocAccessibleParent::RecvSelectionEvent(
   ProxySelectionEvent(target, widget, aType);
   if (!nsCoreUtils::AccEventObserversExist()) {
     return IPC_OK();
   }
   xpcAccessibleGeneric* xpcTarget = GetXPCAccessible(target);
   xpcAccessibleDocument* xpcDoc = GetAccService()->GetXPCDocument(this);
   RefPtr<xpcAccEvent> event = new xpcAccEvent(aType, xpcTarget, xpcDoc,
                                               nullptr, false);
-  nsCoreUtils::DispatchAccEvent(Move(event));
+  nsCoreUtils::DispatchAccEvent(std::move(event));
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 DocAccessibleParent::RecvRoleChangedEvent(const a11y::role& aRole)
 {
   if (mShutdown) {
@@ -626,17 +626,17 @@ DocAccessibleParent::MaybeInitWindowEmul
 
     SetEmulatedWindowHandle(aHwnd);
 
     RefPtr<IAccessible> hwndAcc;
     if (SUCCEEDED(::AccessibleObjectFromWindow(aHwnd, OBJID_WINDOW,
                                                IID_IAccessible,
                                                getter_AddRefs(hwndAcc)))) {
       RefPtr<IDispatch> wrapped(mscom::PassthruProxy::Wrap<IDispatch>(WrapNotNull(hwndAcc)));
-      hWndAccHolder.Set(IDispatchHolder::COMPtrType(mscom::ToProxyUniquePtr(Move(wrapped))));
+      hWndAccHolder.Set(IDispatchHolder::COMPtrType(mscom::ToProxyUniquePtr(std::move(wrapped))));
     }
 
     Unused << SendEmulatedWindow(reinterpret_cast<uintptr_t>(mEmulatedWindowHandle),
                                  hWndAccHolder);
   });
 
   HWND parentWnd = reinterpret_cast<HWND>(rootDocument->GetNativeWindow());
   DebugOnly<HWND> hWnd = nsWinUtils::CreateNativeWindow(kClassNameTabContent,
@@ -666,24 +666,24 @@ DocAccessibleParent::SendParentCOMProxy(
   }
 
   RefPtr<IAccessible> nativeAcc;
   outerDoc->GetNativeInterface(getter_AddRefs(nativeAcc));
   MOZ_ASSERT(nativeAcc);
 
   RefPtr<IDispatch> wrapped(mscom::PassthruProxy::Wrap<IDispatch>(WrapNotNull(nativeAcc)));
 
-  IDispatchHolder::COMPtrType ptr(mscom::ToProxyUniquePtr(Move(wrapped)));
-  IDispatchHolder holder(Move(ptr));
+  IDispatchHolder::COMPtrType ptr(mscom::ToProxyUniquePtr(std::move(wrapped)));
+  IDispatchHolder holder(std::move(ptr));
   if (!PDocAccessibleParent::SendParentCOMProxy(holder)) {
     return;
   }
 
 #if defined(MOZ_CONTENT_SANDBOX)
-  mParentProxyStream = Move(holder.GetPreservedStream());
+  mParentProxyStream = std::move(holder.GetPreservedStream());
 #endif // defined(MOZ_CONTENT_SANDBOX)
 }
 
 void
 DocAccessibleParent::SetEmulatedWindowHandle(HWND aWindowHandle)
 {
   if (!aWindowHandle && mEmulatedWindowHandle && IsTopLevel()) {
     ::DestroyWindow(mEmulatedWindowHandle);
@@ -744,17 +744,17 @@ DocAccessibleParent::RecvFocusEvent(cons
   }
 
   xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(proxy);
   xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);
   nsINode* node = nullptr;
   bool fromUser = true; // XXX fix me
   RefPtr<xpcAccEvent> event = new xpcAccEvent(nsIAccessibleEvent::EVENT_FOCUS,
                                               xpcAcc, doc, node, fromUser);
-  nsCoreUtils::DispatchAccEvent(Move(event));
+  nsCoreUtils::DispatchAccEvent(std::move(event));
 
   return IPC_OK();
 }
 
 #endif // defined(XP_WIN)
 
 } // a11y
 } // mozilla
--- a/accessible/ipc/other/ProxyAccessible.cpp
+++ b/accessible/ipc/other/ProxyAccessible.cpp
@@ -73,17 +73,17 @@ ProxyAccessible::RelationByType(Relation
                                      &targetIDs);
 
   size_t targetCount = targetIDs.Length();
   nsTArray<ProxyAccessible*> targets(targetCount);
   for (size_t i = 0; i < targetCount; i++)
     if (ProxyAccessible* proxy = mDoc->GetAccessible(targetIDs[i]))
       targets.AppendElement(proxy);
 
-  return Move(targets);
+  return std::move(targets);
 }
 
 void
 ProxyAccessible::Relations(nsTArray<RelationType>* aTypes,
                            nsTArray<nsTArray<ProxyAccessible*>>* aTargetSets)
   const
 {
   nsTArray<RelationTargets> ipcRelations;
@@ -101,17 +101,17 @@ ProxyAccessible::Relations(nsTArray<Rela
     nsTArray<ProxyAccessible*> targets(targetCount);
     for (size_t j = 0; j < targetCount; j++)
       if (ProxyAccessible* proxy = mDoc->GetAccessible(ipcRelations[i].Targets()[j]))
         targets.AppendElement(proxy);
 
     if (targets.IsEmpty())
       continue;
 
-    aTargetSets->AppendElement(Move(targets));
+    aTargetSets->AppendElement(std::move(targets));
     aTypes->AppendElement(static_cast<RelationType>(type));
   }
 }
 
 bool
 ProxyAccessible::IsSearchbox() const
 {
   bool retVal = false;
--- a/accessible/ipc/win/COMPtrTypes.cpp
+++ b/accessible/ipc/win/COMPtrTypes.cpp
@@ -44,33 +44,33 @@ CreateHolderFromAccessible(NotNull<Acces
 
   RefPtr<HandlerProvider> payload;
   if (useHandler) {
     payload = new HandlerProvider(IID_IAccessible,
                                   mscom::ToInterceptorTargetPtr(iaToProxy));
   }
 
   ProxyUniquePtr<IAccessible> intercepted;
-  HRESULT hr = MainThreadHandoff::WrapInterface(Move(iaToProxy), payload,
+  HRESULT hr = MainThreadHandoff::WrapInterface(std::move(iaToProxy), payload,
                                                 (IAccessible**) mscom::getter_AddRefs(intercepted));
   MOZ_ASSERT(SUCCEEDED(hr));
   if (FAILED(hr)) {
     return nullptr;
   }
 
-  return IAccessibleHolder(Move(intercepted));
+  return IAccessibleHolder(std::move(intercepted));
 }
 
 IHandlerControlHolder
 CreateHolderFromHandlerControl(mscom::ProxyUniquePtr<IHandlerControl> aHandlerControl)
 {
   MOZ_ASSERT(aHandlerControl);
   MOZ_ASSERT(XRE_IsContentProcess());
   MOZ_ASSERT(NS_IsMainThread());
   if (!aHandlerControl) {
     return nullptr;
   }
 
-  return IHandlerControlHolder(Move(aHandlerControl));
+  return IHandlerControlHolder(std::move(aHandlerControl));
 }
 
 } // namespace a11y
 } // namespace mozilla
--- a/accessible/ipc/win/DocAccessibleChild.cpp
+++ b/accessible/ipc/win/DocAccessibleChild.cpp
@@ -103,17 +103,17 @@ DocAccessibleChild::PushDeferredEvent(Un
       return;
     }
 
     topLevelIPCDoc =
       static_cast<DocAccessibleChild*>(tabChild->GetTopLevelDocAccessibleChild());
   }
 
   if (topLevelIPCDoc) {
-    topLevelIPCDoc->mDeferredEvents.AppendElement(Move(aEvent));
+    topLevelIPCDoc->mDeferredEvents.AppendElement(std::move(aEvent));
   }
 }
 
 bool
 DocAccessibleChild::SendEvent(const uint64_t& aID, const uint32_t& aType)
 {
   if (IsConstructedInParentProcess()) {
     return PDocAccessibleChild::SendEvent(aID, aType);
--- a/accessible/ipc/win/DocAccessibleChild.h
+++ b/accessible/ipc/win/DocAccessibleChild.h
@@ -114,17 +114,17 @@ private:
       , mEventData(aEventData.ID(), aEventData.Idx(),
                    nsTArray<AccessibleData>(), aEventData.EventSuppressed())
       , mFromUser(aFromUser)
     {
       // Since IPDL doesn't generate a move constructor for ShowEventData,
       // we move NewTree manually (ugh). We still construct with an empty
       // NewTree above so that the compiler catches any changes made to the
       // ShowEventData structure in IPDL.
-      mEventData.NewTree() = Move(aEventData.NewTree());
+      mEventData.NewTree() = std::move(aEventData.NewTree());
     }
 
     void Dispatch(DocAccessibleChild* aIPCDoc) override
     {
       Unused << aIPCDoc->SendShowEvent(mEventData, mFromUser);
     }
 
     ShowEventData mEventData;
--- a/accessible/ipc/win/HandlerProvider.cpp
+++ b/accessible/ipc/win/HandlerProvider.cpp
@@ -38,17 +38,17 @@
 namespace mozilla {
 namespace a11y {
 
 HandlerProvider::HandlerProvider(REFIID aIid,
                                mscom::InterceptorTargetPtr<IUnknown> aTarget)
   : mRefCnt(0)
   , mMutex("mozilla::a11y::HandlerProvider::mMutex")
   , mTargetUnkIid(aIid)
-  , mTargetUnk(Move(aTarget))
+  , mTargetUnk(std::move(aTarget))
 {
 }
 
 HRESULT
 HandlerProvider::QueryInterface(REFIID riid, void** ppv)
 {
   if (!ppv) {
     return E_INVALIDARG;
@@ -497,31 +497,31 @@ HandlerProvider::GetEffectiveOutParamIid
   return IID_IUnknown;
 }
 
 HRESULT
 HandlerProvider::NewInstance(REFIID aIid,
                              mscom::InterceptorTargetPtr<IUnknown> aTarget,
                              NotNull<mscom::IHandlerProvider**> aOutNewPayload)
 {
-  RefPtr<IHandlerProvider> newPayload(new HandlerProvider(aIid, Move(aTarget)));
+  RefPtr<IHandlerProvider> newPayload(new HandlerProvider(aIid, std::move(aTarget)));
   newPayload.forget(aOutNewPayload.get());
   return S_OK;
 }
 
 void
 HandlerProvider::SetHandlerControlOnMainThread(DWORD aPid,
                                               mscom::ProxyUniquePtr<IHandlerControl> aCtrl)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   auto content = dom::ContentChild::GetSingleton();
   MOZ_ASSERT(content);
 
-  IHandlerControlHolder holder(CreateHolderFromHandlerControl(Move(aCtrl)));
+  IHandlerControlHolder holder(CreateHolderFromHandlerControl(std::move(aCtrl)));
   Unused << content->SendA11yHandlerControl(aPid, holder);
 }
 
 HRESULT
 HandlerProvider::put_HandlerControl(long aPid, IHandlerControl* aCtrl)
 {
   MOZ_ASSERT(mscom::IsCurrentThreadMTA());
 
@@ -529,17 +529,17 @@ HandlerProvider::put_HandlerControl(long
     return E_INVALIDARG;
   }
 
   auto ptrProxy = mscom::ToProxyUniquePtr(aCtrl);
 
   if (!mscom::InvokeOnMainThread("HandlerProvider::SetHandlerControlOnMainThread",
                                  this,
                                  &HandlerProvider::SetHandlerControlOnMainThread,
-                                 static_cast<DWORD>(aPid), Move(ptrProxy))) {
+                                 static_cast<DWORD>(aPid), std::move(ptrProxy))) {
     return E_FAIL;
   }
 
   return S_OK;
 }
 
 HRESULT
 HandlerProvider::Refresh(DynamicIA2Data* aOutData)
@@ -571,17 +571,17 @@ HandlerProvider::Refresh(DynamicIA2Data*
 
 template<typename Interface>
 HRESULT
 HandlerProvider::ToWrappedObject(Interface** aObj)
 {
   mscom::STAUniquePtr<Interface> inObj(*aObj);
   RefPtr<HandlerProvider> hprov = new HandlerProvider(__uuidof(Interface),
     mscom::ToInterceptorTargetPtr(inObj));
-  HRESULT hr = mscom::MainThreadHandoff::WrapInterface(Move(inObj), hprov,
+  HRESULT hr = mscom::MainThreadHandoff::WrapInterface(std::move(inObj), hprov,
                                                        aObj);
   if (FAILED(hr)) {
     *aObj = nullptr;
   }
   return hr;
 }
 
 void
--- a/accessible/ipc/win/PlatformChild.cpp
+++ b/accessible/ipc/win/PlatformChild.cpp
@@ -57,31 +57,31 @@ PlatformChild::PlatformChild()
   , mSdnTypelib(mozilla::mscom::RegisterTypelib(L"AccessibleMarshal.dll"))
 {
   WORD actCtxResourceId = Compatibility::GetActCtxResourceId();
 
   mozilla::mscom::MTADeletePtr<mozilla::mscom::ActivationContextRegion> tmpActCtxMTA;
   mozilla::mscom::EnsureMTA([actCtxResourceId, &tmpActCtxMTA]() -> void {
     tmpActCtxMTA.reset(new mozilla::mscom::ActivationContextRegion(actCtxResourceId));
   });
-  mActCtxMTA = Move(tmpActCtxMTA);
+  mActCtxMTA = std::move(tmpActCtxMTA);
 
   mozilla::mscom::InterceptorLog::Init();
   mozilla::mscom::RegisterArrayData(sPlatformChildArrayData);
 
 
   UniquePtr<mozilla::mscom::RegisteredProxy> customProxy;
   mozilla::mscom::EnsureMTA([&customProxy]() -> void {
-    customProxy = Move(mozilla::mscom::RegisterProxy());
+    customProxy = std::move(mozilla::mscom::RegisterProxy());
   });
-  mCustomProxy = Move(customProxy);
+  mCustomProxy = std::move(customProxy);
 
   // IA2 needs to be registered in both the main thread's STA as well as the MTA
   UniquePtr<mozilla::mscom::RegisteredProxy> ia2ProxyMTA;
   mozilla::mscom::EnsureMTA([&ia2ProxyMTA]() -> void {
-    ia2ProxyMTA = Move(mozilla::mscom::RegisterProxy(L"ia2marshal.dll"));
+    ia2ProxyMTA = std::move(mozilla::mscom::RegisterProxy(L"ia2marshal.dll"));
   });
-  mIA2ProxyMTA = Move(ia2ProxyMTA);
+  mIA2ProxyMTA = std::move(ia2ProxyMTA);
 }
 
 } // namespace a11y
 } // namespace mozilla
 
--- a/accessible/ipc/win/ProxyAccessible.cpp
+++ b/accessible/ipc/win/ProxyAccessible.cpp
@@ -411,17 +411,17 @@ ProxyAccessible::RelationByType(Relation
   nsTArray<ProxyAccessible*> proxies;
   for (long idx = 0; idx < nTargets; idx++) {
     IUnknown* target = targets[idx];
     proxies.AppendElement(GetProxyFor(Document(), target));
     target->Release();
   }
   CoTaskMemFree(targets);
 
-  return Move(proxies);
+  return std::move(proxies);
 }
 
 double
 ProxyAccessible::CurValue()
 {
   RefPtr<IAccessibleValue> acc = QueryInterface<IAccessibleValue>(this);
   if (!acc) {
     return UnspecifiedNaN<double>();
--- a/accessible/ipc/win/handler/AccessibleHandlerControl.cpp
+++ b/accessible/ipc/win/handler/AccessibleHandlerControl.cpp
@@ -37,17 +37,17 @@ TextChange::TextChange(long aIA2UniqueId
   , mIsInsert(aIsInsert)
   , mText{BSTRCopy(aText->text), aText->start, aText->end}
 {
 }
 
 TextChange::TextChange(TextChange&& aOther)
   : mText()
 {
-  *this = Move(aOther);
+  *this = std::move(aOther);
 }
 
 TextChange::TextChange(const TextChange& aOther)
   : mText()
 {
   *this = aOther;
 }
 
--- a/accessible/windows/ia2/ia2AccessibleRelation.h
+++ b/accessible/windows/ia2/ia2AccessibleRelation.h
@@ -21,17 +21,17 @@ namespace a11y {
 
 class ia2AccessibleRelation final : public IAccessibleRelation
 {
 public:
   ia2AccessibleRelation(RelationType aType, Relation* aRel);
 
   ia2AccessibleRelation(RelationType aType,
                         nsTArray<RefPtr<Accessible>>&& aTargets) :
-    mType(aType), mTargets(Move(aTargets)) {}
+    mType(aType), mTargets(std::move(aTargets)) {}
 
   // IUnknown
   DECL_IUNKNOWN
 
   // IAccessibleRelation
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_relationType(
       /* [retval][out] */ BSTR *relationType);
 
--- a/accessible/windows/msaa/AccessibleWrap.cpp
+++ b/accessible/windows/msaa/AccessibleWrap.cpp
@@ -1723,22 +1723,22 @@ AccessibleWrap::SetHandlerControl(DWORD 
 {
   MOZ_ASSERT(XRE_IsParentProcess() && NS_IsMainThread());
 
   if (!sHandlerControllers) {
     sHandlerControllers = new nsTArray<HandlerControllerData>();
     ClearOnShutdown(&sHandlerControllers);
   }
 
-  HandlerControllerData ctrlData(aPid, Move(aCtrl));
+  HandlerControllerData ctrlData(aPid, std::move(aCtrl));
   if (sHandlerControllers->Contains(ctrlData)) {
     return;
   }
 
-  sHandlerControllers->AppendElement(Move(ctrlData));
+  sHandlerControllers->AppendElement(std::move(ctrlData));
 }
 
 /* static */
 void
 AccessibleWrap::InvalidateHandlers()
 {
   static const HRESULT kErrorServerDied =
     HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE);
--- a/accessible/windows/msaa/AccessibleWrap.h
+++ b/accessible/windows/msaa/AccessibleWrap.h
@@ -268,25 +268,25 @@ protected:
     NAVRELATION_ERROR = 0x1017,
     NAVRELATION_ERROR_FOR = 0x1018
   };
 
   struct HandlerControllerData final
   {
     HandlerControllerData(DWORD aPid, RefPtr<IHandlerControl>&& aCtrl)
       : mPid(aPid)
-      , mCtrl(Move(aCtrl))
+      , mCtrl(std::move(aCtrl))
     {
       mIsProxy = mozilla::mscom::IsProxy(mCtrl);
     }
 
     HandlerControllerData(HandlerControllerData&& aOther)
       : mPid(aOther.mPid)
       , mIsProxy(aOther.mIsProxy)
-      , mCtrl(Move(aOther.mCtrl))
+      , mCtrl(std::move(aOther.mCtrl))
     {
     }
 
     bool operator==(const HandlerControllerData& aOther) const
     {
       return mPid == aOther.mPid;
     }
 
--- a/accessible/xpcom/xpcAccessibleHyperText.cpp
+++ b/accessible/xpcom/xpcAccessibleHyperText.cpp
@@ -533,17 +533,17 @@ xpcAccessibleHyperText::GetSelectionRang
   nsCOMPtr<nsIMutableArray> xpcRanges =
     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   AutoTArray<TextRange, 1> ranges;
   Intl()->SelectionRanges(&ranges);
   uint32_t len = ranges.Length();
   for (uint32_t idx = 0; idx < len; idx++)
-    xpcRanges->AppendElement(new xpcAccessibleTextRange(Move(ranges[idx])));
+    xpcRanges->AppendElement(new xpcAccessibleTextRange(std::move(ranges[idx])));
 
   xpcRanges.forget(aRanges);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetVisibleRanges(nsIArray** aRanges)
 {
@@ -557,17 +557,17 @@ xpcAccessibleHyperText::GetVisibleRanges
   nsCOMPtr<nsIMutableArray> xpcRanges =
     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsTArray<TextRange> ranges;
   Intl()->VisibleRanges(&ranges);
   uint32_t len = ranges.Length();
   for (uint32_t idx = 0; idx < len; idx++)
-    xpcRanges->AppendElement(new xpcAccessibleTextRange(Move(ranges[idx])));
+    xpcRanges->AppendElement(new xpcAccessibleTextRange(std::move(ranges[idx])));
 
   xpcRanges.forget(aRanges);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetRangeByChild(nsIAccessible* aChild,
                                         nsIAccessibleTextRange** aRange)
--- a/browser/app/ProcThreadAttributes.h
+++ b/browser/app/ProcThreadAttributes.h
@@ -153,17 +153,17 @@ public:
                                        PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
                                        mInheritableHandles.begin(),
                                        mInheritableHandles.length() * sizeof(HANDLE),
                                        nullptr, nullptr)) {
         return Nothing();
       }
     }
 
-    mAttrList = Move(attrList);
+    mAttrList = std::move(attrList);
     aSiex.lpAttributeList = mAttrList.get();
     aSiex.StartupInfo.cb = sizeof(STARTUPINFOEXW);
     return Some(true);
   }
 
 private:
   static const uint32_t kNumInline = 3; // Inline storage for the std handles
 
--- a/build/moz.configure/warnings.configure
+++ b/build/moz.configure/warnings.configure
@@ -81,16 +81,22 @@ check_and_add_gcc_warning('-Wstring-conv
 
 # we inline 'new' and 'delete' in mozalloc
 check_and_add_gcc_warning('-Wno-inline-new-delete', cxx_compiler)
 
 # Prevent the following GCC warnings from being treated as errors:
 # too many false positives
 check_and_add_gcc_warning('-Wno-error=maybe-uninitialized')
 
+# Turned on by -Wall, but needs changes to be turned into an error
+# (bug 1465060).
+check_and_add_gcc_warning('-Wno-error=pessimizing-move')
+# This one is probably easier, it's only triggered by tests.
+check_and_add_gcc_warning('-Wno-error=self-move')
+
 # we don't want our builds held hostage when a platform-specific API
 # becomes deprecated.
 check_and_add_gcc_warning('-Wno-error=deprecated-declarations')
 
 # false positives depending on optimization
 check_and_add_gcc_warning('-Wno-error=array-bounds')
 
 # can't get rid of those PGO warnings
--- a/caps/ExpandedPrincipal.cpp
+++ b/caps/ExpandedPrincipal.cpp
@@ -276,17 +276,17 @@ ExpandedPrincipal::Read(nsIObjectInputSt
 
     nsCOMPtr<nsIPrincipal> principal = do_QueryInterface(read);
     if (!principal) {
       return NS_ERROR_UNEXPECTED;
     }
 
     // Play it safe and InsertElementSorted, in case the sort order
     // changed for some bizarre reason.
-    mPrincipals.InsertElementSorted(Move(principal), c);
+    mPrincipals.InsertElementSorted(std::move(principal), c);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 ExpandedPrincipal::Write(nsIObjectOutputStream* aStream)
 {
--- a/chrome/nsChromeRegistryChrome.h
+++ b/chrome/nsChromeRegistryChrome.h
@@ -118,18 +118,18 @@ class nsChromeRegistryChrome : public ns
 
   class OverlayListEntry : public nsURIHashKey
   {
    public:
     typedef nsURIHashKey::KeyType        KeyType;
     typedef nsURIHashKey::KeyTypePointer KeyTypePointer;
 
     explicit OverlayListEntry(KeyTypePointer aKey) : nsURIHashKey(aKey) { }
-    OverlayListEntry(OverlayListEntry&& toMove) : nsURIHashKey(mozilla::Move(toMove)),
-                                                  mArray(mozilla::Move(toMove.mArray)) { }
+    OverlayListEntry(OverlayListEntry&& toMove) : nsURIHashKey(std::move(toMove)),
+                                                  mArray(std::move(toMove.mArray)) { }
     ~OverlayListEntry() { }
 
     void AddURI(nsIURI* aURI);
 
     nsCOMArray<nsIURI> mArray;
   };
 
   class OverlayListHash
--- a/devtools/shared/heapsnapshot/DeserializedNode.cpp
+++ b/devtools/shared/heapsnapshot/DeserializedNode.cpp
@@ -15,17 +15,17 @@ DeserializedEdge::DeserializedEdge(Deser
   referent = rhs.referent;
   name = rhs.name;
 }
 
 DeserializedEdge& DeserializedEdge::operator=(DeserializedEdge&& rhs)
 {
   MOZ_ASSERT(&rhs != this);
   this->~DeserializedEdge();
-  new(this) DeserializedEdge(Move(rhs));
+  new(this) DeserializedEdge(std::move(rhs));
   return *this;
 }
 
 JS::ubi::Node
 DeserializedNode::getEdgeReferent(const DeserializedEdge& edge)
 {
   auto ptr = owner->nodes.lookup(edge.referent);
   MOZ_ASSERT(ptr);
@@ -82,17 +82,17 @@ class DeserializedEdgeRange : public Edg
   void settle() {
     if (i >= node->edges.length()) {
       front_ = nullptr;
       return;
     }
 
     auto& edge = node->edges[i];
     auto referent = node->getEdgeReferent(edge);
-    currentEdge = mozilla::Move(Edge(edge.name ? NS_strdup(edge.name) : nullptr,
+    currentEdge = std::move(Edge(edge.name ? NS_strdup(edge.name) : nullptr,
                                      referent));
     front_ = &currentEdge;
   }
 
 public:
   explicit DeserializedEdgeRange(DeserializedNode& node)
     : node(&node)
     , i(0)
--- a/devtools/shared/heapsnapshot/DeserializedNode.h
+++ b/devtools/shared/heapsnapshot/DeserializedNode.h
@@ -82,41 +82,41 @@ struct DeserializedNode {
                    const Maybe<StackFrameId>& allocationStack,
                    const char* className,
                    const char* filename,
                    HeapSnapshot& owner)
     : id(id)
     , coarseType(coarseType)
     , typeName(typeName)
     , size(size)
-    , edges(Move(edges))
+    , edges(std::move(edges))
     , allocationStack(allocationStack)
     , jsObjectClassName(className)
     , scriptFilename(filename)
     , owner(&owner)
   { }
   virtual ~DeserializedNode() { }
 
   DeserializedNode(DeserializedNode&& rhs)
     : id(rhs.id)
     , coarseType(rhs.coarseType)
     , typeName(rhs.typeName)
     , size(rhs.size)
-    , edges(Move(rhs.edges))
+    , edges(std::move(rhs.edges))
     , allocationStack(rhs.allocationStack)
     , jsObjectClassName(rhs.jsObjectClassName)
     , scriptFilename(rhs.scriptFilename)
     , owner(rhs.owner)
   { }
 
   DeserializedNode& operator=(DeserializedNode&& rhs)
   {
     MOZ_ASSERT(&rhs != this);
     this->~DeserializedNode();
-    new(this) DeserializedNode(Move(rhs));
+    new(this) DeserializedNode(std::move(rhs));
     return *this;
   }
 
   // Get a borrowed reference to the given edge's referent. This method is
   // virtual to provide a hook for gmock and gtest.
   virtual JS::ubi::Node getEdgeReferent(const DeserializedEdge& edge);
 
   struct HashPolicy;
--- a/devtools/shared/heapsnapshot/DominatorTree.h
+++ b/devtools/shared/heapsnapshot/DominatorTree.h
@@ -27,17 +27,17 @@ protected:
 private:
   JS::ubi::DominatorTree mDominatorTree;
   RefPtr<HeapSnapshot> mHeapSnapshot;
 
 public:
   explicit DominatorTree(JS::ubi::DominatorTree&& aDominatorTree, HeapSnapshot* aHeapSnapshot,
                          nsISupports* aParent)
     : mParent(aParent)
-    , mDominatorTree(Move(aDominatorTree))
+    , mDominatorTree(std::move(aDominatorTree))
     , mHeapSnapshot(aHeapSnapshot)
   {
     MOZ_ASSERT(aParent);
     MOZ_ASSERT(aHeapSnapshot);
   };
 
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS;
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(DominatorTree);
--- a/devtools/shared/heapsnapshot/HeapSnapshot.cpp
+++ b/devtools/shared/heapsnapshot/HeapSnapshot.cpp
@@ -143,17 +143,17 @@ struct GetOrInternStringMatcher
   explicit GetOrInternStringMatcher(InternedStringSet& strings) : internedStrings(strings) { }
 
   const CharT* match(const std::string* str) {
     MOZ_ASSERT(str);
     size_t length = str->length() / sizeof(CharT);
     auto tempString = reinterpret_cast<const CharT*>(str->data());
 
     UniqueFreePtr<CharT[]> owned(NS_strndup(tempString, length));
-    if (!owned || !internedStrings.append(Move(owned)))
+    if (!owned || !internedStrings.append(std::move(owned)))
       return nullptr;
 
     return internedStrings.back().get();
   }
 
   const CharT* match(uint64_t ref) {
     if (MOZ_LIKELY(ref < internedStrings.length())) {
       auto& string = internedStrings[ref];
@@ -280,17 +280,17 @@ HeapSnapshot::saveNode(const protobuf::N
   if (node.ScriptFilenameOrRef_case() != protobuf::Node::SCRIPTFILENAMEORREF_NOT_SET) {
     Maybe<StringOrRef> scriptFilenameOrRef = GET_STRING_OR_REF(node, scriptfilename);
     scriptFilename = getOrInternString<char>(internedOneByteStrings, scriptFilenameOrRef);
     if (NS_WARN_IF(!scriptFilename))
       return false;
   }
 
   if (NS_WARN_IF(!nodes.putNew(id, DeserializedNode(id, coarseType, typeName,
-                                                    size, Move(edges),
+                                                    size, std::move(edges),
                                                     allocationStack,
                                                     jsObjectClassName,
                                                     scriptFilename, *this))))
   {
     return false;
   };
 
   return true;
@@ -563,17 +563,17 @@ HeapSnapshot::ComputeDominatorTree(Error
     maybeTree = JS::ubi::DominatorTree::Create(cx, nogc, getRoot());
   }
 
   if (NS_WARN_IF(maybeTree.isNothing())) {
     rv.Throw(NS_ERROR_OUT_OF_MEMORY);
     return nullptr;
   }
 
-  return MakeAndAddRef<DominatorTree>(Move(*maybeTree), this, mParent);
+  return MakeAndAddRef<DominatorTree>(std::move(*maybeTree), this, mParent);
 }
 
 void
 HeapSnapshot::ComputeShortestPaths(JSContext*cx, uint64_t start,
                                    const Sequence<uint64_t>& targets,
                                    uint64_t maxNumPaths,
                                    JS::MutableHandleObject results,
                                    ErrorResult& rv)
@@ -619,17 +619,17 @@ HeapSnapshot::ComputeShortestPaths(JSCon
   }
 
   // Walk the heap graph and find the shortest paths.
 
   Maybe<ShortestPaths> maybeShortestPaths;
   {
     JS::AutoCheckCannotGC nogc(cx);
     maybeShortestPaths = ShortestPaths::Create(cx, nogc, maxNumPaths, *startNode,
-                                               Move(targetsSet));
+                                               std::move(targetsSet));
   }
 
   if (NS_WARN_IF(maybeShortestPaths.isNothing())) {
     rv.Throw(NS_ERROR_OUT_OF_MEMORY);
     return;
   }
 
   auto& shortestPaths = *maybeShortestPaths;
@@ -1027,17 +1027,17 @@ struct TwoByteString::HashPolicy {
   };
 
   static bool match(const TwoByteString& k, const Lookup& l) {
     EqualityMatcher eq(l);
     return k.match(eq);
   }
 
   static void rekey(TwoByteString& k, TwoByteString&& newKey) {
-    k = Move(newKey);
+    k = std::move(newKey);
   }
 };
 
 // Returns whether `edge` should be included in a heap snapshot of
 // `compartments`. The optional `policy` out-param is set to INCLUDE_EDGES
 // if we want to include the referent's edges, or EXCLUDE_EDGES if we don't
 // want to include them.
 static bool
@@ -1132,17 +1132,17 @@ class MOZ_STACK_CLASS StreamWriter : pub
     auto stringData = MakeUnique<std::string>(length * sizeof(char16_t), '\0');
     if (!stringData)
       return false;
 
     auto buf = const_cast<char16_t*>(reinterpret_cast<const char16_t*>(stringData->data()));
     string.copyToBuffer(RangedPtr<char16_t>(buf, length), length);
 
     uint64_t ref = twoByteStringsAlreadySerialized.count();
-    if (!twoByteStringsAlreadySerialized.add(ptr, Move(string), ref))
+    if (!twoByteStringsAlreadySerialized.add(ptr, std::move(string), ref))
       return false;
 
     setString(stringData.release());
     return true;
   }
 
   // Attach the full one-byte string or a reference to a one-byte string that
   // has already been serialized to a protobuf message.
@@ -1298,17 +1298,17 @@ public:
         protobuf::Edge* protobufEdge = protobufNode.add_edges();
         if (NS_WARN_IF(!protobufEdge)) {
           return false;
         }
 
         protobufEdge->set_referent(ubiEdge.referent.identifier());
 
         if (wantNames && ubiEdge.name) {
-          TwoByteString edgeName(Move(ubiEdge.name));
+          TwoByteString edgeName(std::move(ubiEdge.name));
           if (NS_WARN_IF(!attachTwoByteString(edgeName,
                                               [&] (std::string* name) { protobufEdge->set_allocated_name(name); },
                                               [&] (uint64_t ref) { protobufEdge->set_nameref(ref); })))
           {
             return false;
           }
         }
       }
--- a/devtools/shared/heapsnapshot/tests/gtest/DeserializedNodeUbiNodes.cpp
+++ b/devtools/shared/heapsnapshot/tests/gtest/DeserializedNodeUbiNodes.cpp
@@ -18,17 +18,17 @@ using testing::ReturnRef;
 struct MockDeserializedNode : public DeserializedNode
 {
   MockDeserializedNode(NodeId id, const char16_t* typeName, uint64_t size)
     : DeserializedNode(id, typeName, size)
   { }
 
   bool addEdge(DeserializedEdge&& edge)
   {
-    return edges.append(Move(edge));
+    return edges.append(std::move(edge));
   }
 
   MOCK_METHOD1(getEdgeReferent, JS::ubi::Node(const DeserializedEdge&));
 };
 
 size_t fakeMallocSizeOf(const void*) {
   EXPECT_TRUE(false);
   MOZ_ASSERT_UNREACHABLE("fakeMallocSizeOf should never be called because "
@@ -62,35 +62,35 @@ DEF_TEST(DeserializedNodeUbiNodes, {
     EXPECT_EQ(ubi.scriptFilename(), filename);
 
     // Test the ubi::Node's edges.
 
     UniquePtr<DeserializedNode> referent1(new MockDeserializedNode(1,
                                                                    nullptr,
                                                                    10));
     DeserializedEdge edge1(referent1->id);
-    mocked.addEdge(Move(edge1));
+    mocked.addEdge(std::move(edge1));
     EXPECT_CALL(mocked, getEdgeReferent(EdgeTo(referent1->id)))
       .Times(1)
       .WillOnce(Return(JS::ubi::Node(referent1.get())));
 
     UniquePtr<DeserializedNode> referent2(new MockDeserializedNode(2,
                                                                    nullptr,
                                                                    20));
     DeserializedEdge edge2(referent2->id);
-    mocked.addEdge(Move(edge2));
+    mocked.addEdge(std::move(edge2));
     EXPECT_CALL(mocked, getEdgeReferent(EdgeTo(referent2->id)))
       .Times(1)
       .WillOnce(Return(JS::ubi::Node(referent2.get())));
 
     UniquePtr<DeserializedNode> referent3(new MockDeserializedNode(3,
                                                                    nullptr,
                                                                    30));
     DeserializedEdge edge3(referent3->id);
-    mocked.addEdge(Move(edge3));
+    mocked.addEdge(std::move(edge3));
     EXPECT_CALL(mocked, getEdgeReferent(EdgeTo(referent3->id)))
       .Times(1)
       .WillOnce(Return(JS::ubi::Node(referent3.get())));
 
     auto range = ubi.edges(cx);
     ASSERT_TRUE(!!range);
 
     for ( ; !range->empty(); range->popFront()) {
--- a/devtools/shared/heapsnapshot/tests/gtest/DevTools.h
+++ b/devtools/shared/heapsnapshot/tests/gtest/DevTools.h
@@ -187,17 +187,17 @@ const char16_t Concrete<FakeNode>::concr
 void AddEdge(FakeNode& node, FakeNode& referent, const char16_t* edgeName = nullptr) {
   char16_t* ownedEdgeName = nullptr;
   if (edgeName) {
     ownedEdgeName = NS_strdup(edgeName);
     ASSERT_NE(ownedEdgeName, nullptr);
   }
 
   JS::ubi::Edge edge(ownedEdgeName, &referent);
-  ASSERT_TRUE(node.edges.append(mozilla::Move(edge)));
+  ASSERT_TRUE(node.edges.append(std::move(edge)));
 }
 
 
 // Custom GMock Matchers
 
 // Use the testing namespace to avoid static analysis failures in the gmock
 // matcher classes that get generated from MATCHER_P macros.
 namespace testing {
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -2860,17 +2860,17 @@ nsDocShell::MaybeCreateInitialClientSour
 }
 
 Maybe<ClientInfo>
 nsDocShell::GetInitialClientInfo() const
 {
   if (mInitialClientSource) {
     Maybe<ClientInfo> result;
     result.emplace(mInitialClientSource->Info());
-    return Move(result);
+    return std::move(result);
   }
 
   nsGlobalWindowInner* innerWindow =
     mScriptGlobal ? mScriptGlobal->GetCurrentInnerWindowInternal() : nullptr;
   nsIDocument* doc = innerWindow ? innerWindow->GetExtantDoc() : nullptr;
 
   if (!doc || !doc->IsInitialDocument()) {
     return Maybe<ClientInfo>();
@@ -5006,17 +5006,17 @@ nsDocShell::Reload(uint32_t aReloadFlags
     // Stack variables to ensure changes to the member variables don't affect to
     // the call.
     nsCOMPtr<nsIURI> currentURI = mCurrentURI;
     nsCOMPtr<nsIURI> referrerURI = mReferrerURI;
     uint32_t referrerPolicy = mReferrerPolicy;
 
     // Reload always rewrites result principal URI.
     Maybe<nsCOMPtr<nsIURI>> emplacedResultPrincipalURI;
-    emplacedResultPrincipalURI.emplace(Move(resultPrincipalURI));
+    emplacedResultPrincipalURI.emplace(std::move(resultPrincipalURI));
     rv = InternalLoad(currentURI,
                       originalURI,
                       emplacedResultPrincipalURI,
                       loadReplace,
                       referrerURI,
                       referrerPolicy,
                       triggeringPrincipal,
                       triggeringPrincipal,
@@ -11091,17 +11091,17 @@ nsDocShell::DoChannelLoad(nsIChannel* aC
 
   // Since we are loading a document we need to make sure the proper reserved
   // and initial client data is stored on the nsILoadInfo.  The
   // ClientChannelHelper does this and ensures that it is propagated properly
   // on redirects.  We pass no reserved client here so that the helper will
   // create the reserved ClientSource if necessary.
   Maybe<ClientInfo> noReservedClient;
   rv = AddClientChannelHelper(aChannel,
-                              Move(noReservedClient),
+                              std::move(noReservedClient),
                               GetInitialClientInfo(),
                               win->EventTargetFor(TaskCategory::Other));
   NS_ENSURE_SUCCESS(rv, rv);
 
   rv = aURILoader->OpenURI(aChannel, openFlags, this);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // We're about to load a new page and it may take time before necko
@@ -12264,17 +12264,17 @@ nsDocShell::LoadHistoryEntry(nsISHEntry*
     return NS_ERROR_FAILURE;
   }
 
   // Passing nullptr as aSourceDocShell gives the same behaviour as before
   // aSourceDocShell was introduced. According to spec we should be passing
   // the source browsing context that was used when the history entry was
   // first created. bug 947716 has been created to address this issue.
   Maybe<nsCOMPtr<nsIURI>> emplacedResultPrincipalURI;
-  emplacedResultPrincipalURI.emplace(Move(resultPrincipalURI));
+  emplacedResultPrincipalURI.emplace(std::move(resultPrincipalURI));
   rv = InternalLoad(uri,
                     originalURI,
                     emplacedResultPrincipalURI,
                     loadReplace,
                     referrerURI,
                     referrerPolicy,
                     triggeringPrincipal,
                     principalToInherit,
@@ -14062,17 +14062,17 @@ nsDocShell::NotifyJSRunToCompletionStart
                                          const uint32_t aLineNumber,
                                          JS::Handle<JS::Value> aAsyncStack,
                                          const char* aAsyncCause)
 {
   // If first start, mark interval start.
   if (mJSRunToCompletionDepth == 0) {
     RefPtr<TimelineConsumers> timelines = TimelineConsumers::Get();
     if (timelines && timelines->HasConsumer(this)) {
-      timelines->AddMarkerForDocShell(this, Move(
+      timelines->AddMarkerForDocShell(this, std::move(
         mozilla::MakeUnique<JavascriptTimelineMarker>(
           aReason, aFunctionName, aFilename, aLineNumber, MarkerTracingType::START,
           aAsyncStack, aAsyncCause)));
     }
   }
 
   mJSRunToCompletionDepth++;
 }
@@ -14150,17 +14150,17 @@ nsDocShell::InFrameSwap()
     shell = shell->GetParentDocshell();
   } while (shell);
   return false;
 }
 
 UniquePtr<ClientSource>
 nsDocShell::TakeInitialClientSource()
 {
-  return Move(mInitialClientSource);
+  return std::move(mInitialClientSource);
 }
 
 NS_IMETHODIMP
 nsDocShell::IssueWarning(uint32_t aWarning, bool aAsError)
 {
   if (mContentViewer) {
     nsCOMPtr<nsIDocument> doc = mContentViewer->GetDocument();
     if (doc) {
--- a/docshell/base/nsDocShell.h
+++ b/docshell/base/nsDocShell.h
@@ -315,17 +315,17 @@ public:
    * docshell is added to the docshell tree, which can affect what the ancestor
    * principals should look like.
    *
    * This method steals the data from the passed-in array.
    */
   void SetAncestorPrincipals(
     nsTArray<nsCOMPtr<nsIPrincipal>>&& aAncestorPrincipals)
   {
-    mAncestorPrincipals = mozilla::Move(aAncestorPrincipals);
+    mAncestorPrincipals = std::move(aAncestorPrincipals);
   }
 
   /**
    * Get the list of ancestor outerWindowIDs for this docshell.  The list is meant
    * to be the list of outer window IDs that correspond to the ancestorPrincipals
    * above.   For each ancestor principal, we store the parent window ID.
    */
   const nsTArray<uint64_t>& AncestorOuterWindowIDs() const
@@ -337,17 +337,17 @@ public:
    * Set the list of ancestor outer window IDs for this docshell.  We call this
    * from frameloader as well in order to keep the array matched with the
    * ancestor principals.
    *
    * This method steals the data from the passed-in array.
    */
   void SetAncestorOuterWindowIDs(nsTArray<uint64_t>&& aAncestorOuterWindowIDs)
   {
-    mAncestorOuterWindowIDs = mozilla::Move(aAncestorOuterWindowIDs);
+    mAncestorOuterWindowIDs = std::move(aAncestorOuterWindowIDs);
   }
 
   const mozilla::OriginAttributes& GetOriginAttributes()
   {
     return mOriginAttributes;
   }
 
   // Determine whether this docshell corresponds to the given history entry,
--- a/docshell/base/nsDocShellLoadInfo.cpp
+++ b/docshell/base/nsDocShellLoadInfo.cpp
@@ -36,17 +36,17 @@ GetMaybeResultPrincipalURI(nsIDocShellLo
   }
 
   nsCOMPtr<nsIURI> uri;
   rv = aLoadInfo->GetResultPrincipalURI(getter_AddRefs(uri));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return;
   }
 
-  aRPURI.emplace(Move(uri));
+  aRPURI.emplace(std::move(uri));
 }
 
 void
 SetMaybeResultPrincipalURI(nsIDocShellLoadInfo* aLoadInfo, Maybe<nsCOMPtr<nsIURI>> const& aRPURI)
 {
   if (!aLoadInfo) {
     return;
   }
--- a/docshell/base/timeline/AutoRestyleTimelineMarker.cpp
+++ b/docshell/base/timeline/AutoRestyleTimelineMarker.cpp
@@ -27,17 +27,17 @@ AutoRestyleTimelineMarker::AutoRestyleTi
   }
 
   RefPtr<TimelineConsumers> timelines = TimelineConsumers::Get();
   if (!timelines || !timelines->HasConsumer(aDocShell)) {
     return;
   }
 
   mDocShell = aDocShell;
-  timelines->AddMarkerForDocShell(mDocShell, Move(
+  timelines->AddMarkerForDocShell(mDocShell, std::move(
     MakeUnique<RestyleTimelineMarker>(
       mIsAnimationOnly,
       MarkerTracingType::START)));
 }
 
 AutoRestyleTimelineMarker::~AutoRestyleTimelineMarker()
 {
   MOZ_ASSERT(NS_IsMainThread());
@@ -46,15 +46,15 @@ AutoRestyleTimelineMarker::~AutoRestyleT
     return;
   }
 
   RefPtr<TimelineConsumers> timelines = TimelineConsumers::Get();
   if (!timelines || !timelines->HasConsumer(mDocShell)) {
     return;
   }
 
-  timelines->AddMarkerForDocShell(mDocShell, Move(
+  timelines->AddMarkerForDocShell(mDocShell, std::move(
     MakeUnique<RestyleTimelineMarker>(
       mIsAnimationOnly,
       MarkerTracingType::END)));
 }
 
 } // namespace mozilla
--- a/docshell/base/timeline/ObservedDocShell.cpp
+++ b/docshell/base/timeline/ObservedDocShell.cpp
@@ -27,30 +27,30 @@ ObservedDocShell::AddMarker(UniquePtr<Ab
 {
   // Only allow main thread markers to go into this list. No need to lock
   // here since `mTimelineMarkers` will only be accessed or modified on the
   // main thread only.
   MOZ_ASSERT(NS_IsMainThread());
   // Don't accept any markers generated by the process of popping
   // markers.
   if (!mPopping) {
-    mTimelineMarkers.AppendElement(Move(aMarker));
+    mTimelineMarkers.AppendElement(std::move(aMarker));
   }
 }
 
 void
 ObservedDocShell::AddOTMTMarker(UniquePtr<AbstractTimelineMarker>&& aMarker)
 {
   // Only allow off the main thread markers to go into this list. Since most
   // of our markers come from the main thread, be a little more efficient and
   // avoid dealing with multithreading scenarios until all the markers are
   // actually cleared or popped in `ClearMarkers` or `PopMarkers`.
   MOZ_ASSERT(!NS_IsMainThread());
   MutexAutoLock lock(GetLock()); // for `mOffTheMainThreadTimelineMarkers`.
-  mOffTheMainThreadTimelineMarkers.AppendElement(Move(aMarker));
+  mOffTheMainThreadTimelineMarkers.AppendElement(std::move(aMarker));
 }
 
 void
 ObservedDocShell::ClearMarkers()
 {
   MOZ_ASSERT(NS_IsMainThread());
   MutexAutoLock lock(GetLock()); // for `mOffTheMainThreadTimelineMarkers`.
   mTimelineMarkers.Clear();
@@ -66,17 +66,17 @@ ObservedDocShell::PopMarkers(JSContext* 
 
   MOZ_RELEASE_ASSERT(!mPopping);
   AutoRestore<bool> resetPopping(mPopping);
   mPopping = true;
 
   // First, move all of our markers into a single array. We'll chose
   // the `mTimelineMarkers` store because that's where we expect most of
   // our markers to be.
-  mTimelineMarkers.AppendElements(Move(mOffTheMainThreadTimelineMarkers));
+  mTimelineMarkers.AppendElements(std::move(mOffTheMainThreadTimelineMarkers));
 
   // If we see an unpaired START, we keep it around for the next call
   // to ObservedDocShell::PopMarkers. We store the kept START objects here.
   nsTArray<UniquePtr<AbstractTimelineMarker>> keptStartMarkers;
 
   for (uint32_t i = 0; i < mTimelineMarkers.Length(); ++i) {
     UniquePtr<AbstractTimelineMarker>& startPayload = mTimelineMarkers.ElementAt(i);
 
@@ -153,17 +153,17 @@ ObservedDocShell::PopMarkers(JSContext* 
           }
           hasSeenEnd = true;
           break;
         }
       }
 
       // If we did not see the corresponding END, keep the START.
       if (!hasSeenEnd) {
-        keptStartMarkers.AppendElement(Move(mTimelineMarkers.ElementAt(i)));
+        keptStartMarkers.AppendElement(std::move(mTimelineMarkers.ElementAt(i)));
         mTimelineMarkers.RemoveElementAt(i);
         --i;
       }
     }
   }
 
   mTimelineMarkers.SwapElements(keptStartMarkers);
 }
--- a/docshell/base/timeline/TimelineConsumers.cpp
+++ b/docshell/base/timeline/TimelineConsumers.cpp
@@ -180,40 +180,40 @@ TimelineConsumers::IsEmpty()
 void
 TimelineConsumers::AddMarkerForDocShell(nsDocShell* aDocShell,
                                         const char* aName,
                                         MarkerTracingType aTracingType,
                                         MarkerStackRequest aStackRequest)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (HasConsumer(aDocShell)) {
-    aDocShell->mObserved->AddMarker(Move(MakeUnique<TimelineMarker>(aName, aTracingType, aStackRequest)));
+    aDocShell->mObserved->AddMarker(std::move(MakeUnique<TimelineMarker>(aName, aTracingType, aStackRequest)));
   }
 }
 
 void
 TimelineConsumers::AddMarkerForDocShell(nsDocShell* aDocShell,
                                         const char* aName,
                                         const TimeStamp& aTime,
                                         MarkerTracingType aTracingType,
                                         MarkerStackRequest aStackRequest)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (HasConsumer(aDocShell)) {
-    aDocShell->mObserved->AddMarker(Move(MakeUnique<TimelineMarker>(aName, aTime, aTracingType, aStackRequest)));
+    aDocShell->mObserved->AddMarker(std::move(MakeUnique<TimelineMarker>(aName, aTime, aTracingType, aStackRequest)));
   }
 }
 
 void
 TimelineConsumers::AddMarkerForDocShell(nsDocShell* aDocShell,
                                         UniquePtr<AbstractTimelineMarker>&& aMarker)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (HasConsumer(aDocShell)) {
-    aDocShell->mObserved->AddMarker(Move(aMarker));
+    aDocShell->mObserved->AddMarker(std::move(aMarker));
   }
 }
 
 void
 TimelineConsumers::AddMarkerForDocShell(nsIDocShell* aDocShell,
                                         const char* aName,
                                         MarkerTracingType aTracingType,
                                         MarkerStackRequest aStackRequest)
@@ -233,36 +233,36 @@ TimelineConsumers::AddMarkerForDocShell(
   AddMarkerForDocShell(static_cast<nsDocShell*>(aDocShell), aName, aTime, aTracingType, aStackRequest);
 }
 
 void
 TimelineConsumers::AddMarkerForDocShell(nsIDocShell* aDocShell,
                                         UniquePtr<AbstractTimelineMarker>&& aMarker)
 {
   MOZ_ASSERT(NS_IsMainThread());
-  AddMarkerForDocShell(static_cast<nsDocShell*>(aDocShell), Move(aMarker));
+  AddMarkerForDocShell(static_cast<nsDocShell*>(aDocShell), std::move(aMarker));
 }
 
 void
 TimelineConsumers::AddMarkerForAllObservedDocShells(const char* aName,
                                                     MarkerTracingType aTracingType,
                                                     MarkerStackRequest aStackRequest /* = STACK */)
 {
   bool isMainThread = NS_IsMainThread();
   StaticMutexAutoLock lock(sMutex); // for `mMarkersStores`.
 
   for (MarkersStorage* storage = mMarkersStores.getFirst();
        storage != nullptr;
        storage = storage->getNext()) {
     UniquePtr<AbstractTimelineMarker> marker =
       MakeUnique<TimelineMarker>(aName, aTracingType, aStackRequest);
     if (isMainThread) {
-      storage->AddMarker(Move(marker));
+      storage->AddMarker(std::move(marker));
     } else {
-      storage->AddOTMTMarker(Move(marker));
+      storage->AddOTMTMarker(std::move(marker));
     }
   }
 }
 
 void
 TimelineConsumers::AddMarkerForAllObservedDocShells(const char* aName,
                                                     const TimeStamp& aTime,
                                                     MarkerTracingType aTracingType,
@@ -272,37 +272,37 @@ TimelineConsumers::AddMarkerForAllObserv
   StaticMutexAutoLock lock(sMutex); // for `mMarkersStores`.
 
   for (MarkersStorage* storage = mMarkersStores.getFirst();
        storage != nullptr;
        storage = storage->getNext()) {
     UniquePtr<AbstractTimelineMarker> marker =
       MakeUnique<TimelineMarker>(aName, aTime, aTracingType, aStackRequest);
     if (isMainThread) {
-      storage->AddMarker(Move(marker));
+      storage->AddMarker(std::move(marker));
     } else {
-      storage->AddOTMTMarker(Move(marker));
+      storage->AddOTMTMarker(std::move(marker));
     }
   }
 }
 
 void
 TimelineConsumers::AddMarkerForAllObservedDocShells(UniquePtr<AbstractTimelineMarker>& aMarker)
 {
   bool isMainThread = NS_IsMainThread();
   StaticMutexAutoLock lock(sMutex); // for `mMarkersStores`.
 
   for (MarkersStorage* storage = mMarkersStores.getFirst();
        storage != nullptr;
        storage = storage->getNext()) {
     UniquePtr<AbstractTimelineMarker> clone = aMarker->Clone();
     if (isMainThread) {
-      storage->AddMarker(Move(clone));
+      storage->AddMarker(std::move(clone));
     } else {
-      storage->AddOTMTMarker(Move(clone));
+      storage->AddOTMTMarker(std::move(clone));
     }
   }
 }
 
 void
 TimelineConsumers::PopMarkers(nsDocShell* aDocShell,
                               JSContext* aCx,
                               nsTArray<dom::ProfileTimelineMarker>& aStore)
--- a/dom/animation/AnimationEventDispatcher.cpp
+++ b/dom/animation/AnimationEventDispatcher.cpp
@@ -41,17 +41,17 @@ AnimationEventDispatcher::Disconnect()
 }
 
 void
 AnimationEventDispatcher::QueueEvents(nsTArray<AnimationEventInfo>&& aEvents)
 {
   MOZ_ASSERT(mPresContext,
              "The pres context should be valid");
 
-  mPendingEvents.AppendElements(Move(aEvents));
+  mPendingEvents.AppendElements(std::move(aEvents));
   mIsSorted = false;
   if (!mIsObserving) {
     mPresContext->RefreshDriver()->ScheduleAnimationEventDispatch(this);
     mIsObserving = true;
   }
 }
 
 } // namespace mozilla
--- a/dom/animation/EffectSet.h
+++ b/dom/animation/EffectSet.h
@@ -85,27 +85,27 @@ public:
   // This allows us to avoid exposing mEffects directly and saves the
   // caller from having to dereference hashtable iterators using
   // the rather complicated: iter.Get()->GetKey().
   class Iterator
   {
   public:
     explicit Iterator(EffectSet& aEffectSet)
       : mEffectSet(aEffectSet)
-      , mHashIterator(mozilla::Move(aEffectSet.mEffects.Iter()))
+      , mHashIterator(std::move(aEffectSet.mEffects.Iter()))
       , mIsEndIterator(false)
     {
 #ifdef DEBUG
       mEffectSet.mActiveIterators++;
 #endif
     }
 
     Iterator(Iterator&& aOther)
       : mEffectSet(aOther.mEffectSet)
-      , mHashIterator(mozilla::Move(aOther.mHashIterator))
+      , mHashIterator(std::move(aOther.mHashIterator))
       , mIsEndIterator(aOther.mIsEndIterator)
     {
 #ifdef DEBUG
       mEffectSet.mActiveIterators++;
 #endif
     }
 
     static Iterator EndIterator(EffectSet& aEffectSet)
--- a/dom/animation/Keyframe.h
+++ b/dom/animation/Keyframe.h
@@ -24,17 +24,17 @@ enum class CompositeOperation : uint8_t;
  * A property-value pair specified on a keyframe.
  */
 struct PropertyValuePair
 {
   explicit PropertyValuePair(nsCSSPropertyID aProperty)
     : mProperty(aProperty) { }
   PropertyValuePair(nsCSSPropertyID aProperty,
                     RefPtr<RawServoDeclarationBlock>&& aValue)
-    : mProperty(aProperty), mServoDeclarationBlock(Move(aValue))
+    : mProperty(aProperty), mServoDeclarationBlock(std::move(aValue))
   {
     MOZ_ASSERT(mServoDeclarationBlock, "Should be valid property value");
   }
 
   nsCSSPropertyID mProperty;
 
   // The specified value when using the Servo backend.
   RefPtr<RawServoDeclarationBlock> mServoDeclarationBlock;
@@ -65,27 +65,27 @@ struct PropertyValuePair
  * these objects represent the master definition of the effect's values.
  */
 struct Keyframe
 {
   Keyframe() = default;
   Keyframe(const Keyframe& aOther) = default;
   Keyframe(Keyframe&& aOther)
   {
-    *this = Move(aOther);
+    *this = std::move(aOther);
   }
 
   Keyframe& operator=(const Keyframe& aOther) = default;
   Keyframe& operator=(Keyframe&& aOther)
   {
     mOffset         = aOther.mOffset;
     mComputedOffset = aOther.mComputedOffset;
-    mTimingFunction = Move(aOther.mTimingFunction);
-    mComposite      = Move(aOther.mComposite);
-    mPropertyValues = Move(aOther.mPropertyValues);
+    mTimingFunction = std::move(aOther.mTimingFunction);
+    mComposite      = std::move(aOther.mComposite);
+    mPropertyValues = std::move(aOther.mPropertyValues);
     return *this;
   }
 
   Maybe<double>                 mOffset;
   static constexpr double kComputedOffsetNotSet = -1.0;
   double                        mComputedOffset = kComputedOffsetNotSet;
   Maybe<ComputedTimingFunction> mTimingFunction; // Nothing() here means
                                                  // "linear"
--- a/dom/animation/KeyframeEffect.cpp
+++ b/dom/animation/KeyframeEffect.cpp
@@ -237,30 +237,30 @@ KeyframeEffect::SetKeyframes(JSContext* 
 {
   nsTArray<Keyframe> keyframes =
     KeyframeUtils::GetKeyframesFromObject(aContext, mDocument, aKeyframes, aRv);
   if (aRv.Failed()) {
     return;
   }
 
   RefPtr<ComputedStyle> style = GetTargetComputedStyle();
-  SetKeyframes(Move(keyframes), style);
+  SetKeyframes(std::move(keyframes), style);
 }
 
 
 void
 KeyframeEffect::SetKeyframes(
   nsTArray<Keyframe>&& aKeyframes,
   const ComputedStyle* aStyle)
 {
   if (KeyframesEqualIgnoringComputedOffsets(aKeyframes, mKeyframes)) {
     return;
   }
 
-  mKeyframes = Move(aKeyframes);
+  mKeyframes = std::move(aKeyframes);
   KeyframeUtils::DistributeKeyframes(mKeyframes);
 
   if (mAnimation && mAnimation->IsRelevant()) {
     nsNodeUtils::AnimationChanged(mAnimation);
   }
 
   // We need to call UpdateProperties() unless the target element doesn't have
   // style (e.g. the target element is not associated with any document).
@@ -347,17 +347,17 @@ KeyframeEffect::UpdateProperties(const C
   nsCSSPropertyIDSet runningOnCompositorProperties;
 
   for (const AnimationProperty& property : mProperties) {
     if (property.mIsRunningOnCompositor) {
       runningOnCompositorProperties.AddProperty(property.mProperty);
     }
   }
 
-  mProperties = Move(properties);
+  mProperties = std::move(properties);
   UpdateEffectSet();
 
   for (AnimationProperty& property : mProperties) {
     property.mIsRunningOnCompositor =
       runningOnCompositorProperties.HasProperty(property.mProperty);
   }
 
   CalculateCumulativeChangeHint(aStyle);
--- a/dom/animation/KeyframeUtils.cpp
+++ b/dom/animation/KeyframeUtils.cpp
@@ -481,17 +481,17 @@ ConvertKeyframeSequence(JSContext* aCx,
     for (PropertyValuesPair& pair : propertyValuePairs) {
       MOZ_ASSERT(pair.mValues.Length() == 1);
 
       Maybe<PropertyValuePair> valuePair =
         MakePropertyValuePair(pair.mProperty, pair.mValues[0], aDocument);
       if (!valuePair) {
         continue;
       }
-      keyframe->mPropertyValues.AppendElement(Move(valuePair.ref()));
+      keyframe->mPropertyValues.AppendElement(std::move(valuePair.ref()));
 
 #ifdef DEBUG
       // When we go to convert keyframes into arrays of property values we
       // call StyleAnimation::ComputeValues. This should normally return true
       // but in order to test the case where it does not, BaseKeyframeDict
       // includes a chrome-only member that can be set to indicate that
       // ComputeValues should fail for shorthand property values on that
       // keyframe.
@@ -671,17 +671,17 @@ MakePropertyValuePair(nsCSSPropertyID aP
   Maybe<PropertyValuePair> result;
 
   ServoCSSParser::ParsingEnvironment env =
     ServoCSSParser::GetParsingEnvironment(aDocument);
   RefPtr<RawServoDeclarationBlock> servoDeclarationBlock =
     ServoCSSParser::ParseProperty(aProperty, aStringValue, env);
 
   if (servoDeclarationBlock) {
-    result.emplace(aProperty, Move(servoDeclarationBlock));
+    result.emplace(aProperty, std::move(servoDeclarationBlock));
   } else {
     ReportInvalidPropertyValueToConsole(aProperty, aStringValue, aDocument);
   }
   return result;
 }
 
 /**
  * Checks that the given keyframes are loosely ordered (each keyframe's
@@ -1074,23 +1074,23 @@ GetKeyframeListFromPropertyIndexedKeyfra
         keyframe->mComputedOffset = offset;
       }
 
       Maybe<PropertyValuePair> valuePair =
         MakePropertyValuePair(pair.mProperty, stringValue, aDocument);
       if (!valuePair) {
         continue;
       }
-      keyframe->mPropertyValues.AppendElement(Move(valuePair.ref()));
+      keyframe->mPropertyValues.AppendElement(std::move(valuePair.ref()));
     }
   }
 
   aResult.SetCapacity(processedKeyframes.Count());
   for (auto iter = processedKeyframes.Iter(); !iter.Done(); iter.Next()) {
-    aResult.AppendElement(Move(*iter.UserData()));
+    aResult.AppendElement(std::move(*iter.UserData()));
   }
 
   aResult.Sort(ComputedOffsetComparator());
 
   // Fill in any specified offsets
   //
   // This corresponds to step 5, "Otherwise," branch, substeps 5-6 of
   // https://drafts.csswg.org/web-animations/#processing-a-keyframes-argument
@@ -1143,17 +1143,17 @@ GetKeyframeListFromPropertyIndexedKeyfra
   // Fill in any easings.
   //
   // This corresponds to step 5, "Otherwise," branch, substeps 7-11 of
   // https://drafts.csswg.org/web-animations/#processing-a-keyframes-argument
   FallibleTArray<Maybe<ComputedTimingFunction>> easings;
   auto parseAndAppendEasing = [&](const nsString& easingString,
                                   ErrorResult& aRv) {
     auto easing = TimingParams::ParseEasing(easingString, aDocument, aRv);
-    if (!aRv.Failed() && !easings.AppendElement(Move(easing), fallible)) {
+    if (!aRv.Failed() && !easings.AppendElement(std::move(easing), fallible)) {
       aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
     }
   };
 
   auto& easing = keyframeDict.mEasing;
   if (easing.IsString()) {
     parseAndAppendEasing(easing.GetAsString(), aRv);
     if (aRv.Failed()) {
--- a/dom/animation/TimingParams.h
+++ b/dom/animation/TimingParams.h
@@ -170,17 +170,17 @@ struct TimingParams
   bool operator==(const TimingParams& aOther) const;
   bool operator!=(const TimingParams& aOther) const
   {
     return !(*this == aOther);
   }
 
   void SetDuration(Maybe<StickyTimeDuration>&& aDuration)
   {
-    mDuration = Move(aDuration);
+    mDuration = std::move(aDuration);
     Update();
   }
   const Maybe<StickyTimeDuration>& Duration() const { return mDuration; }
 
   void SetDelay(const TimeDuration& aDelay)
   {
     mDelay = aDelay;
     Update();
@@ -216,17 +216,17 @@ struct TimingParams
   void SetFill(dom::FillMode aFill)
   {
     mFill = aFill;
   }
   dom::FillMode Fill() const { return mFill; }
 
   void SetTimingFunction(Maybe<ComputedTimingFunction>&& aFunction)
   {
-    mFunction = Move(aFunction);
+    mFunction = std::move(aFunction);
   }
   const Maybe<ComputedTimingFunction>& TimingFunction() const
   {
     return mFunction;
   }
 
 private:
   void Update()
--- a/dom/asmjscache/AsmJSCache.cpp
+++ b/dom/asmjscache/AsmJSCache.cpp
@@ -1534,17 +1534,17 @@ ChildRunnable::Run()
 
       nsAutoPtr<PrincipalInfo> principalInfo(new PrincipalInfo());
       nsresult rv = PrincipalToPrincipalInfo(mPrincipal, principalInfo);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         Fail(JS::AsmJSCache_InternalError);
         return NS_OK;
       }
 
-      mPrincipalInfo = Move(principalInfo);
+      mPrincipalInfo = std::move(principalInfo);
 
       PBackgroundChild* actor = BackgroundChild::GetOrCreateForCurrentThread();
       if (NS_WARN_IF(!actor)) {
         Fail(JS::AsmJSCache_InternalError);
         return NS_OK;
       }
 
       if (!actor->SendPAsmJSCacheEntryConstructor(this, mOpenMode, mWriteParams,
--- a/dom/base/ChildIterator.h
+++ b/dom/base/ChildIterator.h
@@ -135,17 +135,17 @@ public:
                                   bool aStartAtBeginning = true)
     : ExplicitChildIterator(aParent, aStartAtBeginning)
     , mOriginalContent(aParent)
   {
     Init(false);
   }
 
   FlattenedChildIterator(FlattenedChildIterator&& aOther)
-    : ExplicitChildIterator(Move(aOther))
+    : ExplicitChildIterator(std::move(aOther))
     , mOriginalContent(aOther.mOriginalContent)
     , mXBLInvolved(aOther.mXBLInvolved)
   {}
 
   FlattenedChildIterator(const FlattenedChildIterator& aOther)
     : ExplicitChildIterator(aOther)
     , mOriginalContent(aOther.mOriginalContent)
     , mXBLInvolved(aOther.mXBLInvolved)
@@ -203,18 +203,18 @@ class AllChildrenIterator : private Flat
 public:
   AllChildrenIterator(const nsIContent* aNode, uint32_t aFlags,
                       bool aStartAtBeginning = true) :
     FlattenedChildIterator(aNode, aFlags, aStartAtBeginning),
     mAnonKidsIdx(aStartAtBeginning ? UINT32_MAX : 0),
     mFlags(aFlags), mPhase(aStartAtBeginning ? eAtBegin : eAtEnd) { }
 
   AllChildrenIterator(AllChildrenIterator&& aOther)
-    : FlattenedChildIterator(Move(aOther)),
-      mAnonKids(Move(aOther.mAnonKids)), mAnonKidsIdx(aOther.mAnonKidsIdx),
+    : FlattenedChildIterator(std::move(aOther)),
+      mAnonKids(std::move(aOther.mAnonKids)), mAnonKidsIdx(aOther.mAnonKidsIdx),
       mFlags(aOther.mFlags), mPhase(aOther.mPhase)
 #ifdef DEBUG
       , mMutationGuard(aOther.mMutationGuard)
 #endif
       {}
 
 #ifdef DEBUG
   ~AllChildrenIterator() { MOZ_ASSERT(!mMutationGuard.Mutated(0)); }
--- a/dom/base/ChromeUtils.cpp
+++ b/dom/base/ChromeUtils.cpp
@@ -688,17 +688,17 @@ ChromeUtils::GetCallerLocation(const Glo
 {
   JSContext* cx = aGlobal.Context();
 
   auto* principals = nsJSPrincipals::get(aPrincipal);
 
   JS::StackCapture captureMode(JS::FirstSubsumedFrame(cx, principals));
 
   JS::RootedObject frame(cx);
-  if (!JS::CaptureCurrentStack(cx, &frame, mozilla::Move(captureMode))) {
+  if (!JS::CaptureCurrentStack(cx, &frame, std::move(captureMode))) {
     JS_ClearPendingException(cx);
     aRetval.set(nullptr);
     return;
   }
 
   // FirstSubsumedFrame gets us a stack which stops at the first principal which
   // is subsumed by the given principal. That means that we may have a lot of
   // privileged frames that we don't care about at the top of the stack, though.
--- a/dom/base/CustomElementRegistry.cpp
+++ b/dom/base/CustomElementRegistry.cpp
@@ -48,17 +48,17 @@ private:
 
 //-----------------------------------------------------
 // CustomElementCallbackReaction
 
 class CustomElementCallbackReaction final : public CustomElementReaction
 {
   public:
     explicit CustomElementCallbackReaction(UniquePtr<CustomElementCallback> aCustomElementCallback)
-      : mCustomElementCallback(Move(aCustomElementCallback))
+      : mCustomElementCallback(std::move(aCustomElementCallback))
     {
     }
 
     virtual void Traverse(nsCycleCollectionTraversalCallback& aCb) const override
     {
       mCustomElementCallback->Traverse(aCb);
     }
 
@@ -488,17 +488,17 @@ CustomElementRegistry::CreateCustomEleme
 
   if (aArgs) {
     callback->SetArgs(*aArgs);
   }
 
   if (aAdoptedCallbackArgs) {
     callback->SetAdoptedCallbackArgs(*aAdoptedCallbackArgs);
   }
-  return Move(callback);
+  return std::move(callback);
 }
 
 /* static */ void
 CustomElementRegistry::EnqueueLifecycleCallback(nsIDocument::ElementCallbackType aType,
                                                 Element* aCustomElement,
                                                 LifecycleCallbackArgs* aArgs,
                                                 LifecycleAdoptedCallbackArgs* aAdoptedCallbackArgs,
                                                 CustomElementDefinition* aDefinition)
@@ -534,17 +534,17 @@ CustomElementRegistry::EnqueueLifecycleC
     if (definition->mObservedAttributes.IsEmpty() ||
         !definition->mObservedAttributes.Contains(attrName)) {
       return;
     }
   }
 
   CustomElementReactionsStack* reactionsStack =
     docGroup->CustomElementReactionsStack();
-  reactionsStack->EnqueueCallbackReaction(aCustomElement, Move(callback));
+  reactionsStack->EnqueueCallbackReaction(aCustomElement, std::move(callback));
 }
 
 namespace {
 
 class CandidateFinder
 {
 public:
   CandidateFinder(nsTHashtable<nsRefPtrHashKey<nsIWeakReference>>& aCandidates,
@@ -576,17 +576,17 @@ CandidateFinder::CandidateFinder(nsTHash
 }
 
 nsTArray<nsCOMPtr<Element>>
 CandidateFinder::OrderedCandidates()
 {
   if (mCandidates.Count() == 1) {
     // Fast path for one candidate.
     for (auto iter = mCandidates.Iter(); !iter.Done(); iter.Next()) {
-      nsTArray<nsCOMPtr<Element>> rval({ Move(iter.Data()) });
+      nsTArray<nsCOMPtr<Element>> rval({ std::move(iter.Data()) });
       iter.Remove();
       return rval;
     }
   }
 
   nsTArray<nsCOMPtr<Element>> orderedElements(mCandidates.Count());
   for (Element* child = mDoc->GetFirstElementChild(); child; child = child->GetNextElementSibling()) {
     if (!Traverse(child, orderedElements)) {
@@ -597,17 +597,17 @@ CandidateFinder::OrderedCandidates()
   return orderedElements;
 }
 
 bool
 CandidateFinder::Traverse(Element* aRoot, nsTArray<nsCOMPtr<Element>>& aOrderedElements)
 {
   nsCOMPtr<Element> elem;
   if (mCandidates.Remove(aRoot, getter_AddRefs(elem))) {
-    aOrderedElements.AppendElement(Move(elem));
+    aOrderedElements.AppendElement(std::move(elem));
     if (mCandidates.Count() == 0) {
       return false;
     }
   }
 
   if (ShadowRoot* root = aRoot->GetShadowRoot()) {
     // First iterate the children of the shadow root if aRoot is a shadow host.
     for (Element* child = root->GetFirstElementChild(); child;
@@ -924,18 +924,18 @@ CustomElementRegistry::Define(JSContext*
     aRv.Throw(NS_ERROR_FAILURE);
     return;
   }
 
   RefPtr<CustomElementDefinition> definition =
     new CustomElementDefinition(nameAtom,
                                 localNameAtom,
                                 &aFunctionConstructor,
-                                Move(observedAttributes),
-                                Move(callbacksHolder));
+                                std::move(observedAttributes),
+                                std::move(callbacksHolder));
 
   CustomElementDefinition* def = definition.get();
   mCustomDefinitions.Put(nameAtom, definition.forget());
 
   MOZ_ASSERT(mCustomDefinitions.Count() == mConstructors.count(),
              "Number of entries should be the same");
 
   /**
@@ -1177,17 +1177,17 @@ CustomElementReactionsStack::EnqueueUpgr
 {
   Enqueue(aElement, new CustomElementUpgradeReaction(aDefinition));
 }
 
 void
 CustomElementReactionsStack::EnqueueCallbackReaction(Element* aElement,
                                                      UniquePtr<CustomElementCallback> aCustomElementCallback)
 {
-  Enqueue(aElement, new CustomElementCallbackReaction(Move(aCustomElementCallback)));
+  Enqueue(aElement, new CustomElementCallbackReaction(std::move(aCustomElementCallback)));
 }
 
 void
 CustomElementReactionsStack::Enqueue(Element* aElement,
                                      CustomElementReaction* aReaction)
 {
   RefPtr<CustomElementData> elementData = aElement->GetCustomElementData();
   MOZ_ASSERT(elementData, "CustomElementData should exist");
@@ -1263,17 +1263,17 @@ CustomElementReactionsStack::InvokeReact
       // unlinked, no need to fire the callbacks in this case.
       continue;
     }
 
     auto& reactions = elementData->mReactionQueue;
     for (uint32_t j = 0; j < reactions.Length(); ++j) {
       // Transfer the ownership of the entry due to reentrant invocation of
       // this function.
-      auto reaction(Move(reactions.ElementAt(j)));
+      auto reaction(std::move(reactions.ElementAt(j)));
       if (reaction) {
         if (!aGlobal && reaction->IsUpgradeReaction()) {
           // This is for the special case when custom element is included
           // inside XBL.
           MOZ_ASSERT(nsContentUtils::IsChromeDoc(element->OwnerDoc()));
           nsIGlobalObject* global = element->GetOwnerGlobal();
           MOZ_ASSERT(!aes);
           aes.emplace(global, "custom elements reaction invocation");
@@ -1346,15 +1346,15 @@ NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(C
 CustomElementDefinition::CustomElementDefinition(nsAtom* aType,
                                                  nsAtom* aLocalName,
                                                  Function* aConstructor,
                                                  nsTArray<RefPtr<nsAtom>>&& aObservedAttributes,
                                                  UniquePtr<LifecycleCallbacks>&& aCallbacks)
   : mType(aType),
     mLocalName(aLocalName),
     mConstructor(new CustomElementConstructor(aConstructor)),
-    mObservedAttributes(Move(aObservedAttributes)),
-    mCallbacks(Move(aCallbacks))
+    mObservedAttributes(std::move(aObservedAttributes)),
+    mCallbacks(std::move(aCallbacks))
 {
 }
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/base/DispatcherTrait.cpp
+++ b/dom/base/DispatcherTrait.cpp
@@ -12,17 +12,17 @@
 
 using namespace mozilla;
 using namespace mozilla::dom;
 
 nsresult
 DispatcherTrait::Dispatch(TaskCategory aCategory,
                           already_AddRefed<nsIRunnable>&& aRunnable)
 {
-  return SchedulerGroup::UnlabeledDispatch(aCategory, Move(aRunnable));
+  return SchedulerGroup::UnlabeledDispatch(aCategory, std::move(aRunnable));
 }
 
 nsISerialEventTarget*
 DispatcherTrait::EventTargetFor(TaskCategory aCategory) const
 {
   return GetMainThreadSerialEventTarget();
 }
 
--- a/dom/base/DocGroup.cpp
+++ b/dom/base/DocGroup.cpp
@@ -131,17 +131,17 @@ DocGroup::ReportPerformanceInfo()
 
 nsresult
 DocGroup::Dispatch(TaskCategory aCategory,
                    already_AddRefed<nsIRunnable>&& aRunnable)
 {
   if (mPerformanceCounter) {
     mPerformanceCounter->IncrementDispatchCounter(DispatchCategory(aCategory));
   }
-  return mTabGroup->DispatchWithDocGroup(aCategory, Move(aRunnable), this);
+  return mTabGroup->DispatchWithDocGroup(aCategory, std::move(aRunnable), this);
 }
 
 nsISerialEventTarget*
 DocGroup::EventTargetFor(TaskCategory aCategory) const
 {
   return mTabGroup->EventTargetFor(aCategory);
 }
 
@@ -174,17 +174,17 @@ DocGroup::SignalSlotChange(HTMLSlotEleme
 }
 
 void
 DocGroup::MoveSignalSlotListTo(nsTArray<RefPtr<HTMLSlotElement>>& aDest)
 {
   aDest.SetCapacity(aDest.Length() + mSignalSlotList.Length());
   for (RefPtr<HTMLSlotElement>& slot : mSignalSlotList) {
     slot->RemovedFromSignalSlotList();
-    aDest.AppendElement(Move(slot));
+    aDest.AppendElement(std::move(slot));
   }
   mSignalSlotList.Clear();
 }
 
 bool
 DocGroup::IsActive() const
 {
   for (nsIDocument* doc : mDocuments) {
--- a/dom/base/DocumentOrShadowRoot.cpp
+++ b/dom/base/DocumentOrShadowRoot.cpp
@@ -52,17 +52,17 @@ DocumentOrShadowRoot::InsertSheetAt(size
 
 already_AddRefed<StyleSheet>
 DocumentOrShadowRoot::RemoveSheet(StyleSheet& aSheet)
 {
   auto index = mStyleSheets.IndexOf(&aSheet);
   if (index == mStyleSheets.NoIndex) {
     return nullptr;
   }
-  RefPtr<StyleSheet> sheet = Move(mStyleSheets[index]);
+  RefPtr<StyleSheet> sheet = std::move(mStyleSheets[index]);
   mStyleSheets.RemoveElementAt(index);
   sheet->ClearAssociatedDocumentOrShadowRoot();
   return sheet.forget();
 }
 
 Element*
 DocumentOrShadowRoot::GetElementById(const nsAString& aElementId)
 {
--- a/dom/base/Element.cpp
+++ b/dom/base/Element.cpp
@@ -3512,17 +3512,17 @@ Element::RequestFullscreen(CallerType aC
   if (const char* error = GetFullScreenError(aCallerType)) {
     OwnerDoc()->DispatchFullscreenError(error);
     return;
   }
 
   auto request = MakeUnique<FullscreenRequest>(this);
   request->mIsCallerChrome = (aCallerType == CallerType::System);
 
-  OwnerDoc()->AsyncRequestFullScreen(Move(request));
+  OwnerDoc()->AsyncRequestFullScreen(std::move(request));
 }
 
 void
 Element::RequestPointerLock(CallerType aCallerType)
 {
   OwnerDoc()->RequestPointerLock(this, aCallerType);
 }
 
--- a/dom/base/EventSource.cpp
+++ b/dom/base/EventSource.cpp
@@ -1428,17 +1428,17 @@ EventSourceImpl::Freeze()
   return NS_OK;
 }
 
 nsresult
 EventSourceImpl::DispatchCurrentMessageEvent()
 {
   AssertIsOnTargetThread();
   MOZ_ASSERT(!IsShutDown());
-  UniquePtr<Message> message(Move(mCurrentMessage));
+  UniquePtr<Message> message(std::move(mCurrentMessage));
   ClearFields();
 
   if (!message || message->mData.IsEmpty()) {
     return NS_OK;
   }
 
   // removes the trailing LF from mData
   MOZ_ASSERT(message->mData.CharAt(message->mData.Length() - 1) == LF_CHAR,
@@ -1798,17 +1798,17 @@ class WorkerRunnableDispatcher final : p
   RefPtr<EventSourceImpl> mEventSourceImpl;
 
 public:
   WorkerRunnableDispatcher(EventSourceImpl* aImpl,
                            WorkerPrivate* aWorkerPrivate,
                            already_AddRefed<nsIRunnable> aEvent)
     : WorkerRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount)
     , mEventSourceImpl(aImpl)
-    , mEvent(Move(aEvent))
+    , mEvent(std::move(aEvent))
   {
   }
 
   bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
   {
     aWorkerPrivate->AssertIsOnWorkerThread();
     return !NS_FAILED(mEvent->Run());
   }
--- a/dom/base/ImageEncoder.cpp
+++ b/dom/base/ImageEncoder.cpp
@@ -67,17 +67,17 @@ private:
 // This function returns a DataSourceSurface in B8G8R8A8 format.
 // It uses SourceSurface to do format convert. Because most SourceSurface in
 // image formats should be referenced or dereferenced on main thread, it uses a
 // sync class SurfaceHelper to retrieve SourceSurface and convert to B8G8R8A8 on
 // main thread.
 already_AddRefed<DataSourceSurface>
 GetBRGADataSourceSurfaceSync(already_AddRefed<layers::Image> aImage)
 {
-  RefPtr<SurfaceHelper> helper = new SurfaceHelper(Move(aImage));
+  RefPtr<SurfaceHelper> helper = new SurfaceHelper(std::move(aImage));
   return helper->GetDataSurfaceSafe();
 }
 
 class EncodingCompleteEvent : public CancelableRunnable
 {
   virtual ~EncodingCompleteEvent() {}
 
 public:
@@ -155,17 +155,17 @@ public:
                    EncodingCompleteEvent* aEncodingCompleteEvent,
                    int32_t aFormat,
                    const nsIntSize aSize,
                    bool aUsePlaceholder,
                    bool aUsingCustomOptions)
     : Runnable("EncodingRunnable")
     , mType(aType)
     , mOptions(aOptions)
-    , mImageBuffer(Move(aImageBuffer))
+    , mImageBuffer(std::move(aImageBuffer))
     , mImage(aImage)
     , mEncoder(aEncoder)
     , mEncodingCompleteEvent(aEncodingCompleteEvent)
     , mFormat(aFormat)
     , mSize(aSize)
     , mUsePlaceholder(aUsePlaceholder)
     , mUsingCustomOptions(aUsingCustomOptions)
   {}
@@ -322,17 +322,17 @@ ImageEncoder::ExtractDataAsync(nsAString
     return rv;
   }
 
   RefPtr<EncodingCompleteEvent> completeEvent =
     new EncodingCompleteEvent(aEncodeCallback);
 
   nsCOMPtr<nsIRunnable> event = new EncodingRunnable(aType,
                                                      aOptions,
-                                                     Move(aImageBuffer),
+                                                     std::move(aImageBuffer),
                                                      nullptr,
                                                      encoder,
                                                      completeEvent,
                                                      aFormat,
                                                      aSize,
                                                      aUsePlaceholder,
                                                      aUsingCustomOptions);
   return sThreadPool->Dispatch(event, NS_DISPATCH_NORMAL);
--- a/dom/base/MozQueryInterface.cpp
+++ b/dom/base/MozQueryInterface.cpp
@@ -98,17 +98,17 @@ ChromeUtils::GenerateQI(const GlobalObje
     ifaces.AppendElement(*iid->GetID());
   }
 
   MOZ_ASSERT(!ifaces.Contains(NS_GET_IID(nsISupports), IIDComparator()));
   ifaces.AppendElement(NS_GET_IID(nsISupports));
 
   ifaces.Sort(IIDComparator());
 
-  return new MozQueryInterface(Move(ifaces));
+  return new MozQueryInterface(std::move(ifaces));
 }
 
 bool
 MozQueryInterface::QueriesTo(const nsIID& aIID) const
 {
   // We use BinarySearchIf here because nsTArray::ContainsSorted requires
   // twice as many comparisons.
   size_t result;
--- a/dom/base/MozQueryInterface.h
+++ b/dom/base/MozQueryInterface.h
@@ -25,17 +25,17 @@
 
 namespace mozilla {
 namespace dom {
 
 class MozQueryInterface final : public NonRefcountedDOMObject
 {
 public:
   explicit MozQueryInterface(nsTArray<nsIID>&& aInterfaces)
-    : mInterfaces(Move(aInterfaces))
+    : mInterfaces(std::move(aInterfaces))
   {}
 
   bool QueriesTo(const nsIID& aIID) const;
 
   void LegacyCall(JSContext* cx, JS::Handle<JS::Value> thisv, nsIJSID* aIID, JS::MutableHandle<JS::Value> aResult, ErrorResult& aRv) const;
 
   nsISupports* GetParentObject() const { return nullptr; }
 
--- a/dom/base/Selection.cpp
+++ b/dom/base/Selection.cpp
@@ -1772,17 +1772,17 @@ Selection::LookUpSelection(nsIContent* a
   if (NS_FAILED(rv)) {
     return aDetailsHead;
   }
 
   if (overlappingRanges.Length() == 0) {
     return aDetailsHead;
   }
 
-  UniquePtr<SelectionDetails> detailsHead = Move(aDetailsHead);
+  UniquePtr<SelectionDetails> detailsHead = std::move(aDetailsHead);
 
   for (uint32_t i = 0; i < overlappingRanges.Length(); i++) {
     nsRange* range = overlappingRanges[i];
     nsINode* startNode = range->GetStartContainer();
     nsINode* endNode = range->GetEndContainer();
     int32_t startOffset = range->StartOffset();
     int32_t endOffset = range->EndOffset();
 
@@ -1818,25 +1818,25 @@ Selection::LookUpSelection(nsIContent* a
       start = 0;
       end = aContentLength;
     }
     if (start < 0)
       continue; // the ranges do not overlap the input range
 
     auto newHead = MakeUnique<SelectionDetails>();
 
-    newHead->mNext = Move(detailsHead);
+    newHead->mNext = std::move(detailsHead);
     newHead->mStart = start;
     newHead->mEnd = end;
     newHead->mSelectionType = aSelectionType;
     RangeData *rd = FindRangeData(range);
     if (rd) {
       newHead->mTextRangeStyle = rd->mTextRangeStyle;
     }
-    detailsHead = Move(newHead);
+    detailsHead = std::move(newHead);
   }
   return detailsHead;
 }
 
 NS_IMETHODIMP
 Selection::Repaint(nsPresContext* aPresContext)
 {
   int32_t arrCount = (int32_t)mRanges.Length();
@@ -2365,19 +2365,19 @@ Selection::Collapse(const RawRangeBounda
       }
     }
   }
 
   RefPtr<nsRange> range;
   // If the old range isn't referred by anybody other than this method,
   // we should reuse it for reducing the recreation cost.
   if (oldRange && oldRange->GetRefCount() == 1) {
-    range = Move(oldRange);
+    range = std::move(oldRange);
   } else if (mCachedRange) {
-    range = Move(mCachedRange);
+    range = std::move(mCachedRange);
   } else {
     range = new nsRange(aPoint.Container());
   }
   result = range->CollapseTo(aPoint);
   if (NS_FAILED(result)) {
     aRv.Throw(result);
     return;
   }
@@ -3665,17 +3665,17 @@ Selection::SetBaseAndExtent(nsINode& aAn
     start = &aFocusNode;
     end = &aAnchorNode;
     startOffset = aFocusOffset;
     endOffset = aAnchorOffset;
   }
 
   // If there is cached range, we should reuse it for saving the allocation
   // const (and some other cost in nsRange::DoSetRange().
-  RefPtr<nsRange> newRange = Move(mCachedRange);
+  RefPtr<nsRange> newRange = std::move(mCachedRange);
 
   nsresult rv = NS_OK;
   if (newRange) {
     rv = newRange->SetStartAndEnd(start, startOffset, end, endOffset);
   } else {
     rv = nsRange::CreateRange(start, startOffset, end, endOffset,
                               getter_AddRefs(newRange));
   }
--- a/dom/base/StructuredCloneBlob.cpp
+++ b/dom/base/StructuredCloneBlob.cpp
@@ -150,17 +150,17 @@ StructuredCloneBlob::ReadStructuredClone
       return false;
     }
     length -= size;
   }
 
   mBuffer = MakeUnique<JSAutoStructuredCloneBuffer>(mStructuredCloneScope,
                                                     &StructuredCloneHolder::sCallbacks,
                                                     this);
-  mBuffer->adopt(Move(data), version, &StructuredCloneHolder::sCallbacks);
+  mBuffer->adopt(std::move(data), version, &StructuredCloneHolder::sCallbacks);
 
   return true;
 }
 
 bool
 StructuredCloneBlob::WriteStructuredClone(JSContext* aCx, JSStructuredCloneWriter* aWriter,
                                           StructuredCloneHolder* aHolder)
 {
--- a/dom/base/StructuredCloneHolder.h
+++ b/dom/base/StructuredCloneHolder.h
@@ -37,17 +37,17 @@ namespace dom {
 class StructuredCloneHolderBase
 {
 public:
   typedef JS::StructuredCloneScope StructuredCloneScope;
 
   StructuredCloneHolderBase(StructuredCloneScope aScope = StructuredCloneScope::SameProcessSameThread);
   virtual ~StructuredCloneHolderBase();
 
-  // Note, it is unsafe to Move() a StructuredCloneHolderBase since a raw
+  // Note, it is unsafe to std::move() a StructuredCloneHolderBase since a raw
   // this pointer is passed to mBuffer as a callback closure.  That must
   // be fixed if you want to implement a move constructor here.
   StructuredCloneHolderBase(StructuredCloneHolderBase&& aOther) = delete;
 
   // These methods should be implemented in order to clone data.
   // Read more documentation in js/public/StructuredClone.h.
 
   virtual JSObject* CustomReadHandler(JSContext* aCx,
@@ -235,17 +235,17 @@ public:
   }
 
   // This must be called if the transferring has ports generated by Read().
   // MessagePorts are not thread-safe and they must be retrieved in the thread
   // where they are created.
   nsTArray<RefPtr<MessagePort>>&& TakeTransferredPorts()
   {
     MOZ_ASSERT(mSupportsTransferring);
-    return Move(mTransferredPorts);
+    return std::move(mTransferredPorts);
   }
 
   // This method uses TakeTransferredPorts() to populate a sequence of
   // MessagePorts for WebIDL binding classes.
   bool
   TakeTransferredPortsAsSequence(Sequence<OwningNonNull<mozilla::dom::MessagePort>>& aPorts);
 
   nsTArray<MessagePortIdentifier>& PortIdentifiers() const
--- a/dom/base/nsAttrValue.cpp
+++ b/dom/base/nsAttrValue.cpp
@@ -145,17 +145,17 @@ nsAttrValue::nsAttrValue(nsAtom* aValue)
 {
   SetTo(aValue);
 }
 
 nsAttrValue::nsAttrValue(already_AddRefed<DeclarationBlock> aValue,
                          const nsAString* aSerialized)
     : mBits(0)
 {
-  SetTo(Move(aValue), aSerialized);
+  SetTo(std::move(aValue), aSerialized);
 }
 
 nsAttrValue::nsAttrValue(const nsIntMargin& aValue)
     : mBits(0)
 {
   SetTo(aValue);
 }
 
@@ -1258,32 +1258,32 @@ nsAttrValue::ParseAtomArray(const nsAStr
   }
 
   if (!EnsureEmptyAtomArray()) {
     return;
   }
 
   AtomArray* array = GetAtomArrayValue();
 
-  if (!array->AppendElement(Move(classAtom))) {
+  if (!array->AppendElement(std::move(classAtom))) {
     Reset();
     return;
   }
 
   // parse the rest of the classnames
   while (iter != end) {
     start = iter;
 
     do {
       ++iter;
     } while (iter != end && !nsContentUtils::IsHTMLWhitespace(*iter));
 
     classAtom = NS_AtomizeMainThread(Substring(start, iter));
 
-    if (!array->AppendElement(Move(classAtom))) {
+    if (!array->AppendElement(std::move(classAtom))) {
       Reset();
       return;
     }
 
     // skip whitespace
     while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {
       ++iter;
     }
--- a/dom/base/nsContentIterator.cpp
+++ b/dom/base/nsContentIterator.cpp
@@ -12,17 +12,16 @@
 #include "nsCOMPtr.h"
 #include "nsTArray.h"
 #include "nsContentUtils.h"
 #include "nsINode.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsElementTable.h"
 
 using mozilla::DebugOnly;
-using mozilla::Move;
 using mozilla::RawRangeBoundary;
 
 // couple of utility static functs
 
 ///////////////////////////////////////////////////////////////////////////
 // NodeIsInTraversalRange: returns true if content is visited during
 // the traversal of the range in the specified mode.
 //
@@ -977,17 +976,17 @@ nsContentSubtreeIterator::Init(const Raw
     return NS_ERROR_INVALID_ARG;
   }
 
   if (NS_WARN_IF(range->StartRef() != aStart) ||
       NS_WARN_IF(range->EndRef() != aEnd)) {
     return NS_ERROR_UNEXPECTED;
   }
 
-  mRange = Move(range);
+  mRange = std::move(range);
 
   return InitWithRange();
 }
 
 nsresult
 nsContentSubtreeIterator::InitWithRange()
 {
   MOZ_ASSERT(mRange);
--- a/dom/base/nsContentPermissionHelper.cpp
+++ b/dom/base/nsContentPermissionHelper.cpp
@@ -427,17 +427,17 @@ nsContentPermissionUtils::GetContentPerm
 {
   nsTArray<PContentPermissionRequestParent*> parentArray;
   for (auto& it : ContentPermissionRequestParentMap()) {
     if (it.second == aTabId) {
       parentArray.AppendElement(it.first);
     }
   }
 
-  return Move(parentArray);
+  return std::move(parentArray);
 }
 
 /* static */ void
 nsContentPermissionUtils::NotifyRemoveContentPermissionRequestParent(
   PContentPermissionRequestParent* aParent)
 {
   auto it = ContentPermissionRequestParentMap().find(aParent);
   MOZ_ASSERT(it != ContentPermissionRequestParentMap().end());
@@ -450,17 +450,17 @@ nsContentPermissionUtils::GetContentPerm
 {
   nsTArray<PContentPermissionRequestChild*> childArray;
   for (auto& it : ContentPermissionRequestChildMap()) {
     if (it.second == aTabId) {
       childArray.AppendElement(it.first);
     }
   }
 
-  return Move(childArray);
+  return std::move(childArray);
 }
 
 /* static */ void
 nsContentPermissionUtils::NotifyRemoveContentPermissionRequestChild(
   PContentPermissionRequestChild* aChild)
 {
   auto it = ContentPermissionRequestChildMap().find(aChild);
   MOZ_ASSERT(it != ContentPermissionRequestChildMap().end());
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -5678,25 +5678,25 @@ nsContentUtils::AddScriptRunner(nsIRunna
   AddScriptRunner(runnable.forget());
 }
 
 /* static */
 void
 nsContentUtils::RunInStableState(already_AddRefed<nsIRunnable> aRunnable)
 {
   MOZ_ASSERT(CycleCollectedJSContext::Get(), "Must be on a script thread!");
-  CycleCollectedJSContext::Get()->RunInStableState(Move(aRunnable));
+  CycleCollectedJSContext::Get()->RunInStableState(std::move(aRunnable));
 }
 
 /* static */
 void
 nsContentUtils::AddPendingIDBTransaction(already_AddRefed<nsIRunnable> aTransaction)
 {
   MOZ_ASSERT(CycleCollectedJSContext::Get(), "Must be on a script thread!");
-  CycleCollectedJSContext::Get()->AddPendingIDBTransaction(Move(aTransaction));
+  CycleCollectedJSContext::Get()->AddPendingIDBTransaction(std::move(aTransaction));
 }
 
 /* static */
 bool
 nsContentUtils::IsInStableOrMetaStableState()
 {
   MOZ_ASSERT(CycleCollectedJSContext::Get(), "Must be on a script thread!");
   return CycleCollectedJSContext::Get()->IsInStableOrMetaStableState();
--- a/dom/base/nsDOMMutationObserver.cpp
+++ b/dom/base/nsDOMMutationObserver.cpp
@@ -731,17 +731,17 @@ nsDOMMutationObserver::Observe(nsINode& 
   nsMutationReceiver* r = GetReceiverFor(&aTarget, true, animations);
   r->SetChildList(childList);
   r->SetAttributes(attributes);
   r->SetCharacterData(characterData);
   r->SetSubtree(subtree);
   r->SetAttributeOldValue(attributeOldValue);
   r->SetCharacterDataOldValue(characterDataOldValue);
   r->SetNativeAnonymousChildList(nativeAnonymousChildList);
-  r->SetAttributeFilter(Move(filters));
+  r->SetAttributeFilter(std::move(filters));
   r->SetAllAttributes(allAttrs);
   r->SetAnimations(animations);
   r->RemoveClones();
 
 #ifdef DEBUG
   for (int32_t i = 0; i < mReceivers.Count(); ++i) {
     NS_WARNING_ASSERTION(mReceivers[i]->Target(),
                          "All the receivers should have a target!");
--- a/dom/base/nsDOMMutationObserver.h
+++ b/dom/base/nsDOMMutationObserver.h
@@ -220,17 +220,17 @@ public:
     mAttributeOldValue = aOldValue;
   }
 
   nsTArray<RefPtr<nsAtom>>& AttributeFilter() { return mAttributeFilter; }
   void SetAttributeFilter(nsTArray<RefPtr<nsAtom>>&& aFilter)
   {
     NS_ASSERTION(!mParent, "Shouldn't have parent");
     mAttributeFilter.Clear();
-    mAttributeFilter = mozilla::Move(aFilter);
+    mAttributeFilter = std::move(aFilter);
   }
 
   void AddClone(nsMutationReceiverBase* aClone)
   {
     mTransientReceivers.AppendObject(aClone);
   }
 
   void RemoveClone(nsMutationReceiverBase* aClone)
--- a/dom/base/nsDOMWindowUtils.cpp
+++ b/dom/base/nsDOMWindowUtils.cpp
@@ -178,25 +178,25 @@ class NativeInputRunnable final : public
 {
   explicit NativeInputRunnable(already_AddRefed<nsIRunnable>&& aEvent);
   ~NativeInputRunnable() {}
 public:
   static already_AddRefed<nsIRunnable> Create(already_AddRefed<nsIRunnable>&& aEvent);
 };
 
 NativeInputRunnable::NativeInputRunnable(already_AddRefed<nsIRunnable>&& aEvent)
-  : PrioritizableRunnable(Move(aEvent), nsIRunnablePriority::PRIORITY_INPUT)
+  : PrioritizableRunnable(std::move(aEvent), nsIRunnablePriority::PRIORITY_INPUT)
 {
 }
 
 /* static */ already_AddRefed<nsIRunnable>
 NativeInputRunnable::Create(already_AddRefed<nsIRunnable>&& aEvent)
 {
   MOZ_ASSERT(NS_IsMainThread());
-  nsCOMPtr<nsIRunnable> event(new NativeInputRunnable(Move(aEvent)));
+  nsCOMPtr<nsIRunnable> event(new NativeInputRunnable(std::move(aEvent)));
   return event.forget();
 }
 
 } // unnamed namespace
 
 LinkedList<OldWindowSize> OldWindowSize::sList;
 
 NS_INTERFACE_MAP_BEGIN(nsDOMWindowUtils)
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -380,21 +380,21 @@ nsIdentifierMapEntry::nsIdentifierMapEnt
 nsIdentifierMapEntry::nsIdentifierMapEntry(const nsIdentifierMapEntry::AtomOrString* aKey)
   : mKey(aKey ? *aKey : nullptr)
 {}
 
 nsIdentifierMapEntry::~nsIdentifierMapEntry()
 {}
 
 nsIdentifierMapEntry::nsIdentifierMapEntry(nsIdentifierMapEntry&& aOther)
-  : mKey(mozilla::Move(aOther.mKey))
-  , mIdContentList(mozilla::Move(aOther.mIdContentList))
-  , mNameContentList(mozilla::Move(aOther.mNameContentList))
-  , mChangeCallbacks(mozilla::Move(aOther.mChangeCallbacks))
-  , mImageElement(mozilla::Move(aOther.mImageElement))
+  : mKey(std::move(aOther.mKey))
+  , mIdContentList(std::move(aOther.mIdContentList))
+  , mNameContentList(std::move(aOther.mNameContentList))
+  , mChangeCallbacks(std::move(aOther.mChangeCallbacks))
+  , mImageElement(std::move(aOther.mImageElement))
 {}
 
 void
 nsIdentifierMapEntry::Traverse(nsCycleCollectionTraversalCallback* aCallback)
 {
   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*aCallback,
                                      "mIdentifierMap mNameContentList");
   aCallback->NoteXPCOMChild(static_cast<nsINodeList*>(mNameContentList));
@@ -3197,19 +3197,19 @@ nsIDocument::GetDocGroup() const
 }
 
 nsresult
 nsIDocument::Dispatch(TaskCategory aCategory,
                       already_AddRefed<nsIRunnable>&& aRunnable)
 {
   // Note that this method may be called off the main thread.
   if (mDocGroup) {
-    return mDocGroup->Dispatch(aCategory, Move(aRunnable));
-  }
-  return DispatcherTrait::Dispatch(aCategory, Move(aRunnable));
+    return mDocGroup->Dispatch(aCategory, std::move(aRunnable));
+  }
+  return DispatcherTrait::Dispatch(aCategory, std::move(aRunnable));
 }
 
 nsISerialEventTarget*
 nsIDocument::EventTargetFor(TaskCategory aCategory) const
 {
   if (mDocGroup) {
     return mDocGroup->EventTargetFor(aCategory);
   }
@@ -3836,17 +3836,17 @@ nsIDocument::CreateShell(nsPresContext* 
   NS_ENSURE_FALSE(GetBFCacheEntry(), nullptr);
 
   FillStyleSet(aStyleSet.get());
   AssertNoStaleServoDataIn(static_cast<nsINode&>(*this));
 
   RefPtr<PresShell> shell = new PresShell;
   // Note: we don't hold a ref to the shell (it holds a ref to us)
   mPresShell = shell;
-  shell->Init(this, aContext, aViewManager, Move(aStyleSet));
+  shell->Init(this, aContext, aViewManager, std::move(aStyleSet));
 
   // Make sure to never paint if we belong to an invisible DocShell.
   nsCOMPtr<nsIDocShell> docShell(mDocumentContainer);
   if (docShell && docShell->IsInvisible())
     shell->SetNeverPainting(true);
 
   MOZ_LOG(gDocumentLeakPRLog, LogLevel::Debug, ("DOCUMENT %p with PressShell %p and DocShell %p",
                                                 this, shell.get(), docShell.get()));
@@ -5561,39 +5561,39 @@ nsIDocument::GetAnonRootIfInAnonymousCon
   return nullptr;
 }
 
 Maybe<ClientInfo>
 nsIDocument::GetClientInfo() const
 {
   nsPIDOMWindowInner* inner = GetInnerWindow();
   if (inner) {
-    return Move(inner->GetClientInfo());
-  }
-  return Move(Maybe<ClientInfo>());
+    return std::move(inner->GetClientInfo());
+  }
+  return std::move(Maybe<ClientInfo>());
 }
 
 Maybe<ClientState>
 nsIDocument::GetClientState() const
 {
   nsPIDOMWindowInner* inner = GetInnerWindow();
   if (inner) {
-    return Move(inner->GetClientState());
-  }
-  return Move(Maybe<ClientState>());
+    return std::move(inner->GetClientState());
+  }
+  return std::move(Maybe<ClientState>());
 }
 
 Maybe<ServiceWorkerDescriptor>
 nsIDocument::GetController() const
 {
   nsPIDOMWindowInner* inner = GetInnerWindow();
   if (inner) {
-    return Move(inner->GetController());
-  }
-  return Move(Maybe<ServiceWorkerDescriptor>());
+    return std::move(inner->GetController());
+  }
+  return std::move(Maybe<ServiceWorkerDescriptor>());
 }
 
 //
 // nsIDocument interface
 //
 DocumentType*
 nsIDocument::GetDoctype() const
 {
@@ -6418,17 +6418,17 @@ nsIDocument::NotifyPossibleTitleChange(b
 
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
   RefPtr<nsRunnableMethod<nsIDocument, void, false>> event =
     NewNonOwningRunnableMethod("nsIDocument::DoNotifyPossibleTitleChange",
                                this,
                                &nsIDocument::DoNotifyPossibleTitleChange);
   nsresult rv = Dispatch(TaskCategory::Other, do_AddRef(event));
   if (NS_SUCCEEDED(rv)) {
-    mPendingTitleChangeEvent = Move(event);
+    mPendingTitleChangeEvent = std::move(event);
   }
 }
 
 void
 nsIDocument::DoNotifyPossibleTitleChange()
 {
   mPendingTitleChangeEvent.Forget();
   mHaveFiredTitleChange = true;
@@ -9525,17 +9525,17 @@ nsIDocument::FlushPendingLinkUpdates()
   if (mFlushingPendingLinkUpdates) {
     return;
   }
 
   auto restore = MakeScopeExit([&] { mFlushingPendingLinkUpdates = false; });
   mFlushingPendingLinkUpdates = true;
 
   while (!mLinksToUpdate.IsEmpty()) {
-    LinksToUpdateList links(Move(mLinksToUpdate));
+    LinksToUpdateList links(std::move(mLinksToUpdate));
     for (auto iter = links.Iter(); !iter.Done(); iter.Next()) {
       Link* link = iter.Get();
       Element* element = link->GetElement();
       if (element->OwnerDoc() == this) {
         link->ClearHasPendingLinkUpdate();
         if (element->IsInComposedDoc()) {
           element->UpdateLinkState(link->LinkState());
         }
@@ -10482,17 +10482,17 @@ ResetFullScreen(nsIDocument* aDocument, 
 // Since nsIDocument::ExitFullscreenInDocTree() could be called from
 // Element::UnbindFromTree() where it is not safe to synchronously run
 // script. This runnable is the script part of that function.
 class ExitFullscreenScriptRunnable : public Runnable
 {
 public:
   explicit ExitFullscreenScriptRunnable(nsCOMArray<nsIDocument>&& aDocuments)
     : mozilla::Runnable("ExitFullscreenScriptRunnable")
-    , mDocuments(Move(aDocuments))
+    , mDocuments(std::move(aDocuments))
   {
   }
 
   NS_IMETHOD Run() override
   {
     // Dispatch MozDOMFullscreen:Exited to the last document in
     // the list since we want this event to follow the same path
     // MozDOMFullscreen:Entered dispatched.
@@ -10552,17 +10552,17 @@ nsIDocument::ExitFullscreenInDocTree(nsI
 
   NS_ASSERTION(!root->FullScreenStackTop(),
     "Fullscreen root should no longer be a fullscreen doc...");
 
   // Move the top-level window out of fullscreen mode.
   FullscreenRoots::Remove(root);
 
   nsContentUtils::AddScriptRunner(
-    new ExitFullscreenScriptRunnable(Move(changed)));
+    new ExitFullscreenScriptRunnable(std::move(changed)));
 }
 
 bool
 GetFullscreenLeaf(nsIDocument* aDoc, void* aData)
 {
   if (aDoc->IsFullscreenLeaf()) {
     nsIDocument** result = static_cast<nsIDocument**>(aData);
     *result = aDoc;
@@ -10678,23 +10678,23 @@ nsIDocument::RestorePreviousFullScreenSt
   }
 }
 
 class nsCallRequestFullScreen : public Runnable
 {
 public:
   explicit nsCallRequestFullScreen(UniquePtr<FullscreenRequest>&& aRequest)
     : mozilla::Runnable("nsCallRequestFullScreen")
-    , mRequest(Move(aRequest))
+    , mRequest(std::move(aRequest))
   {
   }
 
   NS_IMETHOD Run() override
   {
-    mRequest->GetDocument()->RequestFullScreen(Move(mRequest));
+    mRequest->GetDocument()->RequestFullScreen(std::move(mRequest));
     return NS_OK;
   }
 
   UniquePtr<FullscreenRequest> mRequest;
 };
 
 void
 nsIDocument::AsyncRequestFullScreen(UniquePtr<FullscreenRequest>&& aRequest)
@@ -10702,17 +10702,17 @@ nsIDocument::AsyncRequestFullScreen(Uniq
   if (!aRequest->GetElement()) {
     MOZ_ASSERT_UNREACHABLE(
       "Must pass non-null element to nsDocument::AsyncRequestFullScreen");
     return;
   }
 
   // Request full-screen asynchronously.
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
-  nsCOMPtr<nsIRunnable> event = new nsCallRequestFullScreen(Move(aRequest));
+  nsCOMPtr<nsIRunnable> event = new nsCallRequestFullScreen(std::move(aRequest));
   Dispatch(TaskCategory::Other, event.forget());
 }
 
 void
 nsIDocument::DispatchFullscreenError(const char* aMessage)
 {
   RefPtr<AsyncEventDispatcher> asyncDispatcher =
     new AsyncEventDispatcher(this,
@@ -10883,17 +10883,17 @@ IsInActiveTab(nsIDocument* aDoc)
 nsresult nsIDocument::RemoteFrameFullscreenChanged(Element* aFrameElement)
 {
   // Ensure the frame element is the fullscreen element in this document.
   // If the frame element is already the fullscreen element in this document,
   // this has no effect.
   auto request = MakeUnique<FullscreenRequest>(aFrameElement);
   request->mIsCallerChrome = false;
   request->mShouldNotifyNewOrigin = false;
-  RequestFullScreen(Move(request));
+  RequestFullScreen(std::move(request));
 
   return NS_OK;
 }
 
 nsresult nsIDocument::RemoteFrameFullscreenReverted()
 {
   RestorePreviousFullScreenState();
   return NS_OK;
@@ -11179,17 +11179,17 @@ nsIDocument::RequestFullScreen(UniquePtr
   }
 
   // We don't need to check element ready before this point, because
   // if we called ApplyFullscreen, it would check that for us.
   if (!FullscreenElementReadyCheck(elem, aRequest->mIsCallerChrome)) {
     return;
   }
 
-  PendingFullscreenRequestList::Add(Move(aRequest));
+  PendingFullscreenRequestList::Add(std::move(aRequest));
   if (XRE_GetProcessType() == GeckoProcessType_Content) {
     // If we are not the top level process, dispatch an event to make
     // our parent process go fullscreen first.
     nsContentUtils::DispatchEventOnlyToChrome(
       this, ToSupports(this), NS_LITERAL_STRING("MozDOMFullscreen:Request"),
       /* Bubbles */ true, /* Cancelable */ false, /* DefaultAction */ nullptr);
   } else {
     // Make the window fullscreen.
--- a/dom/base/nsFrameLoader.cpp
+++ b/dom/base/nsFrameLoader.cpp
@@ -2234,23 +2234,23 @@ nsFrameLoader::MaybeCreateDocShell()
   if (!mDocShell->GetIsMozBrowser() &&
       parentType == mDocShell->ItemType() &&
       !doc->IsStaticDocument() && win) {
     // Propagate through the ancestor principals.
     nsTArray<nsCOMPtr<nsIPrincipal>> ancestorPrincipals;
     // Make a copy, so we can modify it.
     ancestorPrincipals = doc->AncestorPrincipals();
     ancestorPrincipals.InsertElementAt(0, doc->NodePrincipal());
-    nsDocShell::Cast(mDocShell)->SetAncestorPrincipals(Move(ancestorPrincipals));
+    nsDocShell::Cast(mDocShell)->SetAncestorPrincipals(std::move(ancestorPrincipals));
 
     // Repeat for outer window IDs.
     nsTArray<uint64_t> ancestorOuterWindowIDs;
     ancestorOuterWindowIDs = doc->AncestorOuterWindowIDs();
     ancestorOuterWindowIDs.InsertElementAt(0, win->WindowID());
-    nsDocShell::Cast(mDocShell)->SetAncestorOuterWindowIDs(Move(ancestorOuterWindowIDs));
+    nsDocShell::Cast(mDocShell)->SetAncestorOuterWindowIDs(std::move(ancestorOuterWindowIDs));
   }
 
   ReallyLoadFrameScripts();
   InitializeBrowserAPI();
 
   nsCOMPtr<nsIObserverService> os = services::GetObserverService();
   if (os) {
     os->NotifyObservers(ToSupports(this),
--- a/dom/base/nsFrameMessageManager.cpp
+++ b/dom/base/nsFrameMessageManager.cpp
@@ -754,17 +754,17 @@ nsFrameMessageManager::ReceiveMessage(ns
 
       // Get cloned MessagePort from StructuredCloneData.
       if (aCloneData) {
         Sequence<OwningNonNull<MessagePort>> ports;
         if (!aCloneData->TakeTransferredPortsAsSequence(ports)) {
           aError.Throw(NS_ERROR_FAILURE);
           return;
         }
-        argument.mPorts.Construct(Move(ports));
+        argument.mPorts.Construct(std::move(ports));
       }
 
       argument.mName = aMessage;
       argument.mPrincipal = aPrincipal;
       argument.mSync = aIsSync;
       argument.mTarget = aTarget;
       if (aTargetFrameLoader) {
         argument.mTargetFrameLoader.Construct(*aTargetFrameLoader);
--- a/dom/base/nsGlobalWindowInner.cpp
+++ b/dom/base/nsGlobalWindowInner.cpp
@@ -1759,29 +1759,29 @@ nsGlobalWindowInner::EnsureClientSource(
   // Try to get the reserved client from the LoadInfo.  A Client is
   // reserved at the start of the channel load if there is not an
   // initial about:blank document that will be reused.  It is also
   // created if the channel load encounters a cross-origin redirect.
   if (loadInfo) {
     UniquePtr<ClientSource> reservedClient = loadInfo->TakeReservedClientSource();
     if (reservedClient) {
       mClientSource.reset();
-      mClientSource = Move(reservedClient);
+      mClientSource = std::move(reservedClient);
       newClientSource = true;
     }
   }
 
   // We don't have a LoadInfo reserved client, but maybe we should
   // be inheriting an initial one from the docshell.  This means
   // that the docshell started the channel load before creating the
   // initial about:blank document.  This is an optimization, though,
   // and it created an initial Client as a placeholder for the document.
   // In this case we want to inherit this placeholder Client here.
   if (!mClientSource) {
-    mClientSource = Move(initialClientSource);
+    mClientSource = std::move(initialClientSource);
     if (mClientSource) {
       newClientSource = true;
     }
   }
 
   // Verify the final ClientSource principal matches the final document
   // principal.  The ClientChannelHelper handles things like network
   // redirects, but there are other ways the document principal can change.
@@ -2315,35 +2315,35 @@ void
 nsPIDOMWindowInner::SyncStateFromParentWindow()
 {
   nsGlobalWindowInner::Cast(this)->SyncStateFromParentWindow();
 }
 
 Maybe<ClientInfo>
 nsPIDOMWindowInner::GetClientInfo() const
 {
-  return Move(nsGlobalWindowInner::Cast(this)->GetClientInfo());
+  return std::move(nsGlobalWindowInner::Cast(this)->GetClientInfo());
 }
 
 Maybe<ClientState>
 nsPIDOMWindowInner::GetClientState() const
 {
-  return Move(nsGlobalWindowInner::Cast(this)->GetClientState());
+  return std::move(nsGlobalWindowInner::Cast(this)->GetClientState());
 }
 
 Maybe<ServiceWorkerDescriptor>
 nsPIDOMWindowInner::GetController() const
 {
-  return Move(nsGlobalWindowInner::Cast(this)->GetController());
+  return std::move(nsGlobalWindowInner::Cast(this)->GetController());
 }
 
 RefPtr<mozilla::dom::ServiceWorker>
 nsPIDOMWindowInner::GetOrCreateServiceWorker(const mozilla::dom::ServiceWorkerDescriptor& aDescriptor)
 {
-  return Move(nsGlobalWindowInner::Cast(this)->GetOrCreateServiceWorker(aDescriptor));
+  return std::move(nsGlobalWindowInner::Cast(this)->GetOrCreateServiceWorker(aDescriptor));
 }
 
 void
 nsPIDOMWindowInner::NoteCalledRegisterForServiceWorkerScope(const nsACString& aScope)
 {
   nsGlobalWindowInner::Cast(this)->NoteCalledRegisterForServiceWorkerScope(aScope);
 }
 
@@ -5493,17 +5493,17 @@ nsGlobalWindowInner::ShowSlowScriptDialo
   auto getString = [&] (const char* name,
                         nsContentUtils::PropertiesFile propFile = nsContentUtils::eDOM_PROPERTIES) {
     nsAutoString result;
     nsresult rv = nsContentUtils::GetLocalizedString(
       propFile, name, result);
 
     // GetStringFromName can return NS_OK and still give nullptr string
     failed = failed || NS_FAILED(rv) || result.IsEmpty();
-    return Move(result);
+    return std::move(result);
   };
 
   bool isAddonScript = !aAddonId.IsEmpty();
   bool showDebugButton = debugCallback && !isAddonScript;
 
   // Get localizable strings
 
   nsAutoString title, checkboxMsg, debugButton, msg;
@@ -6324,43 +6324,43 @@ nsGlobalWindowInner::CallOnChildren(Meth
 Maybe<ClientInfo>
 nsGlobalWindowInner::GetClientInfo() const
 {
   MOZ_ASSERT(NS_IsMainThread());
   Maybe<ClientInfo> clientInfo;
   if (mClientSource) {
     clientInfo.emplace(mClientSource->Info());
   }
-  return Move(clientInfo);
+  return std::move(clientInfo);
 }
 
 Maybe<ClientState>
 nsGlobalWindowInner::GetClientState() const
 {
   MOZ_ASSERT(NS_IsMainThread());
   Maybe<ClientState> clientState;
   if (mClientSource) {
     ClientState state;
     nsresult rv = mClientSource->SnapshotState(&state);
     if (NS_SUCCEEDED(rv)) {
       clientState.emplace(state);
     }
   }
-  return Move(clientState);
+  return std::move(clientState);
 }
 
 Maybe<ServiceWorkerDescriptor>
 nsGlobalWindowInner::GetController() const
 {
   MOZ_ASSERT(NS_IsMainThread());
   Maybe<ServiceWorkerDescriptor> controller;
   if (mClientSource) {
     controller = mClientSource->GetController();
   }
-  return Move(controller);
+  return std::move(controller);
 }
 
 RefPtr<ServiceWorker>
 nsGlobalWindowInner::GetOrCreateServiceWorker(const ServiceWorkerDescriptor& aDescriptor)
 {
   MOZ_ASSERT(NS_IsMainThread());
   RefPtr<ServiceWorker> ref;
   ForEachEventTargetObject([&] (DOMEventTargetHelper* aTarget, bool* aDoneOut) {
@@ -7371,17 +7371,17 @@ nsGlobalWindowInner::PromiseDocumentFlus
     bool success = shell->AddPostRefreshObserver(this);
     if (!success) {
       aError.Throw(NS_ERROR_FAILURE);
       return nullptr;
     }
     mObservingDidRefresh = true;
   }
 
-  mDocumentFlushedResolvers.AppendElement(Move(flushResolver));
+  mDocumentFlushedResolvers.AppendElement(std::move(flushResolver));
   return resultPromise.forget();
 }
 
 template<bool call>
 void
 nsGlobalWindowInner::CallOrCancelDocumentFlushedResolvers()
 {
   MOZ_ASSERT(!mIteratingDocumentFlushedResolvers);
@@ -7925,19 +7925,19 @@ nsGlobalWindowInner::TabGroupInner()
 }
 
 nsresult
 nsGlobalWindowInner::Dispatch(TaskCategory aCategory,
                               already_AddRefed<nsIRunnable>&& aRunnable)
 {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
   if (GetDocGroup()) {
-    return GetDocGroup()->Dispatch(aCategory, Move(aRunnable));
-  }
-  return DispatcherTrait::Dispatch(aCategory, Move(aRunnable));
+    return GetDocGroup()->Dispatch(aCategory, std::move(aRunnable));
+  }
+  return DispatcherTrait::Dispatch(aCategory, std::move(aRunnable));
 }
 
 nsISerialEventTarget*
 nsGlobalWindowInner::EventTargetFor(TaskCategory aCategory) const
 {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
   if (GetDocGroup()) {
     return GetDocGroup()->EventTargetFor(aCategory);
--- a/dom/base/nsGlobalWindowOuter.cpp
+++ b/dom/base/nsGlobalWindowOuter.cpp
@@ -7567,19 +7567,19 @@ nsGlobalWindowOuter::TabGroupOuter()
 }
 
 nsresult
 nsGlobalWindowOuter::Dispatch(TaskCategory aCategory,
                               already_AddRefed<nsIRunnable>&& aRunnable)
 {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
   if (GetDocGroup()) {
-    return GetDocGroup()->Dispatch(aCategory, Move(aRunnable));
-  }
-  return DispatcherTrait::Dispatch(aCategory, Move(aRunnable));
+    return GetDocGroup()->Dispatch(aCategory, std::move(aRunnable));
+  }
+  return DispatcherTrait::Dispatch(aCategory, std::move(aRunnable));
 }
 
 nsISerialEventTarget*
 nsGlobalWindowOuter::EventTargetFor(TaskCategory aCategory) const
 {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
   if (GetDocGroup()) {
     return GetDocGroup()->EventTargetFor(aCategory);
--- a/dom/base/nsIDocument.h
+++ b/dom/base/nsIDocument.h
@@ -1397,17 +1397,17 @@ public:
     using SelectorList = mozilla::UniquePtr<RawServoSelectorList>;
 
     explicit SelectorCache(nsIEventTarget* aEventTarget);
 
     void CacheList(const nsAString& aSelector, SelectorList aSelectorList)
     {
       MOZ_ASSERT(NS_IsMainThread());
       SelectorCacheKey* key = new SelectorCacheKey(aSelector);
-      mTable.Put(key->mKey, Move(aSelectorList));
+      mTable.Put(key->mKey, std::move(aSelectorList));
       AddObject(key);
     }
 
     void NotifyExpired(SelectorCacheKey* aSelector) final;
 
     // We do not call MarkUsed because it would just slow down lookups and
     // because we're OK expiring things after a few seconds even if they're
     // being used.  Returns whether we actually had an entry for aSelector.
--- a/dom/base/nsINode.cpp
+++ b/dom/base/nsINode.cpp
@@ -2430,17 +2430,17 @@ nsINode::ParseSelectorList(const nsAStri
   if (!selectorList) {
     aRv.ThrowDOMException(NS_ERROR_DOM_SYNTAX_ERR,
       NS_LITERAL_CSTRING("'") + selectorString +
       NS_LITERAL_CSTRING("' is not a valid selector")
     );
   }
 
   auto* ret = selectorList.get();
-  cache.CacheList(aSelectorString, Move(selectorList));
+  cache.CacheList(aSelectorString, std::move(selectorList));
   return ret;
 }
 
 namespace {
 struct SelectorMatchInfo {
 };
 } // namespace
 
--- a/dom/base/nsImageLoadingContent.cpp
+++ b/dom/base/nsImageLoadingContent.cpp
@@ -464,17 +464,17 @@ nsImageLoadingContent::AddObserver(imgIN
     rv = mPendingRequest->Clone(aObserver, nullptr, getter_AddRefs(pendingReq));
     if (NS_FAILED(rv)) {
       mCurrentRequest->CancelAndForgetObserver(NS_BINDING_ABORTED);
       return;
     }
   }
 
   mScriptedObservers.AppendElement(
-    new ScriptedImageObserver(aObserver, Move(currentReq), Move(pendingReq)));
+    new ScriptedImageObserver(aObserver, std::move(currentReq), std::move(pendingReq)));
 }
 
 void
 nsImageLoadingContent::RemoveObserver(imgINotificationObserver* aObserver)
 {
   if (NS_WARN_IF(!aObserver)) {
     return;
   }
@@ -483,17 +483,17 @@ nsImageLoadingContent::RemoveObserver(im
     return;
   }
 
   RefPtr<ScriptedImageObserver> observer;
   auto i = mScriptedObservers.Length();
   do {
     --i;
     if (mScriptedObservers[i]->mObserver == aObserver) {
-      observer = Move(mScriptedObservers[i]);
+      observer = std::move(mScriptedObservers[i]);
       mScriptedObservers.RemoveElementAt(i);
       break;
     }
   } while(i > 0);
 
   if (NS_WARN_IF(!observer)) {
     return;
   }
@@ -513,20 +513,20 @@ nsImageLoadingContent::ClearScriptedRequ
   nsTArray<RefPtr<ScriptedImageObserver>> observers(mScriptedObservers);
   auto i = observers.Length();
   do {
     --i;
 
     RefPtr<imgRequestProxy> req;
     switch (aRequestType) {
     case CURRENT_REQUEST:
-      req = Move(observers[i]->mCurrentRequest);
+      req = std::move(observers[i]->mCurrentRequest);
       break;
     case PENDING_REQUEST:
-      req = Move(observers[i]->mPendingRequest);
+      req = std::move(observers[i]->mPendingRequest);
       break;
     default:
       NS_ERROR("Unknown request type");
       return;
     }
 
     if (req) {
       req->CancelAndForgetObserver(aReason);
@@ -583,17 +583,17 @@ nsImageLoadingContent::MakePendingScript
   auto i = observers.Length();
   do {
     --i;
 
     ScriptedImageObserver* observer = observers[i];
     if (observer->mCurrentRequest) {
       observer->mCurrentRequest->CancelAndForgetObserver(NS_BINDING_ABORTED);
     }
-    observer->mCurrentRequest = Move(observer->mPendingRequest);
+    observer->mCurrentRequest = std::move(observer->mPendingRequest);
   } while (i > 0);
 }
 
 already_AddRefed<imgIRequest>
 nsImageLoadingContent::GetRequest(int32_t aRequestType,
                                   ErrorResult& aError)
 {
   nsCOMPtr<imgIRequest> request;
--- a/dom/base/nsJSTimeoutHandler.cpp
+++ b/dom/base/nsJSTimeoutHandler.cpp
@@ -228,17 +228,17 @@ nsJSScriptTimeoutHandler::nsJSScriptTime
 {
   if (!aWindow->GetContextInternal() || !aWindow->FastGetGlobalJSObject()) {
     // This window was already closed, or never properly initialized,
     // don't let a timer be scheduled on such a window.
     aError.Throw(NS_ERROR_NOT_INITIALIZED);
     return;
   }
 
-  Init(aCx, Move(aArguments));
+  Init(aCx, std::move(aArguments));
 }
 
 nsJSScriptTimeoutHandler::nsJSScriptTimeoutHandler(JSContext* aCx,
                                                    nsGlobalWindowInner *aWindow,
                                                    const nsAString& aExpression,
                                                    bool* aAllowEval,
                                                    ErrorResult& aError)
   : mLineNo(0)
@@ -266,17 +266,17 @@ nsJSScriptTimeoutHandler::nsJSScriptTime
                                                    nsTArray<JS::Heap<JS::Value>>&& aArguments)
   : mLineNo(0)
   , mColumn(0)
   , mFunction(&aFunction)
 {
   MOZ_ASSERT(aWorkerPrivate);
   aWorkerPrivate->AssertIsOnWorkerThread();
 
-  Init(aCx, Move(aArguments));
+  Init(aCx, std::move(aArguments));
 }
 
 nsJSScriptTimeoutHandler::nsJSScriptTimeoutHandler(JSContext* aCx,
                                                    WorkerPrivate* aWorkerPrivate,
                                                    const nsAString& aExpression)
   : mLineNo(0)
   , mColumn(0)
   , mExpr(aExpression)
@@ -292,17 +292,17 @@ nsJSScriptTimeoutHandler::~nsJSScriptTim
   ReleaseJSObjects();
 }
 
 void
 nsJSScriptTimeoutHandler::Init(JSContext* aCx,
                                nsTArray<JS::Heap<JS::Value>>&& aArguments)
 {
   mozilla::HoldJSObjects(this);
-  mArgs = Move(aArguments);
+  mArgs = std::move(aArguments);
 
   Init(aCx);
 }
 
 void
 nsJSScriptTimeoutHandler::Init(JSContext* aCx)
 {
   // Get the calling location.
@@ -334,17 +334,17 @@ NS_CreateJSTimeoutHandler(JSContext *aCx
 {
   nsTArray<JS::Heap<JS::Value>> args;
   if (!args.AppendElements(aArguments, fallible)) {
     aError.Throw(NS_ERROR_OUT_OF_MEMORY);
     return nullptr;
   }
 
   RefPtr<nsJSScriptTimeoutHandler> handler =
-    new nsJSScriptTimeoutHandler(aCx, aWindow, aFunction, Move(args), aError);
+    new nsJSScriptTimeoutHandler(aCx, aWindow, aFunction, std::move(args), aError);
   return aError.Failed() ? nullptr : handler.forget();
 }
 
 already_AddRefed<nsIScriptTimeoutHandler>
 NS_CreateJSTimeoutHandler(JSContext* aCx, nsGlobalWindowInner *aWindow,
                           const nsAString& aExpression, ErrorResult& aError)
 {
   bool allowEval = false;
@@ -365,17 +365,17 @@ NS_CreateJSTimeoutHandler(JSContext *aCx
 {
   nsTArray<JS::Heap<JS::Value>> args;
   if (!args.AppendElements(aArguments, fallible)) {
     aError.Throw(NS_ERROR_OUT_OF_MEMORY);
     return nullptr;
   }
 
   RefPtr<nsJSScriptTimeoutHandler> handler =
-    new nsJSScriptTimeoutHandler(aCx, aWorkerPrivate, aFunction, Move(args));
+    new nsJSScriptTimeoutHandler(aCx, aWorkerPrivate, aFunction, std::move(args));
   return handler.forget();
 }
 
 already_AddRefed<nsIScriptTimeoutHandler>
 NS_CreateJSTimeoutHandler(JSContext* aCx, WorkerPrivate* aWorkerPrivate,
                           const nsAString& aExpression)
 {
   RefPtr<nsJSScriptTimeoutHandler> handler =
--- a/dom/base/nsQueryContentEventResult.cpp
+++ b/dom/base/nsQueryContentEventResult.cpp
@@ -228,17 +228,17 @@ nsQueryContentEventResult::SetEventResul
 {
   mEventMessage = aEvent.mMessage;
   mSucceeded = aEvent.mSucceeded;
   mReversed = aEvent.mReply.mReversed;
   mRect = aEvent.mReply.mRect;
   mOffset = aEvent.mReply.mOffset;
   mTentativeCaretOffset = aEvent.mReply.mTentativeCaretOffset;
   mString = aEvent.mReply.mString;
-  mRectArray = mozilla::Move(aEvent.mReply.mRectArray);
+  mRectArray = std::move(aEvent.mReply.mRectArray);
   // Mark as result that is longer used.
   aEvent.mSucceeded = false;
 
   if (!IsRectRelatedPropertyAvailable(mEventMessage) ||
       !aWidget || !mSucceeded) {
     return;
   }
 
--- a/dom/base/nsRange.cpp
+++ b/dom/base/nsRange.cpp
@@ -3212,17 +3212,17 @@ nsRange::GetUsedFontFaces(nsTArray<nsAut
     }
 
     nsLayoutUtils::GetFontFacesForFrames(frame, fontFaces, aMaxRanges);
   }
 
   // Take ownership of the InspectorFontFaces in the table and move them into
   // the aResult outparam.
   for (auto iter = fontFaces.Iter(); !iter.Done(); iter.Next()) {
-    aResult.AppendElement(Move(iter.Data()));
+    aResult.AppendElement(std::move(iter.Data()));
   }
 
   return NS_OK;
 }
 
 nsINode*
 nsRange::GetRegisteredCommonAncestor()
 {
--- a/dom/base/nsSyncLoadService.cpp
+++ b/dom/base/nsSyncLoadService.cpp
@@ -342,17 +342,17 @@ nsSyncLoadService::LoadDocument(nsIURI *
 }
 
 /* static */
 nsresult
 nsSyncLoadService::PushSyncStreamToListener(already_AddRefed<nsIInputStream> aIn,
                                             nsIStreamListener* aListener,
                                             nsIChannel* aChannel)
 {
-    nsCOMPtr<nsIInputStream> in = Move(aIn);
+    nsCOMPtr<nsIInputStream> in = std::move(aIn);
 
     // Set up buffering stream
     nsresult rv;
     nsCOMPtr<nsIInputStream> bufferedStream;
     if (!NS_InputStreamIsBuffered(in)) {
         int64_t chunkSize;
         rv = aChannel->GetContentLength(&chunkSize);
         if (NS_FAILED(rv) || chunkSize < 1) {
--- a/dom/bindings/BindingUtils.h
+++ b/dom/bindings/BindingUtils.h
@@ -3258,17 +3258,17 @@ WrappedJSToDictionary(nsISupports* aObje
   return aDictionary.Init(aes.cx(), v);
 }
 
 
 template<class T, class S>
 inline RefPtr<T>
 StrongOrRawPtr(already_AddRefed<S>&& aPtr)
 {
-  return Move(aPtr);
+  return std::move(aPtr);
 }
 
 template<class T,
          class ReturnType=typename Conditional<IsRefcounted<T>::value, T*,
                                                nsAutoPtr<T>>::Type>
 inline ReturnType
 StrongOrRawPtr(T* aPtr)
 {
--- a/dom/bindings/ErrorIPCUtils.h
+++ b/dom/bindings/ErrorIPCUtils.h
@@ -69,17 +69,17 @@ struct ParamTraits<mozilla::ErrorResult>
       return false;
     }
     if (hasMessage && !readValue.DeserializeMessage(aMsg, aIter)) {
       return false;
     } else if (hasDOMExceptionInfo &&
                !readValue.DeserializeDOMExceptionInfo(aMsg, aIter)) {
       return false;
     }
-    *aResult = Move(readValue);
+    *aResult = std::move(readValue);
     return true;
   }
 };
 
 template<>
 struct ParamTraits<mozilla::CopyableErrorResult>
 {
   typedef mozilla::CopyableErrorResult paramType;
--- a/dom/bindings/ErrorResult.h
+++ b/dom/bindings/ErrorResult.h
@@ -149,17 +149,17 @@ public:
   }
 
   TErrorResult(TErrorResult&& aRHS)
     // Initialize mResult and whatever else we need to default-initialize, so
     // the ClearUnionData call in our operator= will do the right thing
     // (nothing).
     : TErrorResult()
   {
-    *this = Move(aRHS);
+    *this = std::move(aRHS);
   }
   TErrorResult& operator=(TErrorResult&& aRHS);
 
   explicit TErrorResult(nsresult aRv)
     : TErrorResult()
   {
     AssignErrorCode(aRv);
   }
@@ -602,31 +602,31 @@ class ErrorResult :
   typedef binding_danger::TErrorResult<binding_danger::AssertAndSuppressCleanupPolicy> BaseErrorResult;
 
 public:
   ErrorResult()
     : BaseErrorResult()
   {}
 
   ErrorResult(ErrorResult&& aRHS)
-    : BaseErrorResult(Move(aRHS))
+    : BaseErrorResult(std::move(aRHS))
   {}
 
   explicit ErrorResult(nsresult aRv)
     : BaseErrorResult(aRv)
   {}
 
   void operator=(nsresult rv)
   {
     BaseErrorResult::operator=(rv);
   }
 
   ErrorResult& operator=(ErrorResult&& aRHS)
   {
-    BaseErrorResult::operator=(Move(aRHS));
+    BaseErrorResult::operator=(std::move(aRHS));
     return *this;
   }
 
 private:
   // Not to be implemented, to make sure people always pass this by
   // reference, not by value.
   ErrorResult(const ErrorResult&) = delete;
   void operator=(const ErrorResult&) = delete;
@@ -699,31 +699,31 @@ public:
   explicit CopyableErrorResult(const ErrorResult& aRight)
     : BaseErrorResult()
   {
     auto val = reinterpret_cast<const CopyableErrorResult&>(aRight);
     operator=(val);
   }
 
   CopyableErrorResult(CopyableErrorResult&& aRHS)
-    : BaseErrorResult(Move(aRHS))
+    : BaseErrorResult(std::move(aRHS))
   {}
 
   explicit CopyableErrorResult(nsresult aRv)
     : BaseErrorResult(aRv)
   {}
 
   void operator=(nsresult rv)
   {
     BaseErrorResult::operator=(rv);
   }
 
   CopyableErrorResult& operator=(CopyableErrorResult&& aRHS)
   {
-    BaseErrorResult::operator=(Move(aRHS));
+    BaseErrorResult::operator=(std::move(aRHS));
     return *this;
   }
 
   CopyableErrorResult(const CopyableErrorResult& aRight)
     : BaseErrorResult()
   {
     operator=(aRight);
   }
--- a/dom/bindings/Exceptions.cpp
+++ b/dom/bindings/Exceptions.cpp
@@ -197,17 +197,17 @@ GetCurrentJSStack(int32_t aMaxDepth)
   if (aMaxDepth < 0) {
     aMaxDepth = MAX_FRAMES;
   }
 
   JS::StackCapture captureMode = aMaxDepth == 0
     ? JS::StackCapture(JS::AllFrames())
     : JS::StackCapture(JS::MaxFrames(aMaxDepth));
 
-  return dom::exceptions::CreateStack(cx, mozilla::Move(captureMode));
+  return dom::exceptions::CreateStack(cx, std::move(captureMode));
 }
 
 namespace exceptions {
 
 class JSStackFrame : public nsIStackFrame
 {
 public:
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
@@ -685,17 +685,17 @@ JSStackFrame::ToString(JSContext* aCx, n
                        NS_ConvertUTF16toUTF8(funname).get(),
                        lineno);
 }
 
 already_AddRefed<nsIStackFrame>
 CreateStack(JSContext* aCx, JS::StackCapture&& aCaptureMode)
 {
   JS::Rooted<JSObject*> stack(aCx);
-  if (!JS::CaptureCurrentStack(aCx, &stack, mozilla::Move(aCaptureMode))) {
+  if (!JS::CaptureCurrentStack(aCx, &stack, std::move(aCaptureMode))) {
     return nullptr;
   }
 
   if (!stack) {
     return nullptr;
   }
 
   nsCOMPtr<nsIStackFrame> frame = new JSStackFrame(stack);
--- a/dom/bindings/Nullable.h
+++ b/dom/bindings/Nullable.h
@@ -39,21 +39,21 @@ public:
     : mValue()
   {
     mValue.emplace(aValue);
   }
 
   MOZ_IMPLICIT Nullable(T&& aValue)
     : mValue()
   {
-    mValue.emplace(mozilla::Move(aValue));
+    mValue.emplace(std::move(aValue));
   }
 
   Nullable(Nullable<T>&& aOther)
-    : mValue(mozilla::Move(aOther.mValue))
+    : mValue(std::move(aOther.mValue))
   {}
 
   Nullable(const Nullable<T>& aOther)
     : mValue(aOther.mValue)
   {}
 
   void operator=(const Nullable<T>& aOther)
   {
@@ -64,17 +64,17 @@ public:
   {
     mValue.reset();
     mValue.emplace(aArgs);
   }
 
   void SetValue(T&& aArgs)
   {
     mValue.reset();
-    mValue.emplace(mozilla::Move(aArgs));
+    mValue.emplace(std::move(aArgs));
   }
 
   // For cases when |T| is some type with nontrivial copy behavior, we may want
   // to get a reference to our internal copy of T and work with it directly
   // instead of relying on the copying version of SetValue().
   T& SetValue() {
     if (mValue.isNothing()) {
       mValue.emplace();
--- a/dom/bindings/Record.h
+++ b/dom/bindings/Record.h
@@ -27,18 +27,18 @@ class RecordEntry
 {
 public:
   RecordEntry()
   {
   }
 
   // Move constructor so we can do Records of Records.
   RecordEntry(RecordEntry<KeyType, ValueType>&& aOther)
-    : mKey(Move(aOther.mKey)),
-      mValue(Move(aOther.mValue))
+    : mKey(std::move(aOther.mKey)),
+      mValue(std::move(aOther.mValue))
   {
   }
 
   KeyType mKey;
   ValueType mValue;
 };
 
 } // namespace binding_detail
@@ -51,17 +51,17 @@ public:
   typedef Record<KeyType, ValueType> SelfType;
 
   Record()
   {
   }
 
   // Move constructor so we can do Record of Record.
   Record(SelfType&& aOther) :
-    mEntries(Move(aOther.mEntries))
+    mEntries(std::move(aOther.mEntries))
   {
   }
 
   const nsTArray<EntryType>& Entries() const
   {
     return mEntries;
   }
 
--- a/dom/bindings/TypedArray.h
+++ b/dom/bindings/TypedArray.h
@@ -34,17 +34,17 @@ struct TypedArray_base : public SpiderMo
     : mData(nullptr),
       mLength(0),
       mShared(false),
       mComputed(false)
   {
   }
 
   TypedArray_base(TypedArray_base&& aOther)
-    : SpiderMonkeyInterfaceObjectStorage(Move(aOther)),
+    : SpiderMonkeyInterfaceObjectStorage(std::move(aOther)),
       mData(aOther.mData),
       mLength(aOther.mLength),
       mShared(aOther.mShared),
       mComputed(aOther.mComputed)
   {
     aOther.mData = nullptr;
     aOther.mLength = 0;
     aOther.mShared = false;
@@ -159,17 +159,17 @@ private:
   typedef TypedArray_base<T, UnwrapArray, GetLengthAndDataAndSharedness> Base;
 
 public:
   TypedArray()
     : Base()
   {}
 
   TypedArray(TypedArray&& aOther)
-    : Base(Move(aOther))
+    : Base(std::move(aOther))
   {
   }
 
   static inline JSObject*
   Create(JSContext* cx, nsWrapperCache* creator, uint32_t length,
          const T* data = nullptr) {
     JS::Rooted<JSObject*> creatorWrapper(cx);
     Maybe<JSAutoRealm> ar;
@@ -220,17 +220,17 @@ private:
 
 public:
   ArrayBufferView_base()
     : Base()
   {
   }
 
   ArrayBufferView_base(ArrayBufferView_base&& aOther)
-    : Base(Move(aOther)),
+    : Base(std::move(aOther)),
       mType(aOther.mType)
   {
     aOther.mType = js::Scalar::MaxTypedArrayViewType;
   }
 
 private:
   js::Scalar::Type mType;
 
--- a/dom/broadcastchannel/BroadcastChannel.cpp
+++ b/dom/broadcastchannel/BroadcastChannel.cpp
@@ -319,17 +319,17 @@ BroadcastChannel::Constructor(const Glob
 
     RefPtr<InitializeRunnable> runnable =
       new InitializeRunnable(tsr, origin, principalInfo, aRv);
     runnable->Dispatch(Canceling, aRv);
     if (aRv.Failed()) {
       return nullptr;
     }
 
-    bc->mWorkerRef = Move(workerRef);
+    bc->mWorkerRef = std::move(workerRef);
   }
 
   // Register this component to PBackground.
   PBackgroundChild* actorChild = BackgroundChild::GetOrCreateForCurrentThread();
   if (NS_WARN_IF(!actorChild)) {
     // Firefox is probably shutting down. Let's return a 'generic' error.
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
--- a/dom/cache/Cache.cpp
+++ b/dom/cache/Cache.cpp
@@ -112,17 +112,17 @@ IsValidPutResponseStatus(Response& aResp
 // actor.
 class Cache::FetchHandler final : public PromiseNativeHandler
 {
 public:
   FetchHandler(CacheWorkerHolder* aWorkerHolder, Cache* aCache,
                nsTArray<RefPtr<Request>>&& aRequestList, Promise* aPromise)
     : mWorkerHolder(aWorkerHolder)
     , mCache(aCache)
-    , mRequestList(Move(aRequestList))
+    , mRequestList(std::move(aRequestList))
     , mPromise(aPromise)
   {
     MOZ_ASSERT_IF(!NS_IsMainThread(), mWorkerHolder);
     MOZ_DIAGNOSTIC_ASSERT(mCache);
     MOZ_DIAGNOSTIC_ASSERT(mPromise);
   }
 
   virtual void
@@ -189,17 +189,17 @@ public:
       ErrorResult errorResult;
       if (!IsValidPutResponseStatus(*response, PutStatusPolicy::RequireOK,
                                     errorResult)) {
         // TODO: abort the fetch requests we have running (bug 1157434)
         mPromise->MaybeReject(errorResult);
         return;
       }
 
-      responseList.AppendElement(Move(response));
+      responseList.AppendElement(std::move(response));
     }
 
     MOZ_DIAGNOSTIC_ASSERT(mRequestList.Length() == responseList.Length());
 
     // Now store the unwrapped Response list in the Cache.
     ErrorResult result;
     // TODO: Here we use the JSContext as received by the ResolvedCallback, and
     // its state could be the wrong one. The spec doesn't say anything
@@ -358,18 +358,18 @@ Cache::Add(JSContext* aContext, const Re
   }
 
   nsAutoString url;
   request->GetUrl(url);
   if (NS_WARN_IF(!IsValidPutRequestURL(url, aRv))) {
     return nullptr;
   }
 
-  requestList.AppendElement(Move(request));
-  return AddAll(global, Move(requestList), aCallerType, aRv);
+  requestList.AppendElement(std::move(request));
+  return AddAll(global, std::move(requestList), aCallerType, aRv);
 }
 
 already_AddRefed<Promise>
 Cache::AddAll(JSContext* aContext,
               const Sequence<OwningRequestOrUSVString>& aRequestList,
               CallerType aCallerType,
               ErrorResult& aRv)
 {
@@ -406,20 +406,20 @@ Cache::AddAll(JSContext* aContext,
     }
 
     nsAutoString url;
     request->GetUrl(url);
     if (NS_WARN_IF(!IsValidPutRequestURL(url, aRv))) {
       return nullptr;
     }
 
-    requestList.AppendElement(Move(request));
+    requestList.AppendElement(std::move(request));
   }
 
-  return AddAll(global, Move(requestList), aCallerType, aRv);
+  return AddAll(global, std::move(requestList), aCallerType, aRv);
 }
 
 already_AddRefed<Promise>
 Cache::Put(JSContext* aCx, const RequestOrUSVString& aRequest,
            Response& aResponse, ErrorResult& aRv)
 {
   if (NS_WARN_IF(!mActor)) {
     aRv.Throw(NS_ERROR_UNEXPECTED);
@@ -613,27 +613,27 @@ Cache::AddAll(const GlobalObject& aGloba
     RequestOrUSVString requestOrString;
     requestOrString.SetAsRequest() = aRequestList[i];
     RefPtr<Promise> fetch = FetchRequest(mGlobal, requestOrString,
                                          RequestInit(), aCallerType, aRv);
     if (NS_WARN_IF(aRv.Failed())) {
       return nullptr;
     }
 
-    fetchList.AppendElement(Move(fetch));
+    fetchList.AppendElement(std::move(fetch));
   }
 
   RefPtr<Promise> promise = Promise::Create(mGlobal, aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return nullptr;
   }
 
   RefPtr<FetchHandler> handler =
     new FetchHandler(mActor->GetWorkerHolder(), this,
-                     Move(aRequestList), promise);
+                     std::move(aRequestList), promise);
 
   RefPtr<Promise> fetchPromise = Promise::All(aGlobal.Context(), fetchList, aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return nullptr;
   }
   fetchPromise->AppendNativeHandler(handler);
 
   return promise.forget();
--- a/dom/cache/CacheStorage.cpp
+++ b/dom/cache/CacheStorage.cpp
@@ -338,17 +338,17 @@ CacheStorage::Match(JSContext* aCx, cons
   CacheQueryParams params;
   ToCacheQueryParams(params, aOptions);
 
   nsAutoPtr<Entry> entry(new Entry());
   entry->mPromise = promise;
   entry->mArgs = StorageMatchArgs(CacheRequest(), params, GetOpenMode());
   entry->mRequest = request;
 
-  RunRequest(Move(entry));
+  RunRequest(std::move(entry));
 
   return promise.forget();
 }
 
 already_AddRefed<Promise>
 CacheStorage::Has(const nsAString& aKey, ErrorResult& aRv)
 {
   NS_ASSERT_OWNINGTHREAD(CacheStorage);
@@ -362,17 +362,17 @@ CacheStorage::Has(const nsAString& aKey,
   if (NS_WARN_IF(!promise)) {
     return nullptr;
   }
 
   nsAutoPtr<Entry> entry(new Entry());
   entry->mPromise = promise;
   entry->mArgs = StorageHasArgs(nsString(aKey));
 
-  RunRequest(Move(entry));
+  RunRequest(std::move(entry));
 
   return promise.forget();
 }
 
 already_AddRefed<Promise>
 CacheStorage::Open(const nsAString& aKey, ErrorResult& aRv)
 {
   NS_ASSERT_OWNINGTHREAD(CacheStorage);
@@ -386,17 +386,17 @@ CacheStorage::Open(const nsAString& aKey
   if (NS_WARN_IF(!promise)) {
     return nullptr;
   }
 
   nsAutoPtr<Entry> entry(new Entry());
   entry->mPromise = promise;
   entry->mArgs = StorageOpenArgs(nsString(aKey));
 
-  RunRequest(Move(entry));
+  RunRequest(std::move(entry));
 
   return promise.forget();
 }
 
 already_AddRefed<Promise>
 CacheStorage::Delete(const nsAString& aKey, ErrorResult& aRv)
 {
   NS_ASSERT_OWNINGTHREAD(CacheStorage);
@@ -410,17 +410,17 @@ CacheStorage::Delete(const nsAString& aK
   if (NS_WARN_IF(!promise)) {
     return nullptr;
   }
 
   nsAutoPtr<Entry> entry(new Entry());
   entry->mPromise = promise;
   entry->mArgs = StorageDeleteArgs(nsString(aKey));
 
-  RunRequest(Move(entry));
+  RunRequest(std::move(entry));
 
   return promise.forget();
 }
 
 already_AddRefed<Promise>
 CacheStorage::Keys(ErrorResult& aRv)
 {
   NS_ASSERT_OWNINGTHREAD(CacheStorage);
@@ -434,17 +434,17 @@ CacheStorage::Keys(ErrorResult& aRv)
   if (NS_WARN_IF(!promise)) {
     return nullptr;
   }
 
   nsAutoPtr<Entry> entry(new Entry());
   entry->mPromise = promise;
   entry->mArgs = StorageKeysArgs();
 
-  RunRequest(Move(entry));
+  RunRequest(std::move(entry));
 
   return promise.forget();
 }
 
 // static
 already_AddRefed<CacheStorage>
 CacheStorage::Constructor(const GlobalObject& aGlobal,
                           CacheStorageNamespace aNamespace,
@@ -542,17 +542,17 @@ CacheStorage::~CacheStorage()
   }
 }
 
 void
 CacheStorage::RunRequest(nsAutoPtr<Entry>&& aEntry)
 {
   MOZ_ASSERT(mActor);
 
-  nsAutoPtr<Entry> entry(Move(aEntry));
+  nsAutoPtr<Entry> entry(std::move(aEntry));
 
   AutoChildOpArgs args(this, entry->mArgs, 1);
 
   if (entry->mRequest) {
     ErrorResult rv;
     args.Add(entry->mRequest, IgnoreBody, IgnoreInvalidScheme, rv);
     if (NS_WARN_IF(rv.Failed())) {
       entry->mPromise->MaybeReject(rv);
--- a/dom/cache/CacheStreamControlChild.cpp
+++ b/dom/cache/CacheStreamControlChild.cpp
@@ -99,17 +99,17 @@ void
 CacheStreamControlChild::SerializeStream(CacheReadStream* aReadStreamOut,
                                          nsIInputStream* aStream,
                                          nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList)
 {
   NS_ASSERT_OWNINGTHREAD(CacheStreamControlChild);
   MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
   UniquePtr<AutoIPCStream> autoStream(new AutoIPCStream(aReadStreamOut->stream()));
   autoStream->Serialize(aStream, Manager());
-  aStreamCleanupList.AppendElement(Move(autoStream));
+  aStreamCleanupList.AppendElement(std::move(autoStream));
 }
 
 void
 CacheStreamControlChild::OpenStream(const nsID& aId, InputStreamResolver&& aResolver)
 {
   NS_ASSERT_OWNINGTHREAD(CacheStreamControlChild);
 
   if (mDestroyStarted) {
--- a/dom/cache/CacheStreamControlParent.cpp
+++ b/dom/cache/CacheStreamControlParent.cpp
@@ -63,17 +63,17 @@ CacheStreamControlParent::SerializeStrea
 {
   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
   MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
 
   UniquePtr<AutoIPCStream> autoStream(new AutoIPCStream(aReadStreamOut->stream()));
   DebugOnly<bool> ok = autoStream->Serialize(aStream, Manager());
   MOZ_ASSERT(ok);
 
-  aStreamCleanupList.AppendElement(Move(autoStream));
+  aStreamCleanupList.AppendElement(std::move(autoStream));
 }
 
 void
 CacheStreamControlParent::OpenStream(const nsID& aId,
                                      InputStreamResolver&& aResolver)
 {
   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
   MOZ_DIAGNOSTIC_ASSERT(aResolver);
@@ -82,17 +82,17 @@ CacheStreamControlParent::OpenStream(con
     aResolver(nullptr);
     return;
   }
 
   // Make sure to add ourself as a Listener even thought we are using
   // a separate resolver function to signal the completion of the
   // operation.  The Manager uses the existence of the Listener to ensure
   // that its safe to complete the operation.
-  mStreamList->GetManager()->ExecuteOpenStream(this, Move(aResolver), aId);
+  mStreamList->GetManager()->ExecuteOpenStream(this, std::move(aResolver), aId);
 }
 
 void
 CacheStreamControlParent::NoteClosedAfterForget(const nsID& aId)
 {
   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
   RecvNoteClosed(aId);
 }
--- a/dom/cache/Manager.cpp
+++ b/dom/cache/Manager.cpp
@@ -552,29 +552,29 @@ public:
 
     nsCOMPtr<nsIInputStream> stream;
     if (mArgs.openMode() == OpenMode::Eager) {
       rv = BodyOpen(aQuotaInfo, aDBDir, mResponse.mBodyId, getter_AddRefs(stream));
       if (NS_WARN_IF(NS_FAILED(rv))) { return rv; }
       if (NS_WARN_IF(!stream)) { return NS_ERROR_FILE_NOT_FOUND; }
     }
 
-    mStreamList->Add(mResponse.mBodyId, Move(stream));
+    mStreamList->Add(mResponse.mBodyId, std::move(stream));
 
     return rv;
   }
 
   virtual void
   Complete(Listener* aListener, ErrorResult&& aRv) override
   {
     if (!mFoundResponse) {
-      aListener->OnOpComplete(Move(aRv), CacheMatchResult(void_t()));
+      aListener->OnOpComplete(std::move(aRv), CacheMatchResult(void_t()));
     } else {
       mStreamList->Activate(mCacheId);
-      aListener->OnOpComplete(Move(aRv), CacheMatchResult(void_t()), mResponse,
+      aListener->OnOpComplete(std::move(aRv), CacheMatchResult(void_t()), mResponse,
                               mStreamList);
     }
     mStreamList = nullptr;
   }
 
   virtual bool MatchesCacheId(CacheId aCacheId) const override
   {
     return aCacheId == mCacheId;
@@ -620,27 +620,27 @@ public:
       nsCOMPtr<nsIInputStream> stream;
       if (mArgs.openMode() == OpenMode::Eager) {
         rv = BodyOpen(aQuotaInfo, aDBDir, mSavedResponses[i].mBodyId,
                       getter_AddRefs(stream));
         if (NS_WARN_IF(NS_FAILED(rv))) { return rv; }
         if (NS_WARN_IF(!stream)) { return NS_ERROR_FILE_NOT_FOUND; }
       }
 
-      mStreamList->Add(mSavedResponses[i].mBodyId, Move(stream));
+      mStreamList->Add(mSavedResponses[i].mBodyId, std::move(stream));
     }
 
     return rv;
   }
 
   virtual void
   Complete(Listener* aListener, ErrorResult&& aRv) override
   {
     mStreamList->Activate(mCacheId);
-    aListener->OnOpComplete(Move(aRv), CacheMatchAllResult(), mSavedResponses,
+    aListener->OnOpComplete(std::move(aRv), CacheMatchAllResult(), mSavedResponses,
                             mStreamList);
     mStreamList = nullptr;
   }
 
   virtual bool MatchesCacheId(CacheId aCacheId) const override
   {
     return aCacheId == mCacheId;
   }
@@ -1129,17 +1129,17 @@ public:
     }
 
     mManager->NoteOrphanedBodyIdList(mDeletedBodyIdList);
 
     if (mDeletedPaddingSize > 0) {
       DecreaseUsageForQuotaInfo(mQuotaInfo.ref(), mDeletedPaddingSize);
     }
 
-    aListener->OnOpComplete(Move(aRv), CacheDeleteResult(mSuccess));
+    aListener->OnOpComplete(std::move(aRv), CacheDeleteResult(mSuccess));
   }
 
   virtual bool MatchesCacheId(CacheId aCacheId) const override
   {
     return aCacheId == mCacheId;
   }
 
 private:
@@ -1184,27 +1184,27 @@ public:
       nsCOMPtr<nsIInputStream> stream;
       if (mArgs.openMode() == OpenMode::Eager) {
         rv = BodyOpen(aQuotaInfo, aDBDir, mSavedRequests[i].mBodyId,
                       getter_AddRefs(stream));
         if (NS_WARN_IF(NS_FAILED(rv))) { return rv; }
         if (NS_WARN_IF(!stream)) { return NS_ERROR_FILE_NOT_FOUND; }
       }
 
-      mStreamList->Add(mSavedRequests[i].mBodyId, Move(stream));
+      mStreamList->Add(mSavedRequests[i].mBodyId, std::move(stream));
     }
 
     return rv;
   }
 
   virtual void
   Complete(Listener* aListener, ErrorResult&& aRv) override
   {
     mStreamList->Activate(mCacheId);
-    aListener->OnOpComplete(Move(aRv), CacheKeysResult(), mSavedRequests,
+    aListener->OnOpComplete(std::move(aRv), CacheKeysResult(), mSavedRequests,
                             mStreamList);
     mStreamList = nullptr;
   }
 
   virtual bool MatchesCacheId(CacheId aCacheId) const override
   {
     return aCacheId == mCacheId;
   }
@@ -1250,29 +1250,29 @@ public:
     nsCOMPtr<nsIInputStream> stream;
     if (mArgs.openMode() == OpenMode::Eager) {
       rv = BodyOpen(aQuotaInfo, aDBDir, mSavedResponse.mBodyId,
                     getter_AddRefs(stream));
       if (NS_WARN_IF(NS_FAILED(rv))) { return rv; }
       if (NS_WARN_IF(!stream)) { return NS_ERROR_FILE_NOT_FOUND; }
     }
 
-    mStreamList->Add(mSavedResponse.mBodyId, Move(stream));
+    mStreamList->Add(mSavedResponse.mBodyId, std::move(stream));
 
     return rv;
   }
 
   virtual void
   Complete(Listener* aListener, ErrorResult&& aRv) override
   {
     if (!mFoundResponse) {
-      aListener->OnOpComplete(Move(aRv), StorageMatchResult(void_t()));
+      aListener->OnOpComplete(std::move(aRv), StorageMatchResult(void_t()));
     } else {
       mStreamList->Activate(mSavedResponse.mCacheId);
-      aListener->OnOpComplete(Move(aRv), StorageMatchResult(void_t()), mSavedResponse,
+      aListener->OnOpComplete(std::move(aRv), StorageMatchResult(void_t()), mSavedResponse,
                               mStreamList);
     }
     mStreamList = nullptr;
   }
 
 private:
   const Namespace mNamespace;
   const StorageMatchArgs mArgs;
@@ -1301,17 +1301,17 @@ public:
     CacheId cacheId;
     return db::StorageGetCacheId(aConn, mNamespace, mArgs.key(),
                                  &mCacheFound, &cacheId);
   }
 
   virtual void
   Complete(Listener* aListener, ErrorResult&& aRv) override
   {
-    aListener->OnOpComplete(Move(aRv), StorageHasResult(mCacheFound));
+    aListener->OnOpComplete(std::move(aRv), StorageHasResult(mCacheFound));
   }
 
 private:
   const Namespace mNamespace;
   const StorageHasArgs mArgs;
   bool mCacheFound;
 };
 
@@ -1358,17 +1358,17 @@ public:
     MOZ_DIAGNOSTIC_ASSERT(mCacheId != INVALID_CACHE_ID);
     return rv;
   }
 
   virtual void
   Complete(Listener* aListener, ErrorResult&& aRv) override
   {
     MOZ_DIAGNOSTIC_ASSERT(aRv.Failed() || mCacheId != INVALID_CACHE_ID);
-    aListener->OnOpComplete(Move(aRv),
+    aListener->OnOpComplete(std::move(aRv),
                             StorageOpenResult(nullptr, nullptr, mNamespace),
                             mCacheId);
   }
 
 private:
   const Namespace mNamespace;
   const StorageOpenArgs mArgs;
   CacheId mCacheId;
@@ -1434,17 +1434,17 @@ public:
           context->CancelForCacheId(mCacheId);
           RefPtr<Action> action =
             new DeleteOrphanedCacheAction(mManager, mCacheId);
           context->Dispatch(action);
         }
       }
     }
 
-    aListener->OnOpComplete(Move(aRv), StorageDeleteResult(mCacheDeleted));
+    aListener->OnOpComplete(std::move(aRv), StorageDeleteResult(mCacheDeleted));
   }
 
 private:
   const Namespace mNamespace;
   const StorageDeleteArgs mArgs;
   bool mCacheDeleted;
   CacheId mCacheId;
 };
@@ -1468,33 +1468,33 @@ public:
   }
 
   virtual void
   Complete(Listener* aListener, ErrorResult&& aRv) override
   {
     if (aRv.Failed()) {
       mKeys.Clear();
     }
-    aListener->OnOpComplete(Move(aRv), StorageKeysResult(mKeys));
+    aListener->OnOpComplete(std::move(aRv), StorageKeysResult(mKeys));
   }
 
 private:
   const Namespace mNamespace;
   nsTArray<nsString> mKeys;
 };
 
 // ----------------------------------------------------------------------------
 
 class Manager::OpenStreamAction final : public Manager::BaseAction
 {
 public:
   OpenStreamAction(Manager* aManager, ListenerId aListenerId,
                    InputStreamResolver&& aResolver, const nsID& aBodyId)
     : BaseAction(aManager, aListenerId)
-    , mResolver(Move(aResolver))
+    , mResolver(std::move(aResolver))
     , mBodyId(aBodyId)
   { }
 
   virtual nsresult
   RunSyncWithDBOnTarget(const QuotaInfo& aQuotaInfo, nsIFile* aDBDir,
                         mozIStorageConnection* aConn) override
   {
     nsresult rv = BodyOpen(aQuotaInfo, aDBDir, mBodyId,
@@ -1503,17 +1503,17 @@ public:
     if (NS_WARN_IF(!mBodyStream)) { return NS_ERROR_FILE_NOT_FOUND; }
 
     return rv;
   }
 
   virtual void
   Complete(Listener* aListener, ErrorResult&& aRv) override
   {
-    mResolver(Move(mBodyStream));
+    mResolver(std::move(mBodyStream));
     mResolver = nullptr;
   }
 
 private:
   InputStreamResolver mResolver;
   const nsID mBodyId;
   nsCOMPtr<nsIInputStream> mBodyStream;
 };
@@ -1521,54 +1521,54 @@ private:
 // ----------------------------------------------------------------------------
 
 //static
 Manager::ListenerId Manager::sNextListenerId = 0;
 
 void
 Manager::Listener::OnOpComplete(ErrorResult&& aRv, const CacheOpResult& aResult)
 {
-  OnOpComplete(Move(aRv), aResult, INVALID_CACHE_ID, nsTArray<SavedResponse>(),
+  OnOpComplete(std::move(aRv), aResult, INVALID_CACHE_ID, nsTArray<SavedResponse>(),
                nsTArray<SavedRequest>(), nullptr);
 }
 
 void
 Manager::Listener::OnOpComplete(ErrorResult&& aRv, const CacheOpResult& aResult,
                                 CacheId aOpenedCacheId)
 {
-  OnOpComplete(Move(aRv), aResult, aOpenedCacheId, nsTArray<SavedResponse>(),
+  OnOpComplete(std::move(aRv), aResult, aOpenedCacheId, nsTArray<SavedResponse>(),
                nsTArray<SavedRequest>(), nullptr);
 }
 
 void
 Manager::Listener::OnOpComplete(ErrorResult&& aRv, const CacheOpResult& aResult,
                                 const SavedResponse& aSavedResponse,
                                 StreamList* aStreamList)
 {
   AutoTArray<SavedResponse, 1> responseList;
   responseList.AppendElement(aSavedResponse);
-  OnOpComplete(Move(aRv), aResult, INVALID_CACHE_ID, responseList,
+  OnOpComplete(std::move(aRv), aResult, INVALID_CACHE_ID, responseList,
                nsTArray<SavedRequest>(), aStreamList);
 }
 
 void
 Manager::Listener::OnOpComplete(ErrorResult&& aRv, const CacheOpResult& aResult,
                                 const nsTArray<SavedResponse>& aSavedResponseList,
                                 StreamList* aStreamList)
 {
-  OnOpComplete(Move(aRv), aResult, INVALID_CACHE_ID, aSavedResponseList,
+  OnOpComplete(std::move(aRv), aResult, INVALID_CACHE_ID, aSavedResponseList,
                nsTArray<SavedRequest>(), aStreamList);
 }
 
 void
 Manager::Listener::OnOpComplete(ErrorResult&& aRv, const CacheOpResult& aResult,
                                 const nsTArray<SavedRequest>& aSavedRequestList,
                                 StreamList* aStreamList)
 {
-  OnOpComplete(Move(aRv), aResult, INVALID_CACHE_ID, nsTArray<SavedResponse>(),
+  OnOpComplete(std::move(aRv), aResult, INVALID_CACHE_ID, nsTArray<SavedResponse>(),
                aSavedRequestList, aStreamList);
 }
 
 // static
 nsresult
 Manager::GetOrCreate(ManagerId* aManagerId, Manager** aManagerOut)
 {
   mozilla::ipc::AssertIsOnBackgroundThread();
@@ -1904,17 +1904,17 @@ Manager::ExecuteOpenStream(Listener* aLi
 
   // We save the listener simply to track the existence of the caller here.
   // Our returned value will really be passed to the resolver when the
   // operation completes.  In the future we should remove the Listener
   // mechanism in favor of std::function or MozPromise.
   ListenerId listenerId = SaveListener(aListener);
 
   RefPtr<Action> action =
-    new OpenStreamAction(this, listenerId, Move(aResolver), aBodyId);
+    new OpenStreamAction(this, listenerId, std::move(aResolver), aBodyId);
 
   context->Dispatch(action);
 }
 
 void
 Manager::ExecutePutAll(Listener* aListener, CacheId aCacheId,
                        const nsTArray<CacheRequestResponse>& aPutList,
                        const nsTArray<nsCOMPtr<nsIInputStream>>& aRequestStreamList,
--- a/dom/cache/ReadStream.cpp
+++ b/dom/cache/ReadStream.cpp
@@ -529,17 +529,17 @@ ReadStream::Inner::AsyncOpenStreamOnOwni
   RefPtr<ReadStream::Inner> self = this;
   mControl->OpenStream(mId, [self](nsCOMPtr<nsIInputStream>&& aStream) {
     MutexAutoLock lock(self->mMutex);
     self->mAsyncOpenStarted = false;
     if (!self->mStream) {
       if (!aStream) {
         self->OpenStreamFailed();
       } else {
-        self->mStream = Move(aStream);
+        self->mStream = std::move(aStream);
         self->mSnappyStream = new SnappyUncompressInputStream(self->mStream);
       }
     }
     self->mCondVar.NotifyAll();
   });
 }
 
 void
--- a/dom/cache/StreamList.cpp
+++ b/dom/cache/StreamList.cpp
@@ -91,17 +91,17 @@ StreamList::Activate(CacheId aCacheId)
 }
 
 void
 StreamList::Add(const nsID& aId, nsCOMPtr<nsIInputStream>&& aStream)
 {
   // All streams should be added on IO thread before we set the stream
   // control on the owning IPC thread.
   MOZ_DIAGNOSTIC_ASSERT(!mStreamControl);
-  mList.AppendElement(Entry(aId, Move(aStream)));
+  mList.AppendElement(Entry(aId, std::move(aStream)));
 }
 
 already_AddRefed<nsIInputStream>
 StreamList::Extract(const nsID& aId)
 {
   NS_ASSERT_OWNINGTHREAD(StreamList);
   for (uint32_t i = 0; i < mList.Length(); ++i) {
     if (mList[i].mId == aId) {
--- a/dom/cache/StreamList.h
+++ b/dom/cache/StreamList.h
@@ -47,17 +47,17 @@ public:
   virtual bool MatchesCacheId(CacheId aCacheId) const override;
 
 private:
   ~StreamList();
   struct Entry
   {
     explicit Entry(const nsID& aId, nsCOMPtr<nsIInputStream>&& aStream)
       : mId(aId)
-      , mStream(Move(aStream))
+      , mStream(std::move(aStream))
     {}
 
     nsID mId;
     nsCOMPtr<nsIInputStream> mStream;
   };
   RefPtr<Manager> mManager;
   RefPtr<Context> mContext;
   CacheId mCacheId;
--- a/dom/cache/TypeUtils.cpp
+++ b/dom/cache/TypeUtils.cpp
@@ -277,17 +277,17 @@ TypeUtils::ToResponse(const CacheRespons
   ir->Headers()->Fill(*internalHeaders, result);
   MOZ_DIAGNOSTIC_ASSERT(!result.Failed());
   ir->Headers()->SetGuard(aIn.headersGuard(), result);
   MOZ_DIAGNOSTIC_ASSERT(!result.Failed());
 
   ir->InitChannelInfo(aIn.channelInfo());
   if (aIn.principalInfo().type() == mozilla::ipc::OptionalPrincipalInfo::TPrincipalInfo) {
     UniquePtr<mozilla::ipc::PrincipalInfo> info(new mozilla::ipc::PrincipalInfo(aIn.principalInfo().get_PrincipalInfo()));
-    ir->SetPrincipalInfo(Move(info));
+    ir->SetPrincipalInfo(std::move(info));
   }
 
   nsCOMPtr<nsIInputStream> stream = ReadStream::Create(aIn.body());
   ir->SetBody(stream, InternalResponse::UNKNOWN_BODY_SIZE);
 
   switch (aIn.type())
   {
     case ResponseType::Basic:
@@ -367,17 +367,17 @@ TypeUtils::ToInternalHeaders(const nsTAr
   nsTArray<InternalHeaders::Entry> entryList(aHeadersEntryList.Length());
 
   for (uint32_t i = 0; i < aHeadersEntryList.Length(); ++i) {
     const HeadersEntry& headersEntry = aHeadersEntryList[i];
     entryList.AppendElement(InternalHeaders::Entry(headersEntry.name(),
                                                    headersEntry.value()));
   }
 
-  RefPtr<InternalHeaders> ref = new InternalHeaders(Move(entryList), aGuard);
+  RefPtr<InternalHeaders> ref = new InternalHeaders(std::move(entryList), aGuard);
   return ref.forget();
 }
 
 // Utility function to remove the fragment from a URL, check its scheme, and optionally
 // provide a URL without the query.  We're not using nsIURL or URL to do this because
 // they require going to the main thread.
 // static
 void
@@ -505,14 +505,14 @@ TypeUtils::SerializeCacheStream(nsIInput
   CacheReadStream& cacheStream = aStreamOut->get_CacheReadStream();
 
   cacheStream.controlChild() = nullptr;
   cacheStream.controlParent() = nullptr;
 
   UniquePtr<AutoIPCStream> autoStream(new AutoIPCStream(cacheStream.stream()));
   autoStream->Serialize(aStream, GetIPCManager());
 
-  aStreamCleanupList.AppendElement(Move(autoStream));
+  aStreamCleanupList.AppendElement(std::move(autoStream));
 }
 
 } // namespace cache
 } // namespace dom
 } // namespace mozilla
--- a/dom/canvas/CacheMap.cpp
+++ b/dom/canvas/CacheMap.cpp
@@ -16,17 +16,17 @@ CacheMapInvalidator::InvalidateCaches() 
         pEntry->Invalidate();
         MOZ_ASSERT(mCacheEntries.find(pEntry) == mCacheEntries.end());
     }
 }
 
 namespace detail {
 
 CacheMapUntypedEntry::CacheMapUntypedEntry(std::vector<const CacheMapInvalidator*>&& invalidators)
-    : mInvalidators(Move(invalidators))
+    : mInvalidators(std::move(invalidators))
 {
     for (const auto& cur : mInvalidators) {
         // Don't assert that we insert, since there may be dupes in `invalidators`.
         // (and it's not worth removing the dupes)
         (void)cur->mCacheEntries.insert(this);
     }
 }
 
--- a/dom/canvas/CacheMap.h
+++ b/dom/canvas/CacheMap.h
@@ -65,20 +65,20 @@ class CacheMap final
     class Entry final : public detail::CacheMapUntypedEntry {
     public:
         CacheMap& mParent;
         const KeyT mKey;
         const ValueT mValue;
 
         Entry(std::vector<const CacheMapInvalidator*>&& invalidators, CacheMap& parent,
               KeyT&& key, ValueT&& value)
-            : detail::CacheMapUntypedEntry(Move(invalidators))
+            : detail::CacheMapUntypedEntry(std::move(invalidators))
             , mParent(parent)
-            , mKey(Move(key))
-            , mValue(Move(value))
+            , mKey(std::move(key))
+            , mValue(std::move(value))
         { }
 
         void Invalidate() const override {
             const auto erased = mParent.mMap.erase(&mKey);
             MOZ_ALWAYS_TRUE( erased == 1 );
         }
 
         bool operator <(const Entry& x) const {
@@ -88,26 +88,26 @@ class CacheMap final
 
     typedef std::map<const KeyT*, UniquePtr<const Entry>, detail::DerefLess> MapT;
     MapT mMap;
 
 public:
     const ValueT* Insert(KeyT&& key, ValueT&& value,
                          std::vector<const CacheMapInvalidator*>&& invalidators)
     {
-        UniquePtr<const Entry> entry( new Entry(Move(invalidators), *this, Move(key),
-                                                Move(value)) );
+        UniquePtr<const Entry> entry( new Entry(std::move(invalidators), *this, std::move(key),
+                                                std::move(value)) );
 
         typename MapT::value_type insertable{
             &entry->mKey,
             nullptr
         };
-        insertable.second = Move(entry);
+        insertable.second = std::move(entry);
 
-        const auto res = mMap.insert(Move(insertable));
+        const auto res = mMap.insert(std::move(insertable));
         const auto& didInsert = res.second;
         MOZ_ALWAYS_TRUE( didInsert );
 
         const auto& itr = res.first;
         return &itr->second->mValue;
     }
 
     const ValueT* Find(const KeyT& key) const {
--- a/dom/canvas/CanvasRenderingContext2D.cpp
+++ b/dom/canvas/CanvasRenderingContext2D.cpp
@@ -4636,17 +4636,17 @@ CanvasRenderingContext2D::SetLineDash(co
     for (uint32_t x = 0; x < aSegments.Length(); x++) {
       if (!dash.AppendElement(aSegments[x], fallible)) {
         aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
         return;
       }
     }
   }
 
-  CurrentState().dash = Move(dash);
+  CurrentState().dash = std::move(dash);
 }
 
 void
 CanvasRenderingContext2D::GetLineDash(nsTArray<double>& aSegments) const {
   const nsTArray<mozilla::gfx::Float>& dash = CurrentState().dash;
   aSegments.Clear();
 
   for (uint32_t x = 0; x < dash.Length(); x++) {
--- a/dom/canvas/CanvasRenderingContextHelper.cpp
+++ b/dom/canvas/CanvasRenderingContextHelper.cpp
@@ -102,17 +102,17 @@ CanvasRenderingContextHelper::ToBlob(JSC
     imageBuffer = mCurrentContext->GetImageBuffer(&format);
   }
 
   RefPtr<EncodeCompleteCallback> callback = aCallback;
 
   aRv = ImageEncoder::ExtractDataAsync(type,
                                        params,
                                        usingCustomParseOptions,
-                                       Move(imageBuffer),
+                                       std::move(imageBuffer),
                                        format,
                                        GetWidthHeight(),
                                        aUsePlaceholder,
                                        callback);
 }
 
 already_AddRefed<nsICanvasRenderingContextInternal>
 CanvasRenderingContextHelper::CreateContext(CanvasContextType aContextType)
--- a/dom/canvas/ImageBitmap.cpp
+++ b/dom/canvas/ImageBitmap.cpp
@@ -799,17 +799,17 @@ ImageBitmap::ToCloneData() const
   UniquePtr<ImageBitmapCloneData> result(new ImageBitmapCloneData());
   result->mPictureRect = mPictureRect;
   result->mAlphaType = mAlphaType;
   result->mIsCroppingAreaOutSideOfSourceImage = mIsCroppingAreaOutSideOfSourceImage;
   RefPtr<SourceSurface> surface = mData->GetAsSourceSurface();
   result->mSurface = surface->GetDataSurface();
   MOZ_ASSERT(result->mSurface);
 
-  return Move(result);
+  return std::move(result);
 }
 
 /* static */ already_AddRefed<ImageBitmap>
 ImageBitmap::CreateFromCloneData(nsIGlobalObject* aGlobal,
                                  ImageBitmapCloneData* aData)
 {
   RefPtr<layers::Image> data = CreateImageFromSurface(aData->mSurface);
 
@@ -1258,17 +1258,17 @@ private:
                             already_AddRefed<nsIInputStream> aInputStream,
                             const nsACString& aMimeType,
                             const Maybe<IntRect>& aCropRect,
                             nsIEventTarget* aMainThreadEventTarget)
     : CancelableRunnable("dom::CreateImageBitmapFromBlob")
     , mMutex("dom::CreateImageBitmapFromBlob::mMutex")
     , mPromise(aPromise)
     , mGlobalObject(aGlobal)
-    , mInputStream(Move(aInputStream))
+    , mInputStream(std::move(aInputStream))
     , mMimeType(aMimeType)
     , mCropRect(aCropRect)
     , mOriginalCropRect(aCropRect)
     , mMainThreadEventTarget(aMainThreadEventTarget)
     , mThread(GetCurrentVirtualThread())
   {
   }
 
@@ -2211,17 +2211,17 @@ CreateImageBitmapFromBlob::Create(Promis
 
   UniquePtr<CreateImageBitmapFromBlobHolder> holder(
     new CreateImageBitmapFromBlobHolder(workerPrivate, task));
 
   if (!holder->HoldWorker(workerPrivate, Terminating)) {
     return nullptr;
   }
 
-  task->mWorkerHolder = Move(holder);
+  task->mWorkerHolder = std::move(holder);
   return task.forget();
 }
 
 nsresult
 CreateImageBitmapFromBlob::StartDecodeAndCropBlob()
 {
   MOZ_ASSERT(IsCurrentThread());
 
--- a/dom/canvas/OffscreenCanvas.cpp
+++ b/dom/canvas/OffscreenCanvas.cpp
@@ -156,17 +156,17 @@ OffscreenCanvas::GetContext(JSContext* a
         gl::GLScreenBuffer* screen = gl->Screen();
         gl::SurfaceCaps caps = screen->mCaps;
         auto forwarder = mCanvasClient->GetForwarder();
 
         UniquePtr<gl::SurfaceFactory> factory =
           gl::GLScreenBuffer::CreateFactory(gl, caps, forwarder, flags);
 
         if (factory)
-          screen->Morph(Move(factory));
+          screen->Morph(std::move(factory));
       }
     }
   }
 
   return result;
 }
 
 already_AddRefed<nsICanvasRenderingContextInternal>
--- a/dom/canvas/TexUnpackBlob.cpp
+++ b/dom/canvas/TexUnpackBlob.cpp
@@ -386,17 +386,17 @@ TexUnpackBlob::ConvertIfNeeded(WebGLCont
                       dstBegin, dstStride, dstOrigin, dstFormat, dstIsPremult,
                       &wasTrivial))
     {
         webgl->ErrorImplementationBug("%s: ConvertImage failed.", funcName);
         return false;
     }
 
     *out_begin = dstBegin;
-    *out_anchoredBuffer = Move(dstBuffer);
+    *out_anchoredBuffer = std::move(dstBuffer);
     return true;
 }
 
 static GLenum
 DoTexOrSubImage(bool isSubImage, gl::GLContext* gl, TexImageTarget target, GLint level,
                 const DriverUnpackInfo* dui, GLint xOffset, GLint yOffset, GLint zOffset,
                 GLsizei width, GLsizei height, GLsizei depth, const void* data)
 {
--- a/dom/canvas/WebGLBuffer.cpp
+++ b/dom/canvas/WebGLBuffer.cpp
@@ -152,17 +152,17 @@ WebGLBuffer::BufferData(GLenum target, s
         gl->fBufferData(target, size, uploadData, usage);
     }
 
     mContext->OnDataAllocCall();
 
     mUsage = usage;
     mByteLength = size;
     mFetchInvalidator.InvalidateCaches();
-    mIndexCache = Move(newIndexCache);
+    mIndexCache = std::move(newIndexCache);
 
     if (mIndexCache) {
         if (!mIndexRanges.empty()) {
             mContext->GeneratePerfWarning("[%p] Invalidating %u ranges.", this,
                                           uint32_t(mIndexRanges.size()));
             mIndexRanges.clear();
         }
     }
--- a/dom/canvas/WebGLFormats.cpp
+++ b/dom/canvas/WebGLFormats.cpp
@@ -822,17 +822,17 @@ FormatUsageAuthority::CreateForWebGL1(gl
     ptr->AllowRBFormat(LOCAL_GL_DEPTH_STENCIL,
                        ptr->GetUsage(EffectiveFormat::DEPTH24_STENCIL8));
 
     ////////////////////////////////////////////////////////////////////////////
 
     if (!AddUnsizedFormats(ptr, gl))
         return nullptr;
 
-    return Move(ret);
+    return std::move(ret);
 }
 
 UniquePtr<FormatUsageAuthority>
 FormatUsageAuthority::CreateForWebGL2(gl::GLContext* gl)
 {
     UniquePtr<FormatUsageAuthority> ret(new FormatUsageAuthority);
     const auto ptr = ret.get();
 
@@ -1057,17 +1057,17 @@ FormatUsageAuthority::CreateForWebGL2(gl
         AddSimpleUnsized(ptr, LOCAL_GL_RGB , LOCAL_GL_FLOAT, EffectiveFormat::RGB32F );
 
         AddSimpleUnsized(ptr, LOCAL_GL_RGBA, LOCAL_GL_HALF_FLOAT_OES, EffectiveFormat::RGBA16F);
         AddSimpleUnsized(ptr, LOCAL_GL_RGB , LOCAL_GL_HALF_FLOAT_OES, EffectiveFormat::RGB16F );
     }
 
     ////////////////////////////////////
 
-    return Move(ret);
+    return std::move(ret);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
 void
 FormatUsageAuthority::AddTexUnpack(FormatUsageInfo* usage, const PackingInfo& pi,
                                    const DriverUnpackInfo& dui)
 {
--- a/dom/canvas/WebGLProgram.cpp
+++ b/dom/canvas/WebGLProgram.cpp
@@ -549,17 +549,17 @@ webgl::LinkedProgramInfo::GetDrawFetchLi
         webgl->ErrorInvalidOperation("%s: One active vertex attrib (if any are active)"
                                      " must have a divisor of 0.",
                                      funcName);
         return nullptr;
     }
 
     // --
 
-    return mDrawFetchCache.Insert(vao.get(), Move(fetchLimits), Move(cacheDeps));
+    return mDrawFetchCache.Insert(vao.get(), std::move(fetchLimits), std::move(cacheDeps));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebGLProgram
 
 WebGLProgram::WebGLProgram(WebGLContext* webgl)
     : WebGLRefCountedObject(webgl)
     , mGLName(webgl->gl->fCreateProgram())
--- a/dom/canvas/WebGLTextureUpload.cpp
+++ b/dom/canvas/WebGLTextureUpload.cpp
@@ -222,17 +222,17 @@ FromPboOffset(WebGLContext* webgl, const
                                              isClientData, ptr, availBufferBytes);
 }
 
 static UniquePtr<webgl::TexUnpackBlob>
 FromImageBitmap(WebGLContext* webgl, const char* funcName, TexImageTarget target,
                 uint32_t width, uint32_t height, uint32_t depth,
                 const dom::ImageBitmap& imageBitmap)
 {
-    UniquePtr<dom::ImageBitmapCloneData> cloneData = Move(imageBitmap.ToCloneData());
+    UniquePtr<dom::ImageBitmapCloneData> cloneData = std::move(imageBitmap.ToCloneData());
     if (!cloneData) {
       return nullptr;
     }
 
     const RefPtr<gfx::DataSourceSurface> surf = cloneData->mSurface;
 
     if (!width) {
         width = surf->GetSize().width;
@@ -455,17 +455,17 @@ ValidateTexOrSubImage(WebGLContext* webg
     if (!ValidateViewType(webgl, funcName, pi.type, src))
         return nullptr;
 
     auto blob = webgl->From(funcName, target, rawWidth, rawHeight, rawDepth, border, src,
                             scopedArr);
     if (!blob || !blob->Validate(webgl, funcName, pi))
         return nullptr;
 
-    return Move(blob);
+    return std::move(blob);
 }
 
 void
 WebGLTexture::TexImage(const char* funcName, TexImageTarget target, GLint level,
                        GLenum internalFormat, GLsizei width, GLsizei height,
                        GLsizei depth, GLint border, const webgl::PackingInfo& pi,
                        const TexImageSource& src)
 {
--- a/dom/canvas/WebGLTypes.h
+++ b/dom/canvas/WebGLTypes.h
@@ -209,15 +209,15 @@ public:
         this->mBuffer = newBuffer;
         return *this;
     }
 
     explicit operator bool() const { return bool(mBuffer); }
 
     void* get() const { return mBuffer; }
 
-    UniqueBuffer(const UniqueBuffer& other) = delete; // construct using Move()!
-    void operator =(const UniqueBuffer& other) = delete; // assign using Move()!
+    UniqueBuffer(const UniqueBuffer& other) = delete; // construct using std::move()!
+    void operator =(const UniqueBuffer& other) = delete; // assign using std::move()!
 };
 
 } // namespace mozilla
 
 #endif
--- a/dom/clients/api/Clients.cpp
+++ b/dom/clients/api/Clients.cpp
@@ -89,17 +89,17 @@ Clients::Get(const nsAString& aClientID,
 
   innerPromise->Then(target, __func__,
     [outerPromise, holder, scope] (const ClientOpResult& aResult) {
       holder->Complete();
       NS_ENSURE_TRUE_VOID(holder->GetParentObject());
       RefPtr<Client> client = new Client(holder->GetParentObject(),
                                          aResult.get_ClientInfoAndState());
       if (client->GetStorageAccess() == nsContentUtils::StorageAccess::eAllow) {
-        outerPromise->MaybeResolve(Move(client));
+        outerPromise->MaybeResolve(std::move(client));
         return;
       }
       nsCOMPtr<nsIRunnable> r =
         NS_NewRunnableFunction("Clients::Get() storage denied",
         [scope] {
           ServiceWorkerManager::LocalizeAndReportToAllClients(
             scope, "ServiceWorkerGetClientStorageError", nsTArray<nsString>());
         });
@@ -175,17 +175,17 @@ Clients::MatchAll(const ClientQueryOptio
       nsTArray<RefPtr<Client>> clientList;
       bool storageDenied = false;
       for (const ClientInfoAndState& value : aResult.get_ClientList().values()) {
         RefPtr<Client> client = new Client(global, value);
         if (client->GetStorageAccess() != nsContentUtils::StorageAccess::eAllow) {
           storageDenied = true;
           continue;
         }
-        clientList.AppendElement(Move(client));
+        clientList.AppendElement(std::move(client));
       }
       if (storageDenied) {
         nsCOMPtr<nsIRunnable> r =
           NS_NewRunnableFunction("Clients::MatchAll() storage denied",
           [scope] {
             ServiceWorkerManager::LocalizeAndReportToAllClients(
               scope, "ServiceWorkerGetClientStorageError", nsTArray<nsString>());
           });
--- a/dom/clients/manager/ClientChannelHelper.cpp
+++ b/dom/clients/manager/ClientChannelHelper.cpp
@@ -73,17 +73,17 @@ class ClientChannelHelper final : public
     }
 
     UniquePtr<ClientSource> reservedClient = oldLoadInfo->TakeReservedClientSource();
 
     // If its a same-origin redirect we just move our reserved client to the
     // new channel.
     if (NS_SUCCEEDED(rv)) {
       if (reservedClient) {
-        newLoadInfo->GiveReservedClientSource(Move(reservedClient));
+        newLoadInfo->GiveReservedClientSource(std::move(reservedClient));
       }
 
       // It seems sometimes necko passes two channels with the same LoadInfo.
       // We only need to move the reserved/initial ClientInfo over if we
       // actually have a different LoadInfo.
       else if (oldLoadInfo != newLoadInfo) {
         const Maybe<ClientInfo>& reservedClientInfo =
           oldLoadInfo->GetReservedClientInfo();
@@ -118,17 +118,17 @@ class ClientChannelHelper final : public
       // Create the new ClientSource.  This should only happen for window
       // Clients since support cross-origin redirects are blocked by the
       // same-origin security policy.
       reservedClient.reset();
       reservedClient = ClientManager::CreateSource(ClientType::Window,
                                                    mEventTarget, principal);
       MOZ_DIAGNOSTIC_ASSERT(reservedClient);
 
-      newLoadInfo->GiveReservedClientSource(Move(reservedClient));
+      newLoadInfo->GiveReservedClientSource(std::move(reservedClient));
     }
 
     uint32_t redirectMode = nsIHttpChannelInternal::REDIRECT_MODE_MANUAL;
     nsCOMPtr<nsIHttpChannelInternal> http = do_QueryInterface(aOldChannel);
     if (http) {
       MOZ_ALWAYS_SUCCEEDS(http->GetRedirectMode(&redirectMode));
     }
 
@@ -178,18 +178,18 @@ NS_IMPL_ISUPPORTS(ClientChannelHelper, n
 nsresult
 AddClientChannelHelper(nsIChannel* aChannel,
                        Maybe<ClientInfo>&& aReservedClientInfo,
                        Maybe<ClientInfo>&& aInitialClientInfo,
                        nsISerialEventTarget* aEventTarget)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
-  Maybe<ClientInfo> initialClientInfo(Move(aInitialClientInfo));
-  Maybe<ClientInfo> reservedClientInfo(Move(aReservedClientInfo));
+  Maybe<ClientInfo> initialClientInfo(std::move(aInitialClientInfo));
+  Maybe<ClientInfo> reservedClientInfo(std::move(aReservedClientInfo));
   MOZ_DIAGNOSTIC_ASSERT(reservedClientInfo.isNothing() ||
                         initialClientInfo.isNothing());
 
   nsCOMPtr<nsILoadInfo> loadInfo = aChannel->GetLoadInfo();
   NS_ENSURE_TRUE(loadInfo, NS_ERROR_FAILURE);
 
   nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
   NS_ENSURE_TRUE(ssm, NS_ERROR_FAILURE);
@@ -248,17 +248,17 @@ AddClientChannelHelper(nsIChannel* aChan
   // Only set the callbacks helper if we are able to reserve the client
   // successfully.
   rv = aChannel->SetNotificationCallbacks(helper);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Finally preserve the various client values on the nsILoadInfo once the
   // redirect helper has been added to the channel.
   if (reservedClient) {
-    loadInfo->GiveReservedClientSource(Move(reservedClient));
+    loadInfo->GiveReservedClientSource(std::move(reservedClient));
   }
 
   if (initialClientInfo.isSome()) {
     loadInfo->SetInitialClientInfo(initialClientInfo.ref());
   }
 
   if (reservedClientInfo.isSome()) {
     loadInfo->SetReservedClientInfo(reservedClientInfo.ref());
--- a/dom/clients/manager/ClientHandle.cpp
+++ b/dom/clients/manager/ClientHandle.cpp
@@ -44,21 +44,21 @@ ClientHandle::StartOp(const ClientOpCons
                       const ClientOpCallback&& aRejectCallback)
 {
   // Hold a ref to the client until the remote operation completes.  Otherwise
   // the ClientHandle might get de-refed and teardown the actor before we
   // get an answer.
   RefPtr<ClientHandle> kungFuGrip = this;
 
   MaybeExecute([aArgs, kungFuGrip, aRejectCallback,
-                resolve = Move(aResolveCallback)] (ClientHandleChild* aActor) {
+                resolve = std::move(aResolveCallback)] (ClientHandleChild* aActor) {
     MOZ_RELEASE_ASSERT(aActor);
     ClientHandleOpChild* actor =
-      new ClientHandleOpChild(kungFuGrip, aArgs, Move(resolve),
-                              Move(aRejectCallback));
+      new ClientHandleOpChild(kungFuGrip, aArgs, std::move(resolve),
+                              std::move(aRejectCallback));
     if (!aActor->SendPClientHandleOpConstructor(actor, aArgs)) {
       // Constructor failure will call reject callback via ActorDestroy()
       return;
     }
   }, [aRejectCallback] {
     MOZ_RELEASE_ASSERT(aRejectCallback);
     aRejectCallback(NS_ERROR_DOM_INVALID_STATE_ERR);
   });
@@ -198,13 +198,13 @@ ClientHandle::OnDetach()
   if (!mDetachPromise) {
     mDetachPromise = new GenericPromise::Private(__func__);
     if (IsShutdown()) {
       mDetachPromise->Resolve(true, __func__);
     }
   }
 
   RefPtr<GenericPromise> ref(mDetachPromise);
-  return Move(ref);
+  return std::move(ref);
 }
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/clients/manager/ClientHandleOpChild.cpp
+++ b/dom/clients/manager/ClientHandleOpChild.cpp
@@ -31,18 +31,18 @@ ClientHandleOpChild::Recv__delete__(cons
   return IPC_OK();
 }
 
 ClientHandleOpChild::ClientHandleOpChild(ClientHandle* aClientHandle,
                                          const ClientOpConstructorArgs& aArgs,
                                          const ClientOpCallback&& aResolveCallback,
                                          const ClientOpCallback&& aRejectCallback)
   : mClientHandle(aClientHandle)
-  , mResolveCallback(Move(aResolveCallback))
-  , mRejectCallback(Move(aRejectCallback))
+  , mResolveCallback(std::move(aResolveCallback))
+  , mRejectCallback(std::move(aRejectCallback))
 {
   MOZ_RELEASE_ASSERT(mClientHandle);
   MOZ_RELEASE_ASSERT(mResolveCallback);
   MOZ_RELEASE_ASSERT(mRejectCallback);
 }
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/clients/manager/ClientInfo.cpp
+++ b/dom/clients/manager/ClientInfo.cpp
@@ -39,25 +39,25 @@ ClientInfo&
 ClientInfo::operator=(const ClientInfo& aRight)
 {
   mData.reset();
   mData = MakeUnique<IPCClientInfo>(*aRight.mData);
   return *this;
 }
 
 ClientInfo::ClientInfo(ClientInfo&& aRight)
-  : mData(Move(aRight.mData))
+  : mData(std::move(aRight.mData))
 {
 }
 
 ClientInfo&
 ClientInfo::operator=(ClientInfo&& aRight)
 {
   mData.reset();
-  mData = Move(aRight.mData);
+  mData = std::move(aRight.mData);
   return *this;
 }
 
 ClientInfo::~ClientInfo()
 {
 }
 
 const nsID&
@@ -140,13 +140,13 @@ ClientInfo::IsPrivateBrowsing() const
   }
 }
 
 nsCOMPtr<nsIPrincipal>
 ClientInfo::GetPrincipal() const
 {
   MOZ_ASSERT(NS_IsMainThread());
   nsCOMPtr<nsIPrincipal> ref = PrincipalInfoToPrincipal(PrincipalInfo());
-  return Move(ref);
+  return std::move(ref);
 }
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/clients/manager/ClientManager.cpp
+++ b/dom/clients/manager/ClientManager.cpp
@@ -122,30 +122,30 @@ ClientManager::CreateSourceInternal(Clie
   if (NS_WARN_IF(NS_FAILED(rv))) {
     // If we can't even get a UUID, at least make sure not to use a garbage
     // value.  Instead return a shutdown ClientSource with a zero'd id.
     // This should be exceptionally rare, if it happens at all.
     id.Clear();
     ClientSourceConstructorArgs args(id, aType, aPrincipal, TimeStamp::Now());
     UniquePtr<ClientSource> source(new ClientSource(this, aEventTarget, args));
     source->Shutdown();
-    return Move(source);
+    return std::move(source);
   }
 
   ClientSourceConstructorArgs args(id, aType, aPrincipal, TimeStamp::Now());
   UniquePtr<ClientSource> source(new ClientSource(this, aEventTarget, args));
 
   if (IsShutdown()) {
     source->Shutdown();
-    return Move(source);
+    return std::move(source);
   }
 
   source->Activate(GetActor());
 
-  return Move(source);
+  return std::move(source);
 }
 
 already_AddRefed<ClientHandle>
 ClientManager::CreateHandleInternal(const ClientInfo& aClientInfo,
                                     nsISerialEventTarget* aSerialEventTarget)
 {
   NS_ASSERT_OWNINGTHREAD(ClientManager);
   MOZ_DIAGNOSTIC_ASSERT(aSerialEventTarget);
--- a/dom/clients/manager/ClientManagerService.cpp
+++ b/dom/clients/manager/ClientManagerService.cpp
@@ -358,17 +358,17 @@ public:
 
     RefPtr<ClientOpPromise> ref = mResultPromise;
     return ref.forget();
   }
 
   void
   AddPromise(RefPtr<ClientOpPromise>&& aPromise)
   {
-    mPromiseList.AppendElement(Move(aPromise));
+    mPromiseList.AppendElement(std::move(aPromise));
     MOZ_DIAGNOSTIC_ASSERT(mPromiseList.LastElement());
     mOutstandingPromiseCount += 1;
 
     RefPtr<PromiseListHolder> self(this);
     mPromiseList.LastElement()->Then(
       GetCurrentThreadSerialEventTarget(), __func__,
       [self] (const ClientOpResult& aResult) {
         // TODO: This is pretty clunky.  Try to figure out a better
@@ -433,17 +433,17 @@ ClientManagerService::MatchAll(const Cli
 
       if(controller.ref().Id() != swd.Id() ||
          controller.ref().Scope() != swd.Scope()) {
         continue;
       }
     }
 
     promiseList->AddPromise(
-      source->StartOp(Move(ClientGetInfoAndStateArgs(source->Info().Id(),
+      source->StartOp(std::move(ClientGetInfoAndStateArgs(source->Info().Id(),
                                                      source->Info().PrincipalInfo()))));
   }
 
   // Maybe finish the promise now in case we didn't find any matching clients.
   promiseList->MaybeFinish();
 
   return promiseList->GetResultPromise();
 }
@@ -590,17 +590,17 @@ public:
 RefPtr<ClientOpPromise>
 ClientManagerService::OpenWindow(const ClientOpenWindowArgs& aArgs,
                                  already_AddRefed<ContentParent> aSourceProcess)
 {
   RefPtr<ClientOpPromise::Private> promise =
     new ClientOpPromise::Private(__func__);
 
   nsCOMPtr<nsIRunnable> r = new OpenWindowRunnable(promise, aArgs,
-                                                   Move(aSourceProcess));
+                                                   std::move(aSourceProcess));
   MOZ_ALWAYS_SUCCEEDS(SystemGroup::Dispatch(TaskCategory::Other,
                                             r.forget()));
 
   RefPtr<ClientOpPromise> ref = promise;
   return ref.forget();
 }
 
 } // namespace dom
--- a/dom/clients/manager/ClientSourceParent.cpp
+++ b/dom/clients/manager/ClientSourceParent.cpp
@@ -32,17 +32,17 @@ namespace {
 // the main thread.
 class KillContentParentRunnable final : public Runnable
 {
   RefPtr<ContentParent> mContentParent;
 
 public:
   explicit KillContentParentRunnable(RefPtr<ContentParent>&& aContentParent)
     : Runnable("KillContentParentRunnable")
-    , mContentParent(Move(aContentParent))
+    , mContentParent(std::move(aContentParent))
   {
     MOZ_ASSERT(mContentParent);
   }
 
   NS_IMETHOD
   Run() override
   {
     MOZ_ASSERT(NS_IsMainThread());
@@ -74,17 +74,17 @@ ClientSourceParent::KillInvalidChild()
     return;
   }
 
   // In e10s mode we also want to kill the child process.  Validation failures
   // typically mean someone sent us bogus data over the IPC link.  We can't
   // trust that process any more.  We have to do this on the main thread, so
   // there is a small window of time before we kill the process.  This is why
   // we start the actor destruction immediately above.
-  nsCOMPtr<nsIRunnable> r = new KillContentParentRunnable(Move(process));
+  nsCOMPtr<nsIRunnable> r = new KillContentParentRunnable(std::move(process));
   MOZ_ALWAYS_SUCCEEDS(SystemGroup::Dispatch(TaskCategory::Other, r.forget()));
 }
 
 mozilla::ipc::IPCResult
 ClientSourceParent::RecvWorkerSyncPing()
 {
   AssertIsOnBackgroundThread();
   // Do nothing here.  This is purely a sync message allowing the child to
--- a/dom/clients/manager/ClientState.cpp
+++ b/dom/clients/manager/ClientState.cpp
@@ -26,33 +26,33 @@ ClientWindowState::ClientWindowState(con
 }
 
 ClientWindowState::ClientWindowState(const ClientWindowState& aRight)
 {
   operator=(aRight);
 }
 
 ClientWindowState::ClientWindowState(ClientWindowState&& aRight)
-  : mData(Move(aRight.mData))
+  : mData(std::move(aRight.mData))
 {
 }
 
 ClientWindowState&
 ClientWindowState::operator=(const ClientWindowState& aRight)
 {
   mData.reset();
   mData = MakeUnique<IPCClientWindowState>(*aRight.mData);
   return *this;
 }
 
 ClientWindowState&
 ClientWindowState::operator=(ClientWindowState&& aRight)
 {
   mData.reset();
-  mData = Move(aRight.mData);
+  mData = std::move(aRight.mData);
   return *this;
 }
 
 ClientWindowState::~ClientWindowState()
 {
 }
 
 mozilla::dom::VisibilityState
@@ -91,17 +91,17 @@ ClientWorkerState::ClientWorkerState(nsC
 }
 
 ClientWorkerState::ClientWorkerState(const IPCClientWorkerState& aData)
   : mData(MakeUnique<IPCClientWorkerState>(aData))
 {
 }
 
 ClientWorkerState::ClientWorkerState(ClientWorkerState&& aRight)
-  : mData(Move(aRight.mData))
+  : mData(std::move(aRight.mData))
 {
 }
 
 ClientWorkerState::ClientWorkerState(const ClientWorkerState& aRight)
 {
   operator=(aRight);
 }
 
@@ -112,17 +112,17 @@ ClientWorkerState::operator=(const Clien
   mData = MakeUnique<IPCClientWorkerState>(*aRight.mData);
   return *this;
 }
 
 ClientWorkerState&
 ClientWorkerState::operator=(ClientWorkerState&& aRight)
 {
   mData.reset();
-  mData = Move(aRight.mData);
+  mData = std::move(aRight.mData);
   return *this;
 }
 
 ClientWorkerState::~ClientWorkerState()
 {
 }
 
 nsContentUtils::StorageAccess
@@ -157,24 +157,24 @@ ClientState::ClientState(const IPCClient
 }
 
 ClientState::ClientState(const IPCClientWorkerState& aData)
 {
   mData.emplace(AsVariant(ClientWorkerState(aData)));
 }
 
 ClientState::ClientState(ClientState&& aRight)
-  : mData(Move(aRight.mData))
+  : mData(std::move(aRight.mData))
 {
 }
 
 ClientState&
 ClientState::operator=(ClientState&& aRight)
 {
-  mData = Move(aRight.mData);
+  mData = std::move(aRight.mData);
   return *this;
 }
 
 ClientState::~ClientState()
 {
 }
 
 // static
--- a/dom/console/Console.cpp
+++ b/dom/console/Console.cpp
@@ -1577,17 +1577,17 @@ Console::MethodInternal(JSContext* aCx, 
     oa = workerPrivate->GetOriginAttributes();
   }
 
   callData->SetOriginAttributes(oa);
 
   JS::StackCapture captureMode = ShouldIncludeStackTrace(aMethodName) ?
     JS::StackCapture(JS::MaxFrames(DEFAULT_MAX_STACKTRACE_DEPTH)) :
     JS::StackCapture(JS::FirstSubsumedFrame(aCx));
-  nsCOMPtr<nsIStackFrame> stack = CreateStack(aCx, mozilla::Move(captureMode));
+  nsCOMPtr<nsIStackFrame> stack = CreateStack(aCx, std::move(captureMode));
 
   if (stack) {
     callData->mTopStackFrame.emplace();
     StackFrameToStackEntry(aCx, stack, *callData->mTopStackFrame);
   }
 
   if (NS_IsMainThread()) {
     callData->mStack = stack;
@@ -2882,33 +2882,33 @@ Console::MonotonicTimer(JSContext* aCx, 
         return false;
       }
 
       nsAutoJSString key;
       if (!key.init(aCx, jsString)) {
         return false;
       }
 
-      timelines->AddMarkerForDocShell(docShell, Move(
+      timelines->AddMarkerForDocShell(docShell, std::move(
         MakeUnique<TimestampTimelineMarker>(key)));
     }
     // For `console.time(foo)` and `console.timeEnd(foo)`.
     else if (isTimelineRecording && aData.Length() == 1) {
       JS::Rooted<JS::Value> value(aCx, aData[0]);
       JS::Rooted<JSString*> jsString(aCx, JS::ToString(aCx, value));
       if (!jsString) {
         return false;
       }
 
       nsAutoJSString key;
       if (!key.init(aCx, jsString)) {
         return false;
       }
 
-      timelines->AddMarkerForDocShell(docShell, Move(
+      timelines->AddMarkerForDocShell(docShell, std::move(
         MakeUnique<ConsoleTimelineMarker>(
           key, aMethodName == MethodTime ? MarkerTracingType::START
                                          : MarkerTracingType::END)));
     }
 
     return true;
   }
 
--- a/dom/events/EventDispatcher.cpp
+++ b/dom/events/EventDispatcher.cpp
@@ -217,17 +217,17 @@ public:
 
   void SetRetargetedRelatedTarget(EventTarget* aTarget)
   {
     mRetargetedRelatedTarget = aTarget;
   }
 
   void SetRetargetedTouchTarget(Maybe<nsTArray<RefPtr<EventTarget>>>&& aTargets)
   {
-    mRetargetedTouchTargets = Move(aTargets);
+    mRetargetedTouchTargets = std::move(aTargets);
   }
 
   bool HasRetargetTouchTargets()
   {
     return mRetargetedTouchTargets.isSome() || mInitialTargetTouches.isSome();
   }
 
   void RetargetTouchTargets(WidgetTouchEvent* aTouchEvent, Event* aDOMEvent)
@@ -261,17 +261,17 @@ public:
         }
       }
     }
   }
 
   void SetInitialTargetTouches(Maybe<nsTArray<RefPtr<dom::Touch>>>&&
                                  aInitialTargetTouches)
   {
-    mInitialTargetTouches = Move(aInitialTargetTouches);
+    mInitialTargetTouches = std::move(aInitialTargetTouches);
   }
 
   void SetForceContentDispatch(bool aForce)
   {
     mFlags.mForceContentDispatch = aForce;
   }
 
   bool ForceContentDispatch()
@@ -479,17 +479,17 @@ EventTargetChainItem::GetEventTargetPare
   mTarget->GetEventTargetParent(aVisitor);
   SetForceContentDispatch(aVisitor.mForceContentDispatch);
   SetWantsWillHandleEvent(aVisitor.mWantsWillHandleEvent);
   SetMayHaveListenerManager(aVisitor.mMayHaveListenerManager);
   SetWantsPreHandleEvent(aVisitor.mWantsPreHandleEvent);
   SetPreHandleEventOnly(aVisitor.mWantsPreHandleEvent && !aVisitor.mCanHandle);
   SetRootOfClosedTree(aVisitor.mRootOfClosedTree);
   SetRetargetedRelatedTarget(aVisitor.mRetargetedRelatedTarget);
-  SetRetargetedTouchTarget(Move(aVisitor.mRetargetedTouchTargets));
+  SetRetargetedTouchTarget(std::move(aVisitor.mRetargetedTouchTargets));
   mItemFlags = aVisitor.mItemFlags;
   mItemData = aVisitor.mItemData;
 }
 
 void
 EventTargetChainItem::PreHandleEvent(EventChainVisitor& aVisitor)
 {
   if (!WantsPreHandleEvent()) {
@@ -1004,17 +1004,17 @@ EventDispatcher::Dispatch(nsISupports* a
       TouchEvent* touchEvent = static_cast<TouchEvent*>(aDOMEvent);
       TouchList* targetTouches = touchEvent->GetExistingTargetTouches();
       if (targetTouches) {
         Maybe<nsTArray<RefPtr<dom::Touch>>> initialTargetTouches;
         initialTargetTouches.emplace();
         for (uint32_t i = 0; i < targetTouches->Length(); ++i) {
           initialTargetTouches->AppendElement(targetTouches->Item(i));
         }
-        targetEtci->SetInitialTargetTouches(Move(initialTargetTouches));
+        targetEtci->SetInitialTargetTouches(std::move(initialTargetTouches));
         targetTouches->Clear();
       }
     }
     EventTargetChainItem* topEtci = targetEtci;
     targetEtci = nullptr;
     while (preVisitor.GetParentTarget()) {
       EventTarget* parentTarget = preVisitor.GetParentTarget();
       EventTargetChainItem* parentEtci =
--- a/dom/events/EventListenerManager.cpp
+++ b/dom/events/EventListenerManager.cpp
@@ -296,17 +296,17 @@ EventListenerManager::AddEventListenerIn
   if (aFlags.mListenerIsJSListener) {
     MOZ_ASSERT(!aListenerHolder.HasWebIDLCallback());
     listener->mListenerType = Listener::eJSEventListener;
   } else if (aListenerHolder.HasWebIDLCallback()) {
     listener->mListenerType = Listener::eWebIDLListener;
   } else {
     listener->mListenerType = Listener::eNativeListener;
   }
-  listener->mListener = Move(aListenerHolder);
+  listener->mListener = std::move(aListenerHolder);
 
 
   if (aFlags.mInSystemGroup) {
     mMayHaveSystemGroupListeners = true;
   }
   if (aFlags.mCapture) {
     mMayHaveCapturingListeners = true;
   }
@@ -726,32 +726,32 @@ EventListenerManager::AddEventListenerBy
         ((node = do_QueryInterface(mTarget)) &&
          (node == node->OwnerDoc() ||
           node == node->OwnerDoc()->GetRootElement() ||
           node == node->OwnerDoc()->GetBody()))) {
       flags.mPassive = true;
     }
   }
 
-  AddEventListenerInternal(Move(aListenerHolder),
+  AddEventListenerInternal(std::move(aListenerHolder),
                            message, atom, aType, flags);
 }
 
 void
 EventListenerManager::RemoveEventListenerByType(
                         EventListenerHolder aListenerHolder,
                         const nsAString& aType,
                         const EventListenerFlags& aFlags)
 {
   RefPtr<nsAtom> atom;
   EventMessage message = mIsMainThreadELM ?
     nsContentUtils::GetEventMessageAndAtomForListener(aType,
                                                       getter_AddRefs(atom)) :
     eUnidentifiedEvent;
-  RemoveEventListenerInternal(Move(aListenerHolder),
+  RemoveEventListenerInternal(std::move(aListenerHolder),
                               message, atom, aType, aFlags);
 }
 
 EventListenerManager::Listener*
 EventListenerManager::FindEventHandler(EventMessage aEventMessage,
                                        nsAtom* aTypeAtom,
                                        const nsAString& aTypeString)
 {
@@ -1240,30 +1240,30 @@ EventListenerManager::HandleEventInterna
                 listener->mListenerType != Listener::eNativeListener) {
               docShell = nsContentUtils::GetDocShellForEventTarget(mTarget);
               if (docShell) {
                 if (timelines && timelines->HasConsumer(docShell)) {
                   needsEndEventMarker = true;
                   nsAutoString typeStr;
                   (*aDOMEvent)->GetType(typeStr);
                   uint16_t phase = (*aDOMEvent)->EventPhase();
-                  timelines->AddMarkerForDocShell(docShell, Move(
+                  timelines->AddMarkerForDocShell(docShell, std::move(
                     MakeUnique<EventTimelineMarker>(
                       typeStr, phase, MarkerTracingType::START)));
                 }
               }
             }
 
             aEvent->mFlags.mInPassiveListener = listener->mFlags.mPassive;
             Maybe<Listener> listenerHolder;
             if (listener->mFlags.mOnce) {
               // Move the listener to the stack before handling the event.
               // The order is important, otherwise the listener could be
               // called again inside the listener.
-              listenerHolder.emplace(Move(*listener));
+              listenerHolder.emplace(std::move(*listener));
               listener = listenerHolder.ptr();
               hasRemovedListener = true;
             }
 
             nsresult rv = NS_OK;
 #ifdef MOZ_GECKO_PROFILER
             if (profiler_is_active()) {
               // Add a profiler label and a profiler marker for the actual
@@ -1388,17 +1388,17 @@ EventListenerManager::AddEventListener(
                         const nsAString& aType,
                         EventListenerHolder aListenerHolder,
                         bool aUseCapture,
                         bool aWantsUntrusted)
 {
   EventListenerFlags flags;
   flags.mCapture = aUseCapture;
   flags.mAllowUntrustedEvents = aWantsUntrusted;
-  return AddEventListenerByType(Move(aListenerHolder), aType, flags);
+  return AddEventListenerByType(std::move(aListenerHolder), aType, flags);
 }
 
 void
 EventListenerManager::AddEventListener(
                         const nsAString& aType,
                         EventListenerHolder aListenerHolder,
                         const dom::AddEventListenerOptionsOrBoolean& aOptions,
                         bool aWantsUntrusted)
@@ -1412,45 +1412,45 @@ EventListenerManager::AddEventListener(
     flags.mCapture = options.mCapture;
     flags.mInSystemGroup = options.mMozSystemGroup;
     flags.mOnce = options.mOnce;
     if (options.mPassive.WasPassed()) {
       passive.Construct(options.mPassive.Value());
     }
   }
   flags.mAllowUntrustedEvents = aWantsUntrusted;
-  return AddEventListenerByType(Move(aListenerHolder), aType, flags, passive);
+  return AddEventListenerByType(std::move(aListenerHolder), aType, flags, passive);
 }
 
 void
 EventListenerManager::RemoveEventListener(
                         const nsAString& aType,
                         EventListenerHolder aListenerHolder,
                         bool aUseCapture)
 {
   EventListenerFlags flags;
   flags.mCapture = aUseCapture;
-  RemoveEventListenerByType(Move(aListenerHolder), aType, flags);
+  RemoveEventListenerByType(std::move(aListenerHolder), aType, flags);
 }
 
 void
 EventListenerManager::RemoveEventListener(
                         const nsAString& aType,
                         EventListenerHolder aListenerHolder,
                         const dom::EventListenerOptionsOrBoolean& aOptions)
 {
   EventListenerFlags flags;
   if (aOptions.IsBoolean()) {
     flags.mCapture = aOptions.GetAsBoolean();
   } else {
     const auto& options = aOptions.GetAsEventListenerOptions();
     flags.mCapture = options.mCapture;
     flags.mInSystemGroup = options.mMozSystemGroup;
   }
-  RemoveEventListenerByType(Move(aListenerHolder), aType, flags);
+  RemoveEventListenerByType(std::move(aListenerHolder), aType, flags);
 }
 
 void
 EventListenerManager::AddListenerForAllEvents(EventListener* aDOMListener,
                                               bool aUseCapture,
                                               bool aWantsUntrusted,
                                               bool aSystemEventGroup)
 {
--- a/dom/events/EventListenerManager.h
+++ b/dom/events/EventListenerManager.h
@@ -220,17 +220,17 @@ public:
       , mListenerIsHandler(false)
       , mHandlerIsString(false)
       , mAllEvents(false)
       , mIsChrome(false)
     {
     }
 
     Listener(Listener&& aOther)
-      : mListener(Move(aOther.mListener))
+      : mListener(std::move(aOther.mListener))
       , mTypeAtom(aOther.mTypeAtom.forget())
       , mTypeString(aOther.mTypeString)
       , mEventMessage(aOther.mEventMessage)
       , mListenerType(aOther.mListenerType)
       , mListenerIsHandler(aOther.mListenerIsHandler)
       , mHandlerIsString(aOther.mHandlerIsString)
       , mAllEvents(aOther.mAllEvents)
       , mIsChrome(aOther.mIsChrome)
--- a/dom/fetch/BodyExtractor.cpp
+++ b/dom/fetch/BodyExtractor.cpp
@@ -136,17 +136,17 @@ BodyExtractor<const nsAString>::GetAsStr
                                             nsACString& aCharset) const
 {
   nsCString encoded;
   if (!CopyUTF16toUTF8(*mBody, encoded, fallible)) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
 
   uint32_t encodedLength = encoded.Length();
-  nsresult rv = NS_NewCStringInputStream(aResult, Move(encoded));
+  nsresult rv = NS_NewCStringInputStream(aResult, std::move(encoded));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   *aContentLength = encodedLength;
   aContentTypeWithCharset.AssignLiteral("text/plain;charset=UTF-8");
   aCharset.AssignLiteral("UTF-8");
   return NS_OK;
--- a/dom/fetch/Fetch.cpp
+++ b/dom/fetch/Fetch.cpp
@@ -195,17 +195,17 @@ public:
     RefPtr<WeakWorkerRef> workerRef =
       WeakWorkerRef::Create(aWorkerPrivate, [r]() {
         r->Shutdown(r->mWorkerRef->GetPrivate());
       });
     if (NS_WARN_IF(!workerRef)) {
       return nullptr;
     }
 
-    r->mWorkerRef = Move(workerRef);
+    r->mWorkerRef = std::move(workerRef);
 
     return r.forget();
   }
 
   AbortSignal*
   GetAbortSignalForMainThread()
   {
     MOZ_ASSERT(NS_IsMainThread());
--- a/dom/fetch/FetchDriver.cpp
+++ b/dom/fetch/FetchDriver.cpp
@@ -381,17 +381,17 @@ FetchDriver::Fetch(AbortSignal* aSignal,
 
 
   UniquePtr<mozilla::ipc::PrincipalInfo> principalInfo(new mozilla::ipc::PrincipalInfo());
   nsresult rv = PrincipalToPrincipalInfo(mPrincipal, principalInfo.get());
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
-  mRequest->SetPrincipalInfo(Move(principalInfo));
+  mRequest->SetPrincipalInfo(std::move(principalInfo));
 
   // If the signal is aborted, it's time to inform the observer and terminate
   // the operation.
   if (aSignal) {
     if (aSignal->Aborted()) {
       Abort();
       return NS_OK;
     }
--- a/dom/fetch/FetchStreamReader.cpp
+++ b/dom/fetch/FetchStreamReader.cpp
@@ -260,17 +260,17 @@ FetchStreamReader::ResolvedCallback(JSCo
 
   if (len == 0) {
     // If there is nothing to read, let's do another reading.
     OnOutputStreamReady(mPipeOut);
     return;
   }
 
   MOZ_DIAGNOSTIC_ASSERT(!mBuffer);
-  mBuffer = Move(value);
+  mBuffer = std::move(value);
 
   mBufferOffset = 0;
   mBufferRemaining = len;
 
   nsresult rv = WriteBuffer();
   if (NS_FAILED(rv)) {
     // DOMException only understands errors from domerr.msg, so we normalize to
     // identifying an abort if the write fails.
--- a/dom/fetch/FetchUtil.cpp
+++ b/dom/fetch/FetchUtil.cpp
@@ -300,17 +300,17 @@ public:
   }
 
   struct Destroyer final : CancelableRunnable
   {
     RefPtr<WorkerStreamOwner> mDoomed;
 
     explicit Destroyer(already_AddRefed<WorkerStreamOwner>&& aDoomed)
       : CancelableRunnable("WorkerStreamOwner::Destroyer")
-      , mDoomed(Move(aDoomed))
+      , mDoomed(std::move(aDoomed))
     {}
 
     NS_IMETHOD
     Run() override
     {
       mDoomed = nullptr;
       return NS_OK;
     }
@@ -351,17 +351,17 @@ class JSStreamConsumer final : public ns
     MOZ_DIAGNOSTIC_ASSERT(mWindowStreamOwner);
     MOZ_DIAGNOSTIC_ASSERT(mConsumer);
   }
 
   JSStreamConsumer(RefPtr<WorkerStreamOwner> aWorkerStreamOwner,
                    nsIGlobalObject* aGlobal,
                    JS::StreamConsumer* aConsumer)
    : mOwningEventTarget(aGlobal->EventTargetFor(TaskCategory::Other))
-   , mWorkerStreamOwner(Move(aWorkerStreamOwner))
+   , mWorkerStreamOwner(std::move(aWorkerStreamOwner))
    , mConsumer(aConsumer)
    , mConsumerAborted(false)
   {
     MOZ_DIAGNOSTIC_ASSERT(mWorkerStreamOwner);
     MOZ_DIAGNOSTIC_ASSERT(mConsumer);
   }
 
   ~JSStreamConsumer()
@@ -441,17 +441,17 @@ public:
     RefPtr<JSStreamConsumer> consumer;
     if (aMaybeWorker) {
       RefPtr<WorkerStreamOwner> owner =
         WorkerStreamOwner::Create(asyncStream, aMaybeWorker);
       if (!owner) {
         return false;
       }
 
-      consumer = new JSStreamConsumer(Move(owner), aGlobal, aConsumer);
+      consumer = new JSStreamConsumer(std::move(owner), aGlobal, aConsumer);
     } else {
       RefPtr<WindowStreamOwner> owner =
         WindowStreamOwner::Create(asyncStream, aGlobal);
       if (!owner) {
         return false;
       }
 
       consumer = new JSStreamConsumer(owner.forget(), aGlobal, aConsumer);
--- a/dom/fetch/InternalRequest.cpp
+++ b/dom/fetch/InternalRequest.cpp
@@ -472,13 +472,13 @@ InternalRequest::MaybeSkipCacheIfPerform
       mHeaders->HasRevalidationHeaders()) {
     mCacheMode = RequestCache::No_store;
   }
 }
 
 void
 InternalRequest::SetPrincipalInfo(UniquePtr<mozilla::ipc::PrincipalInfo> aPrincipalInfo)
 {
-  mPrincipalInfo = Move(aPrincipalInfo);
+  mPrincipalInfo = std::move(aPrincipalInfo);
 }
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/fetch/InternalResponse.cpp
+++ b/dom/fetch/InternalResponse.cpp
@@ -51,17 +51,17 @@ InternalResponse::FromIPC(const IPCInter
   response->SetURLList(aIPCResponse.urlList());
 
   response->mHeaders = new InternalHeaders(aIPCResponse.headers(),
                                            aIPCResponse.headersGuard());
 
   response->InitChannelInfo(aIPCResponse.channelInfo());
   if (aIPCResponse.principalInfo().type() == mozilla::ipc::OptionalPrincipalInfo::TPrincipalInfo) {
     UniquePtr<mozilla::ipc::PrincipalInfo> info(new mozilla::ipc::PrincipalInfo(aIPCResponse.principalInfo().get_PrincipalInfo()));
-    response->SetPrincipalInfo(Move(info));
+    response->SetPrincipalInfo(std::move(info));
   }
 
   nsCOMPtr<nsIInputStream> stream = DeserializeIPCStream(aIPCResponse.body());
   response->SetBody(stream, aIPCResponse.bodySize());
 
   switch (aIPCResponse.type())
   {
     case ResponseType::Basic:
@@ -276,17 +276,17 @@ InternalResponse::SetPaddingSize(int64_t
                         aPaddingSize >= 0);
 
   mPaddingSize = aPaddingSize;
 }
 
 void
 InternalResponse::SetPrincipalInfo(UniquePtr<mozilla::ipc::PrincipalInfo> aPrincipalInfo)
 {
-  mPrincipalInfo = Move(aPrincipalInfo);
+  mPrincipalInfo = std::move(aPrincipalInfo);
 }
 
 LoadTainting
 InternalResponse::GetTainting() const
 {
   switch (mType) {
     case ResponseType::Cors:
       return LoadTainting::CORS;
--- a/dom/file/Blob.cpp
+++ b/dom/file/Blob.cpp
@@ -135,17 +135,17 @@ already_AddRefed<File>
 Blob::ToFile(const nsAString& aName, ErrorResult& aRv) const
 {
   AutoTArray<RefPtr<BlobImpl>, 1> blobImpls({mImpl});
 
   nsAutoString contentType;
   mImpl->GetType(contentType);
 
   RefPtr<MultipartBlobImpl> impl =
-    MultipartBlobImpl::Create(Move(blobImpls), aName, contentType, aRv);
+    MultipartBlobImpl::Create(std::move(blobImpls), aName, contentType, aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return nullptr;
   }
 
   RefPtr<File> file = new File(mParent, impl);
   return file.forget();
 }
 
--- a/dom/file/FileReaderSync.cpp
+++ b/dom/file/FileReaderSync.cpp
@@ -471,17 +471,17 @@ FileReaderSync::SyncRead(nsIInputStream*
   return SyncRead(aStream, aBuffer, aBufferSize, aRead);
 }
 
 nsresult
 FileReaderSync::ConvertAsyncToSyncStream(uint64_t aStreamSize,
                                          already_AddRefed<nsIInputStream> aAsyncStream,
                                          nsIInputStream** aSyncStream)
 {
-  nsCOMPtr<nsIInputStream> asyncInputStream = Move(aAsyncStream);
+  nsCOMPtr<nsIInputStream> asyncInputStream = std::move(aAsyncStream);
 
   // If the stream is not async, we just need it to be bufferable.
   nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(asyncInputStream);
   if (!asyncStream) {
     return NS_NewBufferedInputStream(aSyncStream, asyncInputStream.forget(), 4096);
   }
 
   nsAutoCString buffer;
@@ -495,15 +495,15 @@ FileReaderSync::ConvertAsyncToSyncStream
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   if (read != aStreamSize) {
     return NS_ERROR_FAILURE;
   }
 
-  rv = NS_NewCStringInputStream(aSyncStream, Move(buffer));
+  rv = NS_NewCStringInputStream(aSyncStream, std::move(buffer));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   return NS_OK;
 }
--- a/dom/file/MultipartBlobImpl.cpp
+++ b/dom/file/MultipartBlobImpl.cpp
@@ -24,32 +24,32 @@ using namespace mozilla::dom;
 
 /* static */ already_AddRefed<MultipartBlobImpl>
 MultipartBlobImpl::Create(nsTArray<RefPtr<BlobImpl>>&& aBlobImpls,
                           const nsAString& aName,
                           const nsAString& aContentType,
                           ErrorResult& aRv)
 {
   RefPtr<MultipartBlobImpl> blobImpl =
-    new MultipartBlobImpl(Move(aBlobImpls), aName, aContentType);
+    new MultipartBlobImpl(std::move(aBlobImpls), aName, aContentType);
   blobImpl->SetLengthAndModifiedDate(aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return nullptr;
   }
 
   return blobImpl.forget();
 }
 
 /* static */ already_AddRefed<MultipartBlobImpl>
 MultipartBlobImpl::Create(nsTArray<RefPtr<BlobImpl>>&& aBlobImpls,
                           const nsAString& aContentType,
                           ErrorResult& aRv)
 {
   RefPtr<MultipartBlobImpl> blobImpl =
-    new MultipartBlobImpl(Move(aBlobImpls), aContentType);
+    new MultipartBlobImpl(std::move(aBlobImpls), aContentType);
   blobImpl->SetLengthAndModifiedDate(aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return nullptr;
   }
 
   return blobImpl.forget();
 }
 
@@ -148,17 +148,17 @@ MultipartBlobImpl::CreateSlice(uint64_t 
       blobImpls.AppendElement(lastBlobImpl);
     } else {
       blobImpls.AppendElement(blobImpl);
     }
     length -= std::min<uint64_t>(l, length);
   }
 
   // we can create our blob now
-  RefPtr<BlobImpl> impl = Create(Move(blobImpls), aContentType, aRv);
+  RefPtr<BlobImpl> impl = Create(std::move(blobImpls), aContentType, aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return nullptr;
   }
 
   return impl.forget();
 }
 
 void
--- a/dom/file/MultipartBlobImpl.h
+++ b/dom/file/MultipartBlobImpl.h
@@ -94,25 +94,25 @@ public:
 
   size_t GetAllocationSize() const override;
 
 protected:
   MultipartBlobImpl(nsTArray<RefPtr<BlobImpl>>&& aBlobImpls,
                     const nsAString& aName,
                     const nsAString& aContentType)
     : BaseBlobImpl(aName, aContentType, UINT64_MAX),
-      mBlobImpls(Move(aBlobImpls)),
+      mBlobImpls(std::move(aBlobImpls)),
       mIsFromNsIFile(false)
   {
   }
 
   MultipartBlobImpl(nsTArray<RefPtr<BlobImpl>>&& aBlobImpls,
                     const nsAString& aContentType)
     : BaseBlobImpl(aContentType, UINT64_MAX),
-      mBlobImpls(Move(aBlobImpls)),
+      mBlobImpls(std::move(aBlobImpls)),
       mIsFromNsIFile(false)
   {
   }
 
   virtual ~MultipartBlobImpl() {}
 
   void SetLengthAndModifiedDate(ErrorResult& aRv);
 
--- a/dom/file/MutableBlobStorage.cpp
+++ b/dom/file/MutableBlobStorage.cpp
@@ -236,27 +236,27 @@ public:
     MOZ_ASSERT(mBlobStorage);
     mBlobStorage->AskForBlob(this, mContentType);
     return NS_OK;
   }
 
   void
   OperationSucceeded(BlobImpl* aBlobImpl) override
   {
-    nsCOMPtr<nsISupports> parent(Move(mParent));
-    RefPtr<MutableBlobStorageCallback> callback(Move(mCallback));
+    nsCOMPtr<nsISupports> parent(std::move(mParent));
+    RefPtr<MutableBlobStorageCallback> callback(std::move(mCallback));
 
     RefPtr<Blob> blob = Blob::Create(parent, aBlobImpl);
     callback->BlobStoreCompleted(mBlobStorage, blob, NS_OK);
   }
 
   void
   OperationFailed(nsresult aRv) override
   {
-    RefPtr<MutableBlobStorageCallback> callback(Move(mCallback));
+    RefPtr<MutableBlobStorageCallback> callback(std::move(mCallback));
     callback->BlobStoreCompleted(mBlobStorage, nullptr, aRv);
   }
 
 private:
   ~CreateBlobRunnable()
   {
     MOZ_ASSERT(mBlobStorage);
     // If something when wrong, we still have to release data in the correct
--- a/dom/file/TemporaryFileBlobImpl.cpp
+++ b/dom/file/TemporaryFileBlobImpl.cpp
@@ -80,17 +80,17 @@ private:
   {
     // Let's delete the file on the IPCBlob Thread.
     RefPtr<IPCBlobInputStreamThread> thread =
       IPCBlobInputStreamThread::GetOrCreate();
     if (NS_WARN_IF(!thread)) {
       return;
     }
 
-    nsCOMPtr<nsIFile> file = Move(mFile);
+    nsCOMPtr<nsIFile> file = std::move(mFile);
     thread->Dispatch(NS_NewRunnableFunction(
       "TemporaryFileInputStream::Runnable",
       [file]() {
         file->Remove(false);
       }
     ));
   }
 
--- a/dom/file/ipc/IPCBlobInputStream.cpp
+++ b/dom/file/ipc/IPCBlobInputStream.cpp
@@ -463,17 +463,17 @@ IPCBlobInputStream::AsyncWait(nsIInputSt
   MOZ_ASSERT(asyncRemoteStream);
   return asyncRemoteStream->AsyncWait(aCallback ? this : nullptr,
                                       0, 0, aEventTarget);
 }
 
 void
 IPCBlobInputStream::StreamReady(already_AddRefed<nsIInputStream> aInputStream)
 {
-  nsCOMPtr<nsIInputStream> inputStream = Move(aInputStream);
+  nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream);
 
   // If inputStream is null, it means that the serialization went wrong or the
   // stream is not available anymore. We keep the state as pending just to block
   // any additional operation.
 
   if (!inputStream) {
     return;
   }
--- a/dom/file/ipc/IPCBlobInputStreamChild.cpp
+++ b/dom/file/ipc/IPCBlobInputStreamChild.cpp
@@ -66,17 +66,17 @@ private:
 // IPCBlobInputStream.
 class StreamReadyRunnable final : public CancelableRunnable
 {
 public:
   StreamReadyRunnable(IPCBlobInputStream* aDestinationStream,
                       already_AddRefed<nsIInputStream> aCreatedStream)
     : CancelableRunnable("dom::StreamReadyRunnable")
     , mDestinationStream(aDestinationStream)
-    , mCreatedStream(Move(aCreatedStream))
+    , mCreatedStream(std::move(aCreatedStream))
   {
     MOZ_ASSERT(mDestinationStream);
     // mCreatedStream can be null.
   }
 
   NS_IMETHOD
   Run() override
   {
--- a/dom/file/ipc/TemporaryIPCBlobParent.cpp
+++ b/dom/file/ipc/TemporaryIPCBlobParent.cpp
@@ -74,17 +74,17 @@ TemporaryIPCBlobParent::RecvOperationDon
 
   // We have received a file descriptor because in this way we have kept the
   // file locked on windows during the IPC communication. After the creation of
   // the TemporaryFileBlobImpl, this prfile can be closed.
   auto rawFD = aFD.ClonePlatformHandle();
   PRFileDesc* prfile = PR_ImportFile(PROsfd(rawFD.release()));
 
   // Let's create the BlobImpl.
-  nsCOMPtr<nsIFile> file = Move(mFile);
+  nsCOMPtr<nsIFile> file = std::move(mFile);
 
   RefPtr<TemporaryFileBlobImpl> blobImpl =
     new TemporaryFileBlobImpl(file, NS_ConvertUTF8toUTF16(aContentType));
 
   PR_Close(prfile);
 
   IPCBlob ipcBlob;
   nsresult rv = IPCBlobUtils::Serialize(blobImpl, Manager(), ipcBlob);
--- a/dom/file/nsHostObjectProtocolHandler.cpp
+++ b/dom/file/nsHostObjectProtocolHandler.cpp
@@ -563,17 +563,17 @@ private:
   {
     nsCOMPtr<nsIAsyncShutdownService> svc = services::GetAsyncShutdown();
     NS_ENSURE_TRUE(!!svc, nullptr);
 
     nsCOMPtr<nsIAsyncShutdownClient> phase;
     nsresult rv = svc->GetXpcomWillShutdown(getter_AddRefs(phase));
     NS_ENSURE_SUCCESS(rv, nullptr);
 
-    return Move(phase);
+    return std::move(phase);
   }
 
   nsCString mURI;
   bool mBroadcastToOtherProcesses;
 
   nsCOMPtr<nsITimer> mTimer;
 };
 
--- a/dom/filehandle/ActorsParent.cpp
+++ b/dom/filehandle/ActorsParent.cpp
@@ -919,17 +919,17 @@ FileHandleThreadPool::WaitForDirectories
                                              nsTArray<nsCString>&& aDirectoryIds,
                                              nsIRunnable* aCallback)
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(!aDirectoryIds.IsEmpty());
   MOZ_ASSERT(aCallback);
 
   nsAutoPtr<StoragesCompleteCallback> callback(
-    new StoragesCompleteCallback(Move(aDirectoryIds), aCallback));
+    new StoragesCompleteCallback(std::move(aDirectoryIds), aCallback));
 
   if (!MaybeFireCallback(callback)) {
     mCompleteCallbacks.AppendElement(callback.forget());
   }
 }
 
 void
 FileHandleThreadPool::Shutdown()
@@ -1269,17 +1269,17 @@ DirectoryInfo::CreateDelayedEnqueueInfo(
   info->mFinish = aFinish;
   return info;
 }
 
 FileHandleThreadPool::
 StoragesCompleteCallback::StoragesCompleteCallback(
                                              nsTArray<nsCString>&& aDirectoryIds,
                                              nsIRunnable* aCallback)
-  : mDirectoryIds(Move(aDirectoryIds))
+  : mDirectoryIds(std::move(aDirectoryIds))
   , mCallback(aCallback)
 {
   AssertIsOnBackgroundThread();
   MOZ_ASSERT(!mDirectoryIds.IsEmpty());
   MOZ_ASSERT(aCallback);
 
   MOZ_COUNT_CTOR(FileHandleThreadPool::StoragesCompleteCallback);
 }
--- a/dom/geolocation/nsGeolocation.cpp
+++ b/dom/geolocation/nsGeolocation.cpp
@@ -308,19 +308,19 @@ nsGeolocationRequest::nsGeolocationReque
                                            GeoPositionErrorCallback aErrorCallback,
                                            UniquePtr<PositionOptions>&& aOptions,
                                            uint8_t aProtocolType,
                                            nsIEventTarget* aMainThreadTarget,
                                            bool aWatchPositionRequest,
                                            bool aIsHandlingUserInput,
                                            int32_t aWatchId)
   : mIsWatchPositionRequest(aWatchPositionRequest),
-    mCallback(Move(aCallback)),
-    mErrorCallback(Move(aErrorCallback)),
-    mOptions(Move(aOptions)),
+    mCallback(std::move(aCallback)),
+    mErrorCallback(std::move(aErrorCallback)),
+    mOptions(std::move(aOptions)),
     mIsHandlingUserInput(aIsHandlingUserInput),
     mLocator(aLocator),
     mWatchId(aWatchId),
     mShutdown(false),
     mProtocolType(aProtocolType),
     mMainThreadTarget(aMainThreadTarget)
 {
   if (nsCOMPtr<nsPIDOMWindowInner> win =
@@ -1237,17 +1237,17 @@ void
 Geolocation::GetCurrentPosition(PositionCallback& aCallback,
                                 PositionErrorCallback* aErrorCallback,
                                 const PositionOptions& aOptions,
                                 CallerType aCallerType,
                                 ErrorResult& aRv)
 {
   nsresult rv = GetCurrentPosition(GeoPositionCallback(&aCallback),
                                    GeoPositionErrorCallback(aErrorCallback),
-                                   Move(CreatePositionOptionsCopy(aOptions)),
+                                   std::move(CreatePositionOptionsCopy(aOptions)),
                                    aCallerType);
 
   if (NS_FAILED(rv)) {
     aRv.Throw(rv);
   }
 }
 
 static nsIEventTarget* MainThreadTarget(Geolocation* geo)
@@ -1272,18 +1272,18 @@ Geolocation::GetCurrentPosition(GeoPosit
   // After this we hand over ownership of options to our nsGeolocationRequest.
 
   // Count the number of requests per protocol/scheme.
   Telemetry::Accumulate(Telemetry::GEOLOCATION_GETCURRENTPOSITION_SECURE_ORIGIN,
                         static_cast<uint8_t>(mProtocolType));
 
   nsIEventTarget* target = MainThreadTarget(this);
   RefPtr<nsGeolocationRequest> request =
-    new nsGeolocationRequest(this, Move(callback), Move(errorCallback),
-                             Move(options), static_cast<uint8_t>(mProtocolType), target,
+    new nsGeolocationRequest(this, std::move(callback), std::move(errorCallback),
+                             std::move(options), static_cast<uint8_t>(mProtocolType), target,
                              false, EventStateManager::IsHandlingUserInput());
 
   if (!sGeoEnabled || ShouldBlockInsecureRequests() ||
       nsContentUtils::ResistFingerprinting(aCallerType)) {
     nsCOMPtr<nsIRunnable> ev = new RequestAllowEvent(false, request);
     target->Dispatch(ev.forget());
     return NS_OK;
   }
@@ -1315,17 +1315,17 @@ Geolocation::WatchPosition(PositionCallb
                            PositionErrorCallback* aErrorCallback,
                            const PositionOptions& aOptions,
                            CallerType aCallerType,
                            ErrorResult& aRv)
 {
   int32_t ret = 0;
   nsresult rv = WatchPosition(GeoPositionCallback(&aCallback),
                               GeoPositionErrorCallback(aErrorCallback),
-                              Move(CreatePositionOptionsCopy(aOptions)),
+                              std::move(CreatePositionOptionsCopy(aOptions)),
                               aCallerType,
                               &ret);
 
   if (NS_FAILED(rv)) {
     aRv.Throw(rv);
   }
 
   return ret;
@@ -1336,17 +1336,17 @@ Geolocation::WatchPosition(nsIDOMGeoPosi
                            nsIDOMGeoPositionErrorCallback *aErrorCallback,
                            UniquePtr<PositionOptions>&& aOptions,
                            int32_t* aRv)
 {
   NS_ENSURE_ARG_POINTER(aCallback);
 
   return WatchPosition(GeoPositionCallback(aCallback),
                        GeoPositionErrorCallback(aErrorCallback),
-                       Move(aOptions), CallerType::System,
+                       std::move(aOptions), CallerType::System,
                        aRv);
 }
 
 nsresult
 Geolocation::WatchPosition(GeoPositionCallback aCallback,
                            GeoPositionErrorCallback aErrorCallback,
                            UniquePtr<PositionOptions>&& aOptions,
                            CallerType aCallerType,
@@ -1360,18 +1360,18 @@ Geolocation::WatchPosition(GeoPositionCa
   Telemetry::Accumulate(Telemetry::GEOLOCATION_WATCHPOSITION_SECURE_ORIGIN,
                         static_cast<uint8_t>(mProtocolType));
 
   // The watch ID:
   *aRv = mLastWatchId++;
 
   nsIEventTarget* target = MainThreadTarget(this);
   RefPtr<nsGeolocationRequest> request =
-    new nsGeolocationRequest(this, Move(aCallback), Move(aErrorCallback),
-                             Move(aOptions),
+    new nsGeolocationRequest(this, std::move(aCallback), std::move(aErrorCallback),
+                             std::move(aOptions),
                              static_cast<uint8_t>(mProtocolType), target, true,
                              EventStateManager::IsHandlingUserInput(), *aRv);
 
   if (!sGeoEnabled || ShouldBlockInsecureRequests() ||
       nsContentUtils::ResistFingerprinting(aCallerType)) {
     nsCOMPtr<nsIRunnable> ev = new RequestAllowEvent(false, request);
     target->Dispatch(ev.forget());
     return NS_OK;
--- a/dom/html/HTMLFormElement.cpp
+++ b/dom/html/HTMLFormElement.cpp
@@ -1565,17 +1565,17 @@ HTMLFormElement::OnSubmitClickEnd()
 }
 
 void
 HTMLFormElement::FlushPendingSubmission()
 {
   if (mPendingSubmission) {
     // Transfer owning reference so that the submissioin doesn't get deleted
     // if we reenter
-    nsAutoPtr<HTMLFormSubmission> submission = Move(mPendingSubmission);
+    nsAutoPtr<HTMLFormSubmission> submission = std::move(mPendingSubmission);
 
     SubmitSubmission(submission);
   }
 }
 
 void
 HTMLFormElement::GetAction(nsString& aValue)
 {
--- a/dom/html/HTMLFormSubmission.cpp
+++ b/dom/html/HTMLFormSubmission.cpp
@@ -296,17 +296,17 @@ FSURLEncoded::GetEncodedSubmission(nsIUR
 
       path += NS_LITERAL_CSTRING("&force-plain-text=Y&body=") + escapedBody;
 
       return NS_MutateURI(aURI)
                .SetPathQueryRef(path)
                .Finalize(aOutURI);
     } else {
       nsCOMPtr<nsIInputStream> dataStream;
-      rv = NS_NewCStringInputStream(getter_AddRefs(dataStream), Move(mQueryString));
+      rv = NS_NewCStringInputStream(getter_AddRefs(dataStream), std::move(mQueryString));
       NS_ENSURE_SUCCESS(rv, rv);
       mQueryString.Truncate();
 
       nsCOMPtr<nsIMIMEInputStream> mimeStream(
         do_CreateInstance("@mozilla.org/network/mime-input-stream;1", &rv));
       NS_ENSURE_SUCCESS(rv, rv);
 
       mimeStream->AddHeader("Content-Type",
@@ -766,17 +766,17 @@ FSTextPlain::GetEncodedSubmission(nsIURI
     // encoded, but that how text/plain is specced.
     nsCString cbody;
     EncodeVal(mBody, cbody, false);
     cbody.Adopt(nsLinebreakConverter::
                 ConvertLineBreaks(cbody.get(),
                                   nsLinebreakConverter::eLinebreakAny,
                                   nsLinebreakConverter::eLinebreakNet));
     nsCOMPtr<nsIInputStream> bodyStream;
-    rv = NS_NewCStringInputStream(getter_AddRefs(bodyStream), Move(cbody));
+    rv = NS_NewCStringInputStream(getter_AddRefs(bodyStream), std::move(cbody));
     if (!bodyStream) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
 
     // Create mime stream with headers and such
     nsCOMPtr<nsIMIMEInputStream> mimeStream
         = do_CreateInstance("@mozilla.org/network/mime-input-stream;1", &rv);
     NS_ENSURE_SUCCESS(rv, rv);
--- a/dom/html/HTMLFrameSetElement.cpp
+++ b/dom/html/HTMLFrameSetElement.cpp
@@ -290,17 +290,17 @@ HTMLFrameSetElement::ParseRowCol(const n
         specs[i].mValue = 0;
       }
       start = end + 1;
     }
   }
 
   aNumSpecs = count;
   // Transfer ownership to caller here
-  *aSpecs = Move(specs);
+  *aSpecs = std::move(specs);
 
   return NS_OK;
 }
 
 bool
 HTMLFrameSetElement::IsEventAttributeNameInternal(nsAtom *aName)
 {
   return nsContentUtils::IsEventAttributeName(aName,
--- a/dom/html/HTMLInputElement.cpp
+++ b/dom/html/HTMLInputElement.cpp
@@ -6190,25 +6190,25 @@ HTMLInputElement::SubmitNamesValues(HTML
 
 static nsTArray<FileContentData>
 SaveFileContentData(const nsTArray<OwningFileOrDirectory>& aArray)
 {
   nsTArray<FileContentData> res(aArray.Length());
   for (auto& it : aArray) {
     if (it.IsFile()) {
       RefPtr<BlobImpl> impl = it.GetAsFile()->Impl();
-      res.AppendElement(Move(impl));
+      res.AppendElement(std::move(impl));
     } else {
       MOZ_ASSERT(it.IsDirectory());
       nsString fullPath;
       nsresult rv = it.GetAsDirectory()->GetFullRealPath(fullPath);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         continue;
       }
-      res.AppendElement(Move(fullPath));
+      res.AppendElement(std::move(fullPath));
     }
   }
   return res;
 }
 
 NS_IMETHODIMP
 HTMLInputElement::SaveState()
 {
@@ -6260,17 +6260,17 @@ HTMLInputElement::SaveState()
                nsLinebreakConverter::eLinebreakContent);
 
         if (NS_FAILED(rv)) {
           NS_ERROR("Converting linebreaks failed!");
           return rv;
         }
       }
 
-      state->contentData() = Move(value);
+      state->contentData() = std::move(value);
       break;
   }
 
   if (mDisabledChanged) {
     if (!state) {
       state = GetPrimaryPresState();
     }
     if (state) {
--- a/dom/html/HTMLMediaElement.cpp
+++ b/dom/html/HTMLMediaElement.cpp
@@ -289,17 +289,17 @@ class HTMLMediaElement::nsResolveOrRejec
 public:
   nsResolveOrRejectPendingPlayPromisesRunner(
     HTMLMediaElement* aElement,
     nsTArray<RefPtr<PlayPromise>>&& aPromises,
     nsresult aError = NS_OK)
     : nsMediaEvent(
         "HTMLMediaElement::nsResolveOrRejectPendingPlayPromisesRunner",
         aElement)
-    , mPromises(Move(aPromises))
+    , mPromises(std::move(aPromises))
     , mError(aError)
   {
     mElement->mPendingPlayPromisesRunners.AppendElement(this);
   }
 
   void ResolveOrReject()
   {
     if (NS_SUCCEEDED(mError)) {
@@ -323,17 +323,17 @@ public:
 class HTMLMediaElement::nsNotifyAboutPlayingRunner
   : public nsResolveOrRejectPendingPlayPromisesRunner
 {
 public:
   nsNotifyAboutPlayingRunner(
     HTMLMediaElement* aElement,
     nsTArray<RefPtr<PlayPromise>>&& aPendingPlayPromises)
     : nsResolveOrRejectPendingPlayPromisesRunner(aElement,
-                                                 Move(aPendingPlayPromises))
+                                                 std::move(aPendingPlayPromises))
   {
   }
 
   NS_IMETHOD Run() override
   {
     if (IsCancelled()) {
       mElement->mPendingPlayPromisesRunners.RemoveElement(this);
       return NS_OK;
@@ -3448,17 +3448,17 @@ HTMLMediaElement::AddCaptureMediaTrackTo
   // Track is muted initially, so we don't leak data if it's added while paused
   // and an MSG iteration passes before the mute comes into effect.
   processedOutputSource->SetTrackEnabled(destinationTrackID,
                                          DisabledTrackMode::SILENCE_FREEZE);
   RefPtr<MediaInputPort> port = inputTrack->ForwardTrackContentsTo(
     processedOutputSource, destinationTrackID);
 
   Pair<nsString, RefPtr<MediaInputPort>> p(aTrack->GetId(), port);
-  aOutputStream.mTrackPorts.AppendElement(Move(p));
+  aOutputStream.mTrackPorts.AppendElement(std::move(p));
 
   if (mSrcStreamIsPlaying) {
     processedOutputSource->SetTrackEnabled(destinationTrackID,
                                            DisabledTrackMode::ENABLED);
   }
 
   LOG(LogLevel::Debug,
       ("Created %s track %p with id %d from track %p through MediaInputPort %p",
@@ -5415,17 +5415,17 @@ HTMLMediaElement::MetadataLoaded(const M
                                  UniquePtr<const MetadataTags> aTags)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   SetMediaInfo(*aInfo);
 
   mIsEncrypted =
     aInfo->IsEncrypted() || mPendingEncryptedInitData.IsEncrypted();
-  mTags = Move(aTags);
+  mTags = std::move(aTags);
   mLoadedDataFired = false;
   ChangeReadyState(HAVE_METADATA);
 
   DispatchAsyncEvent(NS_LITERAL_STRING("durationchange"));
   if (IsVideo() && HasVideo()) {
     DispatchAsyncEvent(NS_LITERAL_STRING("resize"));
   }
   NS_ASSERTION(!HasVideo() || (mMediaInfo.mVideo.mDisplay.width > 0 &&
@@ -7789,17 +7789,17 @@ HTMLMediaElement::AbstractMainThread() c
   MOZ_ASSERT(mAbstractMainThread);
 
   return mAbstractMainThread;
 }
 
 nsTArray<RefPtr<PlayPromise>>
 HTMLMediaElement::TakePendingPlayPromises()
 {
-  return Move(mPendingPlayPromises);
+  return std::move(mPendingPlayPromises);
 }
 
 void
 HTMLMediaElement::NotifyAboutPlaying()
 {
   // Stick to the DispatchAsyncEvent() call path for now because we want to
   // trigger some telemetry-related codes in the DispatchAsyncEvent() method.
   DispatchAsyncEvent(NS_LITERAL_STRING("playing"));
--- a/dom/html/HTMLSelectElement.cpp
+++ b/dom/html/HTMLSelectElement.cpp
@@ -1432,22 +1432,22 @@ HTMLSelectElement::SaveState()
   for (uint32_t optIndex = 0; optIndex < len; optIndex++) {
     HTMLOptionElement* option = Item(optIndex);
     if (option && option->Selected()) {
       nsAutoString value;
       option->GetValue(value);
       if (value.IsEmpty()) {
         state.indices().AppendElement(optIndex);
       } else {
-        state.values().AppendElement(Move(value));
+        state.values().AppendElement(std::move(value));
       }
     }
   }
 
-  presState->contentData() = Move(state);
+  presState->contentData() = std::move(state);
 
   if (mDisabledChanged) {
     // We do not want to save the real disabled state but the disabled
     // attribute.
     presState->disabled() = HasAttr(kNameSpaceID_None, nsGkAtoms::disabled);
     presState->disabledSet() = true;
   }
 
--- a/dom/html/HTMLTableElement.cpp
+++ b/dom/html/HTMLTableElement.cpp
@@ -172,19 +172,19 @@ TableRowsCollection::EnsureInitialized()
     } else if (node->IsHTMLElement(nsGkAtoms::tfoot)) {
       addRowChildren(foot, node);
     } else if (node->IsHTMLElement(nsGkAtoms::tr)) {
       body.AppendElement(node);
     }
   }
 
   mBodyStart = mRows.Length();
-  mRows.AppendElements(Move(body));
+  mRows.AppendElements(std::move(body));
   mFootStart = mRows.Length();
-  mRows.AppendElements(Move(foot));
+  mRows.AppendElements(std::move(foot));
 
   mParent->AddMutationObserver(this);
 }
 
 void
 TableRowsCollection::CleanUp()
 {
   // Unregister ourselves as a mutation observer.
--- a/dom/html/HTMLTextAreaElement.cpp
+++ b/dom/html/HTMLTextAreaElement.cpp
@@ -823,17 +823,17 @@ HTMLTextAreaElement::SaveState()
                nsLinebreakConverter::eLinebreakPlatform,
                nsLinebreakConverter::eLinebreakContent);
 
       if (NS_FAILED(rv)) {
         NS_ERROR("Converting linebreaks failed!");
         return rv;
       }
 
-      state->contentData() = Move(value);
+      state->contentData() = std::move(value);
     }
   }
 
   if (mDisabledChanged) {
     if (!state) {
       state = GetPrimaryPresState();
       rv = NS_OK;
     }
--- a/dom/html/nsGenericHTMLElement.cpp
+++ b/dom/html/nsGenericHTMLElement.cpp
@@ -2759,17 +2759,17 @@ nsGenericHTMLFormElementWithState::GetPr
     return nullptr;
   }
 
   // Get the pres state for this key, if it doesn't exist, create one.
   PresState* result = history->GetState(mStateKey);
   if (!result) {
     UniquePtr<PresState> newState = NewPresState();
     result = newState.get();
-    history->AddState(mStateKey, Move(newState));
+    history->AddState(mStateKey, std::move(newState));
   }
 
   return result;
 }
 
 already_AddRefed<nsILayoutHistoryState>
 nsGenericHTMLFormElementWithState::GetLayoutHistory(bool aRead)
 {
--- a/dom/html/nsGenericHTMLElement.h
+++ b/dom/html/nsGenericHTMLElement.h
@@ -1231,17 +1231,17 @@ nsGenericHTMLElement*                   
 NS_NewHTML##_elementName##Element(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo, \
                                   mozilla::dom::FromParser aFromParser = mozilla::dom::NOT_FROM_PARSER);
 
 #define NS_DECLARE_NS_NEW_HTML_ELEMENT_AS_SHARED(_elementName)             \
 inline nsGenericHTMLElement*                                               \
 NS_NewHTML##_elementName##Element(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo, \
                                   mozilla::dom::FromParser aFromParser = mozilla::dom::NOT_FROM_PARSER) \
 {                                                                          \
-  return NS_NewHTMLSharedElement(mozilla::Move(aNodeInfo), aFromParser);   \
+  return NS_NewHTMLSharedElement(std::move(aNodeInfo), aFromParser);   \
 }
 
 /**
  * A macro to implement the NS_NewHTMLXXXElement() functions.
  */
 #define NS_IMPL_NS_NEW_HTML_ELEMENT(_elementName)                            \
 nsGenericHTMLElement*                                                        \
 NS_NewHTML##_elementName##Element(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo, \
--- a/dom/html/nsHTMLContentSink.cpp
+++ b/dom/html/nsHTMLContentSink.cpp
@@ -243,17 +243,17 @@ CreateHTMLElement(uint32_t aNodeType,
                aNodeType == eHTMLTag_userdefined,
                "aNodeType is out of bounds");
 
   HTMLContentCreatorFunction cb = sHTMLContentCreatorFunctions[aNodeType];
 
   NS_ASSERTION(cb != NS_NewHTMLNOTUSEDElement,
                "Don't know how to construct tag element!");
 
-  RefPtr<nsGenericHTMLElement> result = cb(Move(aNodeInfo), aFromParser);
+  RefPtr<nsGenericHTMLElement> result = cb(std::move(aNodeInfo), aFromParser);
 
   return result.forget();
 }
 
 //----------------------------------------------------------------------
 
 SinkContext::SinkContext(HTMLContentSink* aSink)
   : mSink(aSink),
--- a/dom/indexedDB/ActorsChild.cpp
+++ b/dom/indexedDB/ActorsChild.cpp
@@ -3053,17 +3053,17 @@ BackgroundRequestChild::HandleResponse(
                              const SerializedStructuredCloneReadInfo& aResponse)
 {
   AssertIsOnOwningThread();
 
   // XXX Fix this somehow...
   auto& serializedCloneInfo =
     const_cast<SerializedStructuredCloneReadInfo&>(aResponse);
 
-  StructuredCloneReadInfo cloneReadInfo(Move(serializedCloneInfo));
+  StructuredCloneReadInfo cloneReadInfo(std::move(serializedCloneInfo));
 
   DeserializeStructuredCloneFiles(mTransaction->Database(),
                                   aResponse.files(),
                                   GetNextModuleSet(cloneReadInfo),
                                   cloneReadInfo.mFiles);
 
   ResultHelper helper(mRequest, mTransaction, &cloneReadInfo);
 
@@ -3088,26 +3088,26 @@ BackgroundRequestChild::HandleResponse(
     for (uint32_t index = 0; index < count; index++) {
       // XXX Fix this somehow...
       auto& serializedCloneInfo =
         const_cast<SerializedStructuredCloneReadInfo&>(aResponse[index]);
 
       StructuredCloneReadInfo* cloneReadInfo = cloneReadInfos.AppendElement();
 
       // Move relevant data into the cloneReadInfo
-      *cloneReadInfo = Move(serializedCloneInfo);
+      *cloneReadInfo = std::move(serializedCloneInfo);
 
       // Get the files
       nsTArray<StructuredCloneFile> files;
       DeserializeStructuredCloneFiles(database,
                                       serializedCloneInfo.files(),
                                       GetNextModuleSet(*cloneReadInfo),
                                       files);
 
-      cloneReadInfo->mFiles = Move(files);
+      cloneReadInfo->mFiles = std::move(files);
     }
   }
 
   ResultHelper helper(mRequest, mTransaction, &cloneReadInfos);
 
   DispatchSuccessEvent(&helper);
 }
 
@@ -3422,17 +3422,17 @@ PreprocessHelper::Init(const nsTArray<St
                                           errorResult);
     if (NS_WARN_IF(errorResult.Failed())) {
       return errorResult.StealNSResult();
     }
 
     streamPairs.AppendElement(StreamPair(bytecodeStream, compiledStream));
   }
 
-  mStreamPairs = Move(streamPairs);
+  mStreamPairs = std::move(streamPairs);
 
   return NS_OK;
 }
 
 nsresult
 BackgroundRequestChild::
 PreprocessHelper::Dispatch()
 {
@@ -3525,17 +3525,17 @@ PreprocessHelper::ProcessCurrentStreamPa
   if (NS_WARN_IF(!ok)) {
     ContinueWithStatus(NS_ERROR_FAILURE);
     return;
   }
 
   RefPtr<JS::WasmModule> module =
     JS::DeserializeWasmModule(mCurrentBytecodeFileDesc,
                               mCurrentCompiledFileDesc,
-                              Move(buildId),
+                              std::move(buildId),
                               nullptr,
                               0);
   if (NS_WARN_IF(!module)) {
     ContinueWithStatus(NS_ERROR_FAILURE);
     return;
   }
 
   mModuleSet.AppendElement(module);
@@ -3855,32 +3855,32 @@ BackgroundCursorChild::HandleResponse(
 
   MOZ_ASSERT(aResponses.Length() == 1);
 
   // XXX Fix this somehow...
   auto& responses =
     const_cast<nsTArray<ObjectStoreCursorResponse>&>(aResponses);
 
   for (ObjectStoreCursorResponse& response : responses) {
-    StructuredCloneReadInfo cloneReadInfo(Move(response.cloneInfo()));
+    StructuredCloneReadInfo cloneReadInfo(std::move(response.cloneInfo()));
     cloneReadInfo.mDatabase = mTransaction->Database();
 
     DeserializeStructuredCloneFiles(mTransaction->Database(),
                                     response.cloneInfo().files(),
                                     nullptr,
                                     cloneReadInfo.mFiles);
 
     RefPtr<IDBCursor> newCursor;
 
     if (mCursor) {
-      mCursor->Reset(Move(response.key()), Move(cloneReadInfo));
+      mCursor->Reset(std::move(response.key()), std::move(cloneReadInfo));
     } else {
       newCursor = IDBCursor::Create(this,
-                                    Move(response.key()),
-                                    Move(cloneReadInfo));
+                                    std::move(response.key()),
+                                    std::move(cloneReadInfo));
       mCursor = newCursor;
     }
   }
 
   ResultHelper helper(mRequest, mTransaction, mCursor);
   DispatchSuccessEvent(&helper);
 }
 
@@ -3896,19 +3896,19 @@ BackgroundCursorChild::HandleResponse(
   MOZ_ASSERT(!mStrongCursor);
 
   // XXX Fix this somehow...
   auto& response = const_cast<ObjectStoreKeyCursorResponse&>(aResponse);
 
   RefPtr<IDBCursor> newCursor;
 
   if (mCursor) {
-    mCursor->Reset(Move(response.key()));
+    mCursor->Reset(std::move(response.key()));
   } else {
-    newCursor = IDBCursor::Create(this, Move(response.key()));
+    newCursor = IDBCursor::Create(this, std::move(response.key()));
     mCursor = newCursor;
   }
 
   ResultHelper helper(mRequest, mTransaction, mCursor);
   DispatchSuccessEvent(&helper);
 }
 
 void
@@ -3919,37 +3919,37 @@ BackgroundCursorChild::HandleResponse(co
   MOZ_ASSERT(mTransaction);
   MOZ_ASSERT(mIndex);
   MOZ_ASSERT(!mStrongRequest);
   MOZ_ASSERT(!mStrongCursor);
 
   // XXX Fix this somehow...
   auto& response = const_cast<IndexCursorResponse&>(aResponse);
 
-  StructuredCloneReadInfo cloneReadInfo(Move(response.cloneInfo()));
+  StructuredCloneReadInfo cloneReadInfo(std::move(response.cloneInfo()));
   cloneReadInfo.mDatabase = mTransaction->Database();
 
   DeserializeStructuredCloneFiles(mTransaction->Database(),
                                   aResponse.cloneInfo().files(),
                                   nullptr,
                                   cloneReadInfo.mFiles);
 
   RefPtr<IDBCursor> newCursor;
 
   if (mCursor) {
-    mCursor->Reset(Move(response.key()),
-                   Move(response.sortKey()),
-                   Move(response.objectKey()),
-                   Move(cloneReadInfo));
+    mCursor->Reset(std::move(response.key()),
+                   std::move(response.sortKey()),
+                   std::move(response.objectKey()),
+                   std::move(cloneReadInfo));
   } else {
     newCursor = IDBCursor::Create(this,
-                                  Move(response.key()),
-                                  Move(response.sortKey()),
-                                  Move(response.objectKey()),
-                                  Move(cloneReadInfo));
+                                  std::move(response.key()),
+                                  std::move(response.sortKey()),
+                                  std::move(response.objectKey()),
+                                  std::move(cloneReadInfo));
     mCursor = newCursor;
   }
 
   ResultHelper helper(mRequest, mTransaction, mCursor);
   DispatchSuccessEvent(&helper);
 }
 
 void
@@ -3963,24 +3963,24 @@ BackgroundCursorChild::HandleResponse(co
   MOZ_ASSERT(!mStrongCursor);
 
   // XXX Fix this somehow...
   auto& response = const_cast<IndexKeyCursorResponse&>(aResponse);
 
   RefPtr<IDBCursor> newCursor;
 
   if (mCursor) {
-    mCursor->Reset(Move(response.key()),
-                   Move(response.sortKey()),
-                   Move(response.objectKey()));
+    mCursor->Reset(std::move(response.key()),
+                   std::move(response.sortKey()),
+                   std::move(response.objectKey()));
   } else {
     newCursor = IDBCursor::Create(this,
-                                  Move(response.key()),
-                                  Move(response.sortKey()),
-                                  Move(response.objectKey()));
+                                  std::move(response.key()),
+                                  std::move(response.sortKey()),
+                                  std::move(response.objectKey()));
     mCursor = newCursor;
   }
 
   ResultHelper helper(mRequest, mTransaction, mCursor);
   DispatchSuccessEvent(&helper);
 }
 
 void
--- a/dom/indexedDB/ActorsParent.cpp
+++ b/dom/indexedDB/ActorsParent.cpp
@@ -7786,17 +7786,17 @@ class DeleteDatabaseOp final
   nsString mDatabaseDirectoryPath;
   nsString mDatabaseFilenameBase;
   uint64_t mPreviousVersion;
 
 public:
   DeleteDatabaseOp(Factory* aFactory,
                    already_AddRefed<ContentParent> aContentParent,
                    const CommonFactoryRequestParams& aParams)
-    : FactoryOp(aFactory, Move(aContentParent), aParams, /* aDeleting */ true)
+    : FactoryOp(aFactory, std::move(aContentParent), aParams, /* aDeleting */ true)
     , mPreviousVersion(0)
   { }
 
 private:
   ~DeleteDatabaseOp() override = default;
 
   void
   LoadPreviousVersion(nsIFile* aDatabaseFile);
@@ -8425,17 +8425,17 @@ private:
   ~ObjectStoreDeleteRequestOp() override = default;
 
   nsresult
   DoDatabaseWork(DatabaseConnection* aConnection) override;
 
   void
   GetResponse(RequestResponse& aResponse, size_t* aResponseSize) override
   {
-    aResponse = Move(mResponse);
+    aResponse = std::move(mResponse);
     *aResponseSize = 0;
   }
 };
 
 class ObjectStoreClearRequestOp final
   : public NormalTransactionOp
 {
   friend class TransactionBase;
@@ -8451,17 +8451,17 @@ private:
   ~ObjectStoreClearRequestOp() override = default;
 
   nsresult
   DoDatabaseWork(DatabaseConnection* aConnection) override;
 
   void
   GetResponse(RequestResponse& aResponse, size_t* aResponseSize) override
   {
-    aResponse = Move(mResponse);
+    aResponse = std::move(mResponse);
     *aResponseSize = 0;
   }
 };
 
 class ObjectStoreCountRequestOp final
   : public NormalTransactionOp
 {
   friend class TransactionBase;
@@ -8479,17 +8479,17 @@ private:
   ~ObjectStoreCountRequestOp() override = default;
 
   nsresult
   DoDatabaseWork(DatabaseConnection* aConnection) override;
 
   void
   GetResponse(RequestResponse& aResponse, size_t* aResponseSize) override
   {
-    aResponse = Move(mResponse);
+    aResponse = std::move(mResponse);
     *aResponseSize = sizeof(uint64_t);
   }
 };
 
 class IndexRequestOpBase
   : public NormalTransactionOp
 {
 protected:
@@ -8582,17 +8582,17 @@ private:
   ~IndexCountRequestOp() override = default;
 
   nsresult
   DoDatabaseWork(DatabaseConnection* aConnection) override;
 
   void
   GetResponse(RequestResponse& aResponse, size_t* aResponseSize) override
   {
-    aResponse = Move(mResponse);
+    aResponse = std::move(mResponse);
     *aResponseSize = sizeof(uint64_t);
   }
 };
 
 class Cursor final :
     public PBackgroundIDBCursorParent
 {
   friend class TransactionBase;
@@ -9346,37 +9346,37 @@ struct Maintenance::DirectoryInfo final
   const PersistenceType mPersistenceType;
 
   DirectoryInfo(PersistenceType aPersistenceType,
                 const nsACString& aGroup,
                 const nsACString& aOrigin,
                 nsTArray<nsString>&& aDatabasePaths)
    : mGroup(aGroup)
    , mOrigin(aOrigin)
-   , mDatabasePaths(Move(aDatabasePaths))
+   , mDatabasePaths(std::move(aDatabasePaths))
    , mPersistenceType(aPersistenceType)
   {
     MOZ_ASSERT(aPersistenceType != PERSISTENCE_TYPE_INVALID);
     MOZ_ASSERT(!aGroup.IsEmpty());
     MOZ_ASSERT(!aOrigin.IsEmpty());
 #ifdef DEBUG
     MOZ_ASSERT(!mDatabasePaths.IsEmpty());
     for (const nsString& databasePath : mDatabasePaths) {
       MOZ_ASSERT(!databasePath.IsEmpty());
     }
 #endif
 
     MOZ_COUNT_CTOR(Maintenance::DirectoryInfo);
   }
 
   DirectoryInfo(DirectoryInfo&& aOther)
-    : mGroup(Move(aOther.mGroup))
-    , mOrigin(Move(aOther.mOrigin))
-    , mDatabasePaths(Move(aOther.mDatabasePaths))
-    , mPersistenceType(Move(aOther.mPersistenceType))
+    : mGroup(std::move(aOther.mGroup))
+    , mOrigin(std::move(aOther.mOrigin))
+    , mDatabasePaths(std::move(aOther.mDatabasePaths))
+    , mPersistenceType(std::move(aOther.mPersistenceType))
   {
 #ifdef DEBUG
     MOZ_ASSERT(!mDatabasePaths.IsEmpty());
     for (const nsString& databasePath : mDatabasePaths) {
       MOZ_ASSERT(!databasePath.IsEmpty());
     }
 #endif
 
@@ -9758,17 +9758,17 @@ CheckWasmModule(FileHelper* aFileHelper,
 
     JS::BuildIdCharVector buildId;
     bool ok = GetBuildId(&buildId);
     if (NS_WARN_IF(!ok)) {
       return NS_ERROR_FAILURE;
     }
 
     match = JS::CompiledWasmModuleAssumptionsMatch(compiledFileDesc,
-                                                   Move(buildId));
+                                                   std::move(buildId));
   }
   if (match) {
     return NS_OK;
   }
 
   // Re-compile the module.  It would be preferable to do this in the child
   // (content process) instead of here in the parent, but that would be way more
   // complex and without significant memory allocation or security benefits.
@@ -9791,17 +9791,17 @@ CheckWasmModule(FileHelper* aFileHelper,
   JS::BuildIdCharVector buildId;
   bool ok = GetBuildId(&buildId);
   if (NS_WARN_IF(!ok)) {
     return NS_ERROR_FAILURE;
   }
 
   RefPtr<JS::WasmModule> module = JS::DeserializeWasmModule(bytecodeFileDesc,
                                                             nullptr,
-                                                            Move(buildId),
+                                                            std::move(buildId),
                                                             nullptr,
                                                             0);
   if (NS_WARN_IF(!module)) {
     return NS_ERROR_FAILURE;
   }
 
   size_t compiledSize = module->compiledSerializedSize();
   UniquePtr<uint8_t[]> compiled(new (fallible) uint8_t[compiledSize]);
@@ -12238,17 +12238,17 @@ ConnectionPool::WaitForDatabasesToComple
   }
 
   if (mayRunCallbackImmediately) {
     Unused << aCallback->Run();
     return;
   }
 
   nsAutoPtr<DatabasesCompleteCallback> callback(
-    new DatabasesCompleteCallback(Move(aDatabaseIds), aCallback));
+    new DatabasesCompleteCallback(std::move(aDatabaseIds), aCallback));
   mCompleteCallbacks.AppendElement(callback.forget());
 }
 
 void
 ConnectionPool::Shutdown()
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(!mShutdownRequested);
@@ -13077,17 +13077,17 @@ DatabaseInfo::~DatabaseInfo()
 
   MOZ_COUNT_DTOR(ConnectionPool::DatabaseInfo);
 }
 
 ConnectionPool::
 DatabasesCompleteCallback::DatabasesCompleteCallback(
                                              nsTArray<nsCString>&& aDatabaseIds,
                                              nsIRunnable* aCallback)
-  : mDatabaseIds(Move(aDatabaseIds))
+  : mDatabaseIds(std::move(aDatabaseIds))
   , mCallback(aCallback)
 {
   AssertIsOnBackgroundThread();
   MOZ_ASSERT(!mDatabaseIds.IsEmpty());
   MOZ_ASSERT(aCallback);
 
   MOZ_COUNT_CTOR(ConnectionPool::DatabasesCompleteCallback);
 }
@@ -13145,18 +13145,18 @@ FinishCallbackWrapper::Run()
       mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
 
     return NS_OK;
   }
 
   mConnectionPool->AssertIsOnOwningThread();
   MOZ_ASSERT(mHasRunOnce);
 
-  RefPtr<ConnectionPool> connectionPool = Move(mConnectionPool);
-  RefPtr<FinishCallback> callback = Move(mCallback);
+  RefPtr<ConnectionPool> connectionPool = std::move(mConnectionPool);
+  RefPtr<FinishCallback> callback = std::move(mCallback);
 
   callback->TransactionFinishedBeforeUnblock();
 
   connectionPool->NoteFinishedTransaction(mTransactionId);
 
   callback->TransactionFinishedAfterUnblock();
 
   return NS_OK;
@@ -13535,17 +13535,17 @@ DatabaseLoggingInfo::~DatabaseLoggingInf
   }
 }
 
 /*******************************************************************************
  * Factory
  ******************************************************************************/
 
 Factory::Factory(already_AddRefed<DatabaseLoggingInfo> aLoggingInfo)
-  : mLoggingInfo(Move(aLoggingInfo))
+  : mLoggingInfo(std::move(aLoggingInfo))
 #ifdef DEBUG
   , mActorDestroyed(false)
 #endif
 {
   AssertIsOnBackgroundThread();
   MOZ_ASSERT(!QuotaClient::IsShuttingDownOnBackgroundThread());
 }
 
@@ -13775,17 +13775,17 @@ WaitForTransactionsHelper::MaybeWaitForT
 
   RefPtr<ConnectionPool> connectionPool = gConnectionPool.get();
   if (connectionPool) {
     nsTArray<nsCString> ids(1);
     ids.AppendElement(mDatabaseId);
 
     mState = State::WaitingForTransactions;
 
-    connectionPool->WaitForDatabasesToComplete(Move(ids), this);
+    connectionPool->WaitForDatabasesToComplete(std::move(ids), this);
     return;
   }
 
   MaybeWaitForFileHandles();
 }
 
 void
 WaitForTransactionsHelper::MaybeWaitForFileHandles()
@@ -13796,17 +13796,17 @@ WaitForTransactionsHelper::MaybeWaitForF
   RefPtr<FileHandleThreadPool> fileHandleThreadPool =
     gFileHandleThreadPool.get();
   if (fileHandleThreadPool) {
     nsTArray<nsCString> ids(1);
     ids.AppendElement(mDatabaseId);
 
     mState = State::WaitingForFileHandles;
 
-    fileHandleThreadPool->WaitForDirectoriesToComplete(Move(ids), this);
+    fileHandleThreadPool->WaitForDirectoriesToComplete(std::move(ids), this);
     return;
   }
 
   CallCallback();
 }
 
 void
 WaitForTransactionsHelper::CallCallback()
@@ -13863,17 +13863,17 @@ Database::Database(Factory* aFactory,
                    FullDatabaseMetadata* aMetadata,
                    FileManager* aFileManager,
                    already_AddRefed<DirectoryLock> aDirectoryLock,
                    bool aFileHandleDisabled,
                    bool aChromeWriteAccessAllowed)
   : mFactory(aFactory)
   , mMetadata(aMetadata)
   , mFileManager(aFileManager)
-  , mDirectoryLock(Move(aDirectoryLock))
+  , mDirectoryLock(std::move(aDirectoryLock))
   , mPrincipalInfo(aPrincipalInfo)
   , mOptionalContentParentId(aOptionalContentParentId)
   , mGroup(aGroup)
   , mOrigin(aOrigin)
   , mId(aMetadata->mDatabaseId)
   , mFilePath(aMetadata->mFilePath)
   , mActiveMutableFileCount(0)
   , mTelemetryId(aTelemetryId)
@@ -17497,17 +17497,17 @@ QuotaClient::GetOrCreateThreadPool()
     // Don't keep more than one idle thread.
     MOZ_ALWAYS_SUCCEEDS(threadPool->SetIdleThreadLimit(1));
 
     // Don't keep idle threads alive very long.
     MOZ_ALWAYS_SUCCEEDS(threadPool->SetIdleThreadTimeout(5 * PR_MSEC_PER_SEC));
 
     MOZ_ALWAYS_SUCCEEDS(threadPool->SetName(NS_LITERAL_CSTRING("IndexedDB Mnt")));
 
-    mMaintenanceThreadPool = Move(threadPool);
+    mMaintenanceThreadPool = std::move(threadPool);
   }
 
   return mMaintenanceThreadPool;
 }
 
 mozilla::dom::quota::Client::Type
 QuotaClient::GetType()
 {
@@ -18564,17 +18564,17 @@ Maintenance::DirectoryWork()
 
         databasePaths.AppendElement(idbFilePath);
       }
 
       if (!databasePaths.IsEmpty()) {
         mDirectoryInfos.AppendElement(DirectoryInfo(persistenceType,
                                                     group,
                                                     origin,
-                                                    Move(databasePaths)));
+                                                    std::move(databasePaths)));
 
         nsCOMPtr<nsIFile> directory;
 
         // Idle maintenance may occur before origin is initailized.
         // Ensure origin is initialized first. It will initialize all origins
         // for temporary storage including IDB origins.
         rv = quotaManager->EnsureOriginIsInitialized(persistenceType,
                                                      suffix,
@@ -20652,17 +20652,17 @@ MutableFile::RecvGetFileId(int64_t* aFil
 
 FactoryOp::FactoryOp(Factory* aFactory,
                      already_AddRefed<ContentParent> aContentParent,
                      const CommonFactoryRequestParams& aCommonParams,
                      bool aDeleting)
   : DatabaseOperationBase(aFactory->GetLoggingInfo()->Id(),
                           aFactory->GetLoggingInfo()->NextRequestSN())
   , mFactory(aFactory)
-  , mContentParent(Move(aContentParent))
+  , mContentParent(std::move(aContentParent))
   , mCommonParams(aCommonParams)
   , mState(State::Initial)
   , mEnforcingQuota(true)
   , mDeleting(aDeleting)
   , mChromeWriteAccessAllowed(false)
   , mFileHandleDisabled(false)
 {
   AssertIsOnBackgroundThread();
@@ -21422,17 +21422,17 @@ FactoryOp::RecvPermissionRetry()
   MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));
 
   return IPC_OK();
 }
 
 OpenDatabaseOp::OpenDatabaseOp(Factory* aFactory,
                                already_AddRefed<ContentParent> aContentParent,
                                const CommonFactoryRequestParams& aParams)
-  : FactoryOp(aFactory, Move(aContentParent), aParams, /* aDeleting */ false)
+  : FactoryOp(aFactory, std::move(aContentParent), aParams, /* aDeleting */ false)
   , mMetadata(new FullDatabaseMetadata(aParams.metadata()))
   , mRequestedVersion(aParams.metadata().version())
   , mVersionChangeOp(nullptr)
   , mTelemetryId(0)
 {
   if (mContentParent) {
     // This is a little scary but it looks safe to call this off the main thread
     // for now.
@@ -26505,17 +26505,17 @@ template <typename T>
 void MoveData(StructuredCloneReadInfo& aInfo, T& aResult);
 
 template <>
 void
 MoveData<SerializedStructuredCloneReadInfo>(
                                      StructuredCloneReadInfo& aInfo,
                                      SerializedStructuredCloneReadInfo& aResult)
 {
-  aResult.data().data = Move(aInfo.mData);
+  aResult.data().data = std::move(aInfo.mData);
   aResult.hasPreprocessInfo() = aInfo.mHasPreprocessInfo;
 }
 
 template <>
 void
 MoveData<WasmModulePreprocessInfo>(StructuredCloneReadInfo& aInfo,
                                    WasmModulePreprocessInfo& aResult)
 {
@@ -26859,17 +26859,17 @@ ObjectStoreGetKeyRequestOp::GetResponse(
     return;
   }
 
   aResponse = ObjectStoreGetKeyResponse();
   *aResponseSize = 0;
 
   if (!mResponse.IsEmpty()) {
     *aResponseSize = mResponse[0].GetBuffer().Length();
-    aResponse.get_ObjectStoreGetKeyResponse().key() = Move(mResponse[0]);
+    aResponse.get_ObjectStoreGetKeyResponse().key() = std::move(mResponse[0]);
   }
 }
 
 ObjectStoreDeleteRequestOp::ObjectStoreDeleteRequestOp(
                                          TransactionBase* aTransaction,
                                          const ObjectStoreDeleteParams& aParams)
   : NormalTransactionOp(aTransaction)
   , mParams(aParams)
@@ -27316,17 +27316,17 @@ IndexGetRequestOp::GetResponse(RequestRe
            index < count;
            index++) {
         StructuredCloneReadInfo& info = mResponse[index];
         *aResponseSize += info.Size();
 
         SerializedStructuredCloneReadInfo& serializedInfo =
           fallibleCloneInfos[index];
 
-        serializedInfo.data().data = Move(info.mData);
+        serializedInfo.data().data = std::move(info.mData);
 
         FallibleTArray<SerializedStructuredCloneFile> serializedFiles;
         nsresult rv = SerializeStructuredCloneFiles(mBackgroundParent,
                                                     mDatabase,
                                                     info.mFiles,
                                                     /* aForPreprocess */ false,
                                                     serializedFiles);
         if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -27353,17 +27353,17 @@ IndexGetRequestOp::GetResponse(RequestRe
 
   if (!mResponse.IsEmpty()) {
     StructuredCloneReadInfo& info = mResponse[0];
     *aResponseSize += info.Size();
 
     SerializedStructuredCloneReadInfo& serializedInfo =
       aResponse.get_IndexGetResponse().cloneInfo();
 
-    serializedInfo.data().data = Move(info.mData);
+    serializedInfo.data().data = std::move(info.mData);
 
     FallibleTArray<SerializedStructuredCloneFile> serializedFiles;
     nsresult rv =
       SerializeStructuredCloneFiles(mBackgroundParent,
                                     mDatabase,
                                     info.mFiles,
                                     /* aForPreprocess */ false,
                                     serializedFiles);
@@ -27502,17 +27502,17 @@ IndexGetKeyRequestOp::GetResponse(Reques
     return;
   }
 
   aResponse = IndexGetKeyResponse();
   *aResponseSize = 0;
 
   if (!mResponse.IsEmpty()) {
     *aResponseSize = mResponse[0].GetBuffer().Length();
-    aResponse.get_IndexGetKeyResponse().key() = Move(mResponse[0]);
+    aResponse.get_IndexGetKeyResponse().key() = std::move(mResponse[0]);
   }
 }
 
 nsresult
 IndexCountRequestOp::DoDatabaseWork(DatabaseConnection* aConnection)
 {
   MOZ_ASSERT(aConnection);
   aConnection->AssertIsOnConnectionThread();
@@ -27676,20 +27676,20 @@ CursorOpBase::PopulateResponseFromStatem
         mResponse = nsTArray<ObjectStoreCursorResponse>();
       } else {
         MOZ_ASSERT(mResponse.type() ==
                      CursorResponse::TArrayOfObjectStoreCursorResponse);
       }
 
       auto& responses = mResponse.get_ArrayOfObjectStoreCursorResponse();
       auto& response = *responses.AppendElement();
-      response.cloneInfo().data().data = Move(cloneInfo.mData);
+      response.cloneInfo().data().data = std::move(cloneInfo.mData);
       response.key() = mCursor->mKey;
 
-      mFiles.AppendElement(Move(cloneInfo.mFiles));
+      mFiles.AppendElement(std::move(cloneInfo.mFiles));
       break;
     }
 
     case OpenCursorParams::TObjectStoreOpenKeyCursorParams: {
       MOZ_ASSERT(aInitializeResponse);
       mResponse = ObjectStoreKeyCursorResponse(mCursor->mKey);
       break;
     }
@@ -27719,22 +27719,22 @@ CursorOpBase::PopulateResponseFromStatem
         IDB_WARNING("Preprocessing for cursors not yet implemented!");
         return NS_ERROR_NOT_IMPLEMENTED;
       }
 
       MOZ_ASSERT(aInitializeResponse);
       mResponse = IndexCursorResponse();
 
       auto& response = mResponse.get_IndexCursorResponse();
-      response.cloneInfo().data().data = Move(cloneInfo.mData);
+      response.cloneInfo().data().data = std::move(cloneInfo.mData);
       response.key() = mCursor->mKey;
       response.sortKey() = mCursor->mSortKey;
       response.objectKey() = mCursor->mObjectKey;
 
-      mFiles.AppendElement(Move(cloneInfo.mFiles));
+      mFiles.AppendElement(std::move(cloneInfo.mFiles));
       break;
     }
 
     case OpenCursorParams::TIndexOpenKeyCursorParams: {
       rv = mCursor->mSortKey.SetFromStatement(aStmt, 1);
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
@@ -29100,18 +29100,18 @@ FileHelper::Init()
   DebugOnly<bool> exists;
   MOZ_ASSERT(NS_SUCCEEDED(journalDirectory->Exists(&exists)));
   MOZ_ASSERT(exists);
 
   DebugOnly<bool> isDirectory;
   MOZ_ASSERT(NS_SUCCEEDED(journalDirectory->IsDirectory(&isDirectory)));
   MOZ_ASSERT(isDirectory);
 
-  mFileDirectory = Move(fileDirectory);
-  mJournalDirectory= Move(journalDirectory);
+  mFileDirectory = std::move(fileDirectory);
+  mJournalDirectory= std::move(journalDirectory);
 
   return NS_OK;
 }
 
 already_AddRefed<nsIFile>
 FileHelper::GetFile(FileInfo* aFileInfo)
 {
   MOZ_ASSERT(!IsOnBackgroundThread());
--- a/dom/indexedDB/IDBCursor.cpp
+++ b/dom/indexedDB/IDBCursor.cpp
@@ -93,17 +93,17 @@ IDBCursor::Create(BackgroundCursorChild*
   aBackgroundActor->AssertIsOnOwningThread();
   MOZ_ASSERT(aBackgroundActor->GetObjectStore());
   MOZ_ASSERT(!aBackgroundActor->GetIndex());
   MOZ_ASSERT(!aKey.IsUnset());
 
   RefPtr<IDBCursor> cursor =
     new IDBCursor(Type_ObjectStore, aBackgroundActor, aKey);
 
-  cursor->mCloneInfo = Move(aCloneInfo);
+  cursor->mCloneInfo = std::move(aCloneInfo);
 
   return cursor.forget();
 }
 
 // static
 already_AddRefed<IDBCursor>
 IDBCursor::Create(BackgroundCursorChild* aBackgroundActor,
                   const Key& aKey)
@@ -133,19 +133,19 @@ IDBCursor::Create(BackgroundCursorChild*
   MOZ_ASSERT(aBackgroundActor->GetIndex());
   MOZ_ASSERT(!aBackgroundActor->GetObjectStore());
   MOZ_ASSERT(!aKey.IsUnset());
   MOZ_ASSERT(!aPrimaryKey.IsUnset());
 
   RefPtr<IDBCursor> cursor =
     new IDBCursor(Type_Index, aBackgroundActor, aKey);
 
-  cursor->mSortKey = Move(aSortKey);
-  cursor->mPrimaryKey = Move(aPrimaryKey);
-  cursor->mCloneInfo = Move(aCloneInfo);
+  cursor->mSortKey = std::move(aSortKey);
+  cursor->mPrimaryKey = std::move(aPrimaryKey);
+  cursor->mCloneInfo = std::move(aCloneInfo);
 
   return cursor.forget();
 }
 
 // static
 already_AddRefed<IDBCursor>
 IDBCursor::Create(BackgroundCursorChild* aBackgroundActor,
                   const Key& aKey,
@@ -157,18 +157,18 @@ IDBCursor::Create(BackgroundCursorChild*
   MOZ_ASSERT(aBackgroundActor->GetIndex());
   MOZ_ASSERT(!aBackgroundActor->GetObjectStore());
   MOZ_ASSERT(!aKey.IsUnset());
   MOZ_ASSERT(!aPrimaryKey.IsUnset());
 
   RefPtr<IDBCursor> cursor =
     new IDBCursor(Type_IndexKey, aBackgroundActor, aKey);
 
-  cursor->mSortKey = Move(aSortKey);
-  cursor->mPrimaryKey = Move(aPrimaryKey);
+  cursor->mSortKey = std::move(aSortKey);
+  cursor->mPrimaryKey = std::move(aPrimaryKey);
 
   return cursor.forget();
 }
 
 // static
 auto
 IDBCursor::ConvertDirection(IDBCursorDirection aDirection) -> Direction
 {
@@ -877,67 +877,67 @@ IDBCursor::Delete(JSContext* aCx, ErrorR
 void
 IDBCursor::Reset(Key&& aKey, StructuredCloneReadInfo&& aValue)
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(mType == Type_ObjectStore);
 
   Reset();
 
-  mKey = Move(aKey);
-  mCloneInfo = Move(aValue);
+  mKey = std::move(aKey);
+  mCloneInfo = std::move(aValue);
 
   mHaveValue = !mKey.IsUnset();
 }
 
 void
 IDBCursor::Reset(Key&& aKey)
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(mType == Type_ObjectStoreKey);
 
   Reset();
 
-  mKey = Move(aKey);
+  mKey = std::move(aKey);
 
   mHaveValue = !mKey.IsUnset();
 }
 
 void
 IDBCursor::Reset(Key&& aKey,
                  Key&& aSortKey,
                  Key&& aPrimaryKey,
                  StructuredCloneReadInfo&& aValue)
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(mType == Type_Index);
 
   Reset();
 
-  mKey = Move(aKey);
-  mSortKey = Move(aSortKey);
-  mPrimaryKey = Move(aPrimaryKey);
-  mCloneInfo = Move(aValue);
+  mKey = std::move(aKey);
+  mSortKey = std::move(aSortKey);
+  mPrimaryKey = std::move(aPrimaryKey);
+  mCloneInfo = std::move(aValue);
 
   mHaveValue = !mKey.IsUnset();
 }
 
 void
 IDBCursor::Reset(Key&& aKey,
                  Key&& aSortKey,
                  Key&& aPrimaryKey)
 {
   AssertIsOnOwningThread();
   MOZ_ASSERT(mType == Type_IndexKey);
 
   Reset();
 
-  mKey = Move(aKey);
-  mSortKey = Move(aSortKey);
-  mPrimaryKey = Move(aPrimaryKey);
+  mKey = std::move(aKey);
+  mSortKey = std::move(aSortKey);
+  mPrimaryKey = std::move(aPrimaryKey);
 
   mHaveValue = !mKey.IsUnset();
 }
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(IDBCursor)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(IDBCursor)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(IDBCursor)
--- a/dom/indexedDB/IDBFactory.cpp
+++ b/dom/indexedDB/IDBFactory.cpp
@@ -137,17 +137,17 @@ IDBFactory::CreateForWindow(nsPIDOMWindo
 
   MOZ_ASSERT(principalInfo->type() == PrincipalInfo::TContentPrincipalInfo ||
              principalInfo->type() == PrincipalInfo::TSystemPrincipalInfo);
 
   nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
   nsCOMPtr<nsILoadContext> loadContext = do_QueryInterface(webNav);
 
   RefPtr<IDBFactory> factory = new IDBFactory();
-  factory->mPrincipalInfo = Move(principalInfo);
+  factory->mPrincipalInfo = std::move(principalInfo);
   factory->mWindow = aWindow;
   factory->mTabChild = TabChild::GetFrom(aWindow);
   factory->mEventTarget =
     nsGlobalWindowInner::Cast(aWindow)->EventTargetFor(TaskCategory::Other);
   factory->mInnerWindowID = aWindow->WindowID();
   factory->mPrivateBrowsingMode =
     loadContext && loadContext->UsePrivateBrowsing();
 
--- a/dom/indexedDB/IDBIndex.cpp
+++ b/dom/indexedDB/IDBIndex.cpp
@@ -508,40 +508,40 @@ IDBIndex::OpenCursorInternal(bool aKeysO
   int64_t indexId = Id();
 
   OptionalKeyRange optionalKeyRange;
 
   if (keyRange) {
     SerializedKeyRange serializedKeyRange;
     keyRange->ToSerialized(serializedKeyRange);
 
-    optionalKeyRange = Move(serializedKeyRange);
+    optionalKeyRange = std::move(serializedKeyRange);
   } else {
     optionalKeyRange = void_t();
   }
 
   IDBCursor::Direction direction = IDBCursor::ConvertDirection(aDirection);
 
   OpenCursorParams params;
   if (aKeysOnly) {
     IndexOpenKeyCursorParams openParams;
     openParams.objectStoreId() = objectStoreId;
     openParams.indexId() = indexId;
-    openParams.optionalKeyRange() = Move(optionalKeyRange);
+    openParams.optionalKeyRange() = std::move(optionalKeyRange);
     openParams.direction() = direction;
 
-    params = Move(openParams);
+    params = std::move(openParams);
   } else {
     IndexOpenCursorParams openParams;
     openParams.objectStoreId() = objectStoreId;
     openParams.indexId() = indexId;
-    openParams.optionalKeyRange() = Move(optionalKeyRange);
+    openParams.optionalKeyRange() = std::move(optionalKeyRange);
     openParams.direction() = direction;
 
-    params = Move(openParams);
+    params = std::move(openParams);
   }
 
   RefPtr<IDBRequest> request = GenerateRequest(aCx, this);
   MOZ_ASSERT(request);
 
   if (aKeysOnly) {
     IDB_LOG_MARK("IndexedDB %s: Child  Transaction[%lld] Request[%llu]: "
                    "database(%s).transaction(%s).objectStore(%s).index(%s)."
--- a/dom/indexedDB/IDBObjectStore.cpp
+++ b/dom/indexedDB/IDBObjectStore.cpp
@@ -79,17 +79,17 @@ struct IDBObjectStore::StructuredCloneWr
     , mOffsetToKeyProp(0)
   {
     MOZ_ASSERT(aDatabase);
 
     MOZ_COUNT_CTOR(StructuredCloneWriteInfo);
   }
 
   StructuredCloneWriteInfo(StructuredCloneWriteInfo&& aCloneWriteInfo)
-    : mCloneBuffer(Move(aCloneWriteInfo.mCloneBuffer))
+    : mCloneBuffer(std::move(aCloneWriteInfo.mCloneBuffer))
     , mDatabase(aCloneWriteInfo.mDatabase)
     , mOffsetToKeyProp(aCloneWriteInfo.mOffsetToKeyProp)
   {
     MOZ_ASSERT(mDatabase);
 
     MOZ_COUNT_CTOR(StructuredCloneWriteInfo);
 
     mFiles.SwapElements(aCloneWriteInfo.mFiles);
@@ -460,17 +460,17 @@ private:
 
     nsCString compiled;
     compiled.SetLength(compiledSize);
 
     mModule->compiledSerialize(
       reinterpret_cast<uint8_t*>(compiled.BeginWriting()), compiledSize);
 
     MOZ_ALWAYS_SUCCEEDS(NS_NewCStringInputStream(getter_AddRefs(mStream),
-                                                 Move(compiled)));
+                                                 std::move(compiled)));
 
     mModule = nullptr;
 
     CallCallback();
   }
 };
 
 NS_IMPL_ISUPPORTS(WasmCompiledModuleStream,
@@ -1836,17 +1836,17 @@ IDBObjectStore::AddOrPut(JSContext* aCx,
       nsPrintfCString("The serialized value is too large"
                       " (size=%zu bytes, max=%zu bytes).",
                       messageSize, kMaxMessageSize));
     return nullptr;
   }
 
   ObjectStoreAddPutParams commonParams;
   commonParams.objectStoreId() = Id();
-  commonParams.cloneInfo().data().data = Move(cloneWriteInfo.mCloneBuffer.data());
+  commonParams.cloneInfo().data().data = std::move(cloneWriteInfo.mCloneBuffer.data());
   commonParams.cloneInfo().offsetToKeyProp() = cloneWriteInfo.mOffsetToKeyProp;
   commonParams.key() = key;
   commonParams.indexUpdateInfos().SwapElements(updateInfo);
 
   // Convert any blobs or mutable files into FileAddInfo.
   nsTArray<StructuredCloneFile>& files = cloneWriteInfo.mFiles;
 
   if (!files.IsEmpty()) {
@@ -2635,38 +2635,38 @@ IDBObjectStore::OpenCursorInternal(bool 
   int64_t objectStoreId = Id();
 
   OptionalKeyRange optionalKeyRange;
 
   if (keyRange) {
     SerializedKeyRange serializedKeyRange;
     keyRange->ToSerialized(serializedKeyRange);
 
-    optionalKeyRange = Move(serializedKeyRange);
+    optionalKeyRange = std::move(serializedKeyRange);
   } else {
     optionalKeyRange = void_t();
   }
 
   IDBCursor::Direction direction = IDBCursor::ConvertDirection(aDirection);
 
   OpenCursorParams params;
   if (aKeysOnly) {
     ObjectStoreOpenKeyCursorParams openParams;
     openParams.objectStoreId() = objectStoreId;
-    openParams.optionalKeyRange() = Move(optionalKeyRange);
+    openParams.optionalKeyRange() = std::move(optionalKeyRange);
     openParams.direction() = direction;
 
-    params = Move(openParams);
+    params = std::move(openParams);
   } else {
     ObjectStoreOpenCursorParams openParams;
     openParams.objectStoreId() = objectStoreId;
-    openParams.optionalKeyRange() = Move(optionalKeyRange);
+    openParams.optionalKeyRange() = std::move(optionalKeyRange);
     openParams.direction() = direction;
 
-    params = Move(openParams);
+    params = std::move(openParams);
   }
 
   RefPtr<IDBRequest> request = GenerateRequest(aCx, this);
   MOZ_ASSERT(request);
 
   if (aKeysOnly) {
     IDB_LOG_MARK("IndexedDB %s: Child  Transaction[%lld] Request[%llu]: "
                    "database(%s).transaction(%s).objectStore(%s)."
--- a/dom/indexedDB/IDBTransaction.cpp
+++ b/dom/indexedDB/IDBTransaction.cpp
@@ -237,17 +237,17 @@ IDBTransaction::Create(JSContext* aCx, I
       // Silence the destructor assertion if we never made this object live.
 #ifdef DEBUG
       MOZ_ASSERT(!transaction->mSentCommitOrAbort);
       transaction->mSentCommitOrAbort = true;
 #endif
       return nullptr;
     }
 
-    transaction->mWorkerHolder = Move(workerHolder);
+    transaction->mWorkerHolder = std::move(workerHolder);
   }
 
   nsCOMPtr<nsIRunnable> runnable = do_QueryObject(transaction);
   nsContentUtils::AddPendingIDBTransaction(runnable.forget());
 
   transaction->mCreating = true;
 
   aDatabase->RegisterTransaction(transaction);
@@ -816,17 +816,17 @@ IDBTransaction::FireCompleteOrAbortEvent
 
   mReadyState = DONE;
 
 #ifdef DEBUG
   mFiredCompleteOrAbort = true;
 #endif
 
   // Make sure we drop the WorkerHolder when this function completes.
-  nsAutoPtr<WorkerHolder> workerHolder = Move(mWorkerHolder);
+  nsAutoPtr<WorkerHolder> workerHolder = std::move(mWorkerHolder);
 
   RefPtr<Event> event;
   if (NS_SUCCEEDED(aResult)) {
     event = CreateGenericEvent(this,
                                nsDependentString(kCompleteEventType),
                                eDoesNotBubble,
                                eNotCancelable);
     MOZ_ASSERT(event);
@@ -1076,17 +1076,17 @@ WorkerHolder::Notify(WorkerStatus aStatu
 {
   MOZ_ASSERT(mWorkerPrivate);
   mWorkerPrivate->AssertIsOnWorkerThread();
   MOZ_ASSERT(aStatus > Running);
 
   if (mTransaction && aStatus > Terminating) {
     mTransaction->AssertIsOnOwningThread();
 
-    RefPtr<IDBTransaction> transaction = Move(mTransaction);
+    RefPtr<IDBTransaction> transaction = std::move(mTransaction);
 
     if (!transaction->IsCommittingOrDone()) {
       IDB_REPORT_INTERNAL_ERR();
       transaction->AbortInternal(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR, nullptr);
     }
   }
 
   return true;
--- a/dom/indexedDB/IndexedDatabaseInlines.h
+++ b/dom/indexedDB/IndexedDatabaseInlines.h
@@ -57,33 +57,33 @@ inline
 StructuredCloneReadInfo::StructuredCloneReadInfo()
  : StructuredCloneReadInfo(JS::StructuredCloneScope::DifferentProcessForIndexedDB)
 {
 }
 
 inline
 StructuredCloneReadInfo::StructuredCloneReadInfo(
                              StructuredCloneReadInfo&& aCloneReadInfo)
-  : mData(Move(aCloneReadInfo.mData))
+  : mData(std::move(aCloneReadInfo.mData))
 {
   MOZ_ASSERT(&aCloneReadInfo != this);
   MOZ_COUNT_CTOR(StructuredCloneReadInfo);
 
   mFiles.Clear();
   mFiles.SwapElements(aCloneReadInfo.mFiles);
   mDatabase = aCloneReadInfo.mDatabase;
   aCloneReadInfo.mDatabase = nullptr;
   mHasPreprocessInfo = aCloneReadInfo.mHasPreprocessInfo;
   aCloneReadInfo.mHasPreprocessInfo = false;
 }
 
 inline
 StructuredCloneReadInfo::StructuredCloneReadInfo(
                              SerializedStructuredCloneReadInfo&& aCloneReadInfo)
-  : mData(Move(aCloneReadInfo.data().data))
+  : mData(std::move(aCloneReadInfo.data().data))
   , mDatabase(nullptr)
   , mHasPreprocessInfo(aCloneReadInfo.hasPreprocessInfo())
 {
   MOZ_COUNT_CTOR(StructuredCloneReadInfo);
 }
 
 inline
 StructuredCloneReadInfo::~StructuredCloneReadInfo()
@@ -91,17 +91,17 @@ StructuredCloneReadInfo::~StructuredClon
   MOZ_COUNT_DTOR(StructuredCloneReadInfo);
 }
 
 inline StructuredCloneReadInfo&
 StructuredCloneReadInfo::operator=(StructuredCloneReadInfo&& aCloneReadInfo)
 {
   MOZ_ASSERT(&aCloneReadInfo != this);
 
-  mData = Move(aCloneReadInfo.mData);
+  mData = std::move(aCloneReadInfo.mData);
   mFiles.Clear();
   mFiles.SwapElements(aCloneReadInfo.mFiles);
   mDatabase = aCloneReadInfo.mDatabase;
   aCloneReadInfo.mDatabase = nullptr;
   mHasPreprocessInfo = aCloneReadInfo.mHasPreprocessInfo;
   aCloneReadInfo.mHasPreprocessInfo = false;
   return *this;
 }
--- a/dom/ipc/CoalescedInputData.h
+++ b/dom/ipc/CoalescedInputData.h
@@ -26,33 +26,33 @@ protected:
 public:
   CoalescedInputData()
     : mInputBlockId(0)
   {
   }
 
   void RetrieveDataFrom(CoalescedInputData& aSource)
   {
-    mCoalescedInputEvent = Move(aSource.mCoalescedInputEvent);
+    mCoalescedInputEvent = std::move(aSource.mCoalescedInputEvent);
     mGuid = aSource.mGuid;
     mInputBlockId = aSource.mInputBlockId;
   }
 
   bool IsEmpty()
   {
     return !mCoalescedInputEvent;
   }
 
   bool CanCoalesce(const InputEventType& aEvent,
                    const ScrollableLayerGuid& aGuid,
                    const uint64_t& aInputBlockId);
 
   UniquePtr<InputEventType> TakeCoalescedEvent()
   {
-    return Move(mCoalescedInputEvent);
+    return std::move(mCoalescedInputEvent);
   }
 
   ScrollableLayerGuid GetScrollableLayerGuid()
   {
     return mGuid;
   }
 
   uint64_t GetInputBlockId()
--- a/dom/ipc/ContentBridgeChild.cpp
+++ b/dom/ipc/ContentBridgeChild.cpp
@@ -56,17 +56,17 @@ ContentBridgeChild::DeferredDestroy()
 }
 
 mozilla::ipc::IPCResult
 ContentBridgeChild::RecvAsyncMessage(const nsString& aMsg,
                                      InfallibleTArray<jsipc::CpowEntry>&& aCpows,
                                      const IPC::Principal& aPrincipal,
                                      const ClonedMessageData& aData)
 {
-  return nsIContentChild::RecvAsyncMessage(aMsg, Move(aCpows), aPrincipal, aData);
+  return nsIContentChild::RecvAsyncMessage(aMsg, std::move(aCpows), aPrincipal, aData);
 }
 
 bool
 ContentBridgeChild::SendPBrowserConstructor(PBrowserChild* aActor,
                                             const TabId& aTabId,
                                             const TabId& aSameTabGroupAs,
                                             const IPCTabContext& aContext,
                                             const uint32_t& aChromeFlags,
--- a/dom/ipc/ContentBridgeParent.cpp
+++ b/dom/ipc/ContentBridgeParent.cpp
@@ -73,27 +73,27 @@ ContentBridgeParent::DeferredDestroy()
 
 mozilla::ipc::IPCResult
 ContentBridgeParent::RecvSyncMessage(const nsString& aMsg,
                                      const ClonedMessageData& aData,
                                      InfallibleTArray<jsipc::CpowEntry>&& aCpows,
                                      const IPC::Principal& aPrincipal,
                                      nsTArray<StructuredCloneData>* aRetvals)
 {
-  return nsIContentParent::RecvSyncMessage(aMsg, aData, Move(aCpows),
+  return nsIContentParent::RecvSyncMessage(aMsg, aData, std::move(aCpows),
                                            aPrincipal, aRetvals);
 }
 
 mozilla::ipc::IPCResult
 ContentBridgeParent::RecvAsyncMessage(const nsString& aMsg,
                                       InfallibleTArray<jsipc::CpowEntry>&& aCpows,
                                       const IPC::Principal& aPrincipal,
                                       const ClonedMessageData& aData)
 {
-  return nsIContentParent::RecvAsyncMessage(aMsg, Move(aCpows),
+  return nsIContentParent::RecvAsyncMessage(aMsg, std::move(aCpows),
                                             aPrincipal, aData);
 }
 
 PBrowserParent*
 ContentBridgeParent::SendPBrowserConstructor(PBrowserParent* aActor,
                                              const TabId& aTabId,
                                              const TabId& aSameTabGroupAs,
                                              const IPCTabContext& aContext,
--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -588,18 +588,18 @@ ContentChild::RecvSetXPCOMProcessAttribu
                                             const StructuredCloneData& aInitialData,
                                             nsTArray<LookAndFeelInt>&& aLookAndFeelIntCache,
                                             nsTArray<SystemFontListEntry>&& aFontList)
 {
   if (!sShutdownCanary) {
     return IPC_OK();
   }
 
-  mLookAndFeelCache = Move(aLookAndFeelIntCache);
-  mFontList = Move(aFontList);
+  mLookAndFeelCache = std::move(aLookAndFeelIntCache);
+  mFontList = std::move(aFontList);
   gfx::gfxVars::SetValuesForInitialize(aXPCOMInit.gfxNonDefaultVarUpdates());
   InitXPCOM(aXPCOMInit, aInitialData);
   InitGraphicsDeviceData(aXPCOMInit.contentDeviceData());
 
   return IPC_OK();
 }
 
 bool
@@ -1072,17 +1072,17 @@ ContentChild::ProvideWindowCommon(TabChi
       url.SetIsVoid(true);
     }
 
     // NOTE: BrowserFrameOpenWindowPromise is the same type as
     // CreateWindowPromise, and this code depends on that fact.
     newChild->SendBrowserFrameOpenWindow(aTabOpener, renderFrame,
                                          NS_ConvertUTF8toUTF16(url),
                                          name, NS_ConvertUTF8toUTF16(features),
-                                         Move(resolve), Move(reject));
+                                         std::move(resolve), std::move(reject));
   } else {
     nsAutoCString baseURIString;
     float fullZoom;
     nsCOMPtr<nsIPrincipal> triggeringPrincipal;
     uint32_t referrerPolicy = mozilla::net::RP_Unset;
     rv = GetCreateWindowParams(aParent, aLoadInfo, baseURIString, &fullZoom,
                                &referrerPolicy,
                                getter_AddRefs(triggeringPrincipal));
@@ -1096,17 +1096,17 @@ ContentChild::ProvideWindowCommon(TabChi
     } else {
       uriToLoad = mozilla::void_t();
     }
 
     SendCreateWindow(aTabOpener, newChild, renderFrame,
                      aChromeFlags, aCalledFromJS, aPositionSpecified,
                      aSizeSpecified, uriToLoad, features, baseURIString,
                      fullZoom, Principal(triggeringPrincipal), referrerPolicy,
-                     Move(resolve), Move(reject));
+                     std::move(resolve), std::move(reject));
   }
 
   // =======================
   // Begin Nested Event Loop
   // =======================
 
   // We have to wait for a response from either SendCreateWindow or
   // SendBrowserFrameOpenWindow with information we're going to need to return
@@ -1327,49 +1327,49 @@ ContentChild::DeallocPCycleCollectWithLo
   // Also, we're already in ~CycleCollectWithLogsChild (q.v.) at
   // this point, so we shouldn't touch the actor in any case.
   return true;
 }
 
 mozilla::ipc::IPCResult
 ContentChild::RecvInitContentBridgeChild(Endpoint<PContentBridgeChild>&& aEndpoint)
 {
-  ContentBridgeChild::Create(Move(aEndpoint));
+  ContentBridgeChild::Create(std::move(aEndpoint));
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 ContentChild::RecvInitGMPService(Endpoint<PGMPServiceChild>&& aGMPService)
 {
-  if (!GMPServiceChild::Create(Move(aGMPService))) {
+  if (!GMPServiceChild::Create(std::move(aGMPService))) {
     return IPC_FAIL_NO_REASON(this);
   }
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 ContentChild::RecvInitProfiler(Endpoint<PProfilerChild>&& aEndpoint)
 {
 #ifdef MOZ_GECKO_PROFILER
-  mProfilerController = ChildProfilerController::Create(Move(aEndpoint));
+  mProfilerController = ChildProfilerController::Create(std::move(aEndpoint));
 #endif
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 ContentChild::RecvGMPsChanged(nsTArray<GMPCapabilityData>&& capabilities)
 {
-  GeckoMediaPluginServiceChild::UpdateGMPCapabilities(Move(capabilities));
+  GeckoMediaPluginServiceChild::UpdateGMPCapabilities(std::move(capabilities));
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 ContentChild::RecvInitProcessHangMonitor(Endpoint<PProcessHangMonitorChild>&& aHangMonitor)
 {
-  CreateHangMonitorChild(Move(aHangMonitor));
+  CreateHangMonitorChild(std::move(aHangMonitor));
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 ContentChild::GetResultForRenderingInitFailure(base::ProcessId aOtherPid)
 {
   if (aOtherPid == base::GetCurrentProcId() || aOtherPid == OtherPid()) {
     // If we are talking to ourselves, or the UI process, then that is a fatal
@@ -1404,29 +1404,29 @@ ContentChild::RecvInitRendering(Endpoint
 
   // Note that for all of the methods below, if it can fail, it should only
   // return false if the failure is an IPDL error. In such situations,
   // ContentChild can reason about whether or not to wait for
   // RecvReinitRendering (because we surmised the GPU process crashed), or if it
   // should crash itself (because we are actually talking to the UI process). If
   // there are localized failures (e.g. failed to spawn a thread), then it
   // should MOZ_RELEASE_ASSERT or MOZ_CRASH as necessary instead.
-  if (!CompositorManagerChild::Init(Move(aCompositor), namespaces[0])) {
+  if (!CompositorManagerChild::Init(std::move(aCompositor), namespaces[0])) {
     return GetResultForRenderingInitFailure(aCompositor.OtherPid());
   }
   if (!CompositorManagerChild::CreateContentCompositorBridge(namespaces[1])) {
     return GetResultForRenderingInitFailure(aCompositor.OtherPid());
   }
-  if (!ImageBridgeChild::InitForContent(Move(aImageBridge), namespaces[2])) {
+  if (!ImageBridgeChild::InitForContent(std::move(aImageBridge), namespaces[2])) {
     return GetResultForRenderingInitFailure(aImageBridge.OtherPid());
   }
-  if (!gfx::VRManagerChild::InitForContent(Move(aVRBridge))) {
+  if (!gfx::VRManagerChild::InitForContent(std::move(aVRBridge))) {
     return GetResultForRenderingInitFailure(aVRBridge.OtherPid());
   }
-  VideoDecoderManagerChild::InitForContent(Move(aVideoManager));
+  VideoDecoderManagerChild::InitForContent(std::move(aVideoManager));
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 ContentChild::RecvReinitRendering(Endpoint<PCompositorManagerChild>&& aCompositor,
                                   Endpoint<PImageBridgeChild>&& aImageBridge,
                                   Endpoint<PVRManagerChild>&& aVRBridge,
                                   Endpoint<PVideoDecoderManagerChild>&& aVideoManager,
@@ -1438,38 +1438,38 @@ ContentChild::RecvReinitRendering(Endpoi
   // Zap all the old layer managers we have lying around.
   for (const auto& tabChild : tabs) {
     if (tabChild->GetLayersId().IsValid()) {
       tabChild->InvalidateLayers();
     }
   }
 
   // Re-establish singleton bridges to the compositor.
-  if (!CompositorManagerChild::Init(Move(aCompositor), namespaces[0])) {
+  if (!CompositorManagerChild::Init(std::move(aCompositor), namespaces[0])) {
     return GetResultForRenderingInitFailure(aCompositor.OtherPid());
   }
   if (!CompositorManagerChild::CreateContentCompositorBridge(namespaces[1])) {
     return GetResultForRenderingInitFailure(aCompositor.OtherPid());
   }
-  if (!ImageBridgeChild::ReinitForContent(Move(aImageBridge), namespaces[2])) {
+  if (!ImageBridgeChild::ReinitForContent(std::move(aImageBridge), namespaces[2])) {
     return GetResultForRenderingInitFailure(aImageBridge.OtherPid());
   }
-  if (!gfx::VRManagerChild::ReinitForContent(Move(aVRBridge))) {
+  if (!gfx::VRManagerChild::ReinitForContent(std::move(aVRBridge))) {
     return GetResultForRenderingInitFailure(aVRBridge.OtherPid());
   }
   gfxPlatform::GetPlatform()->CompositorUpdated();
 
   // Establish new PLayerTransactions.
   for (const auto& tabChild : tabs) {
     if (tabChild->GetLayersId().IsValid()) {
       tabChild->ReinitRendering();
     }
   }
 
-  VideoDecoderManagerChild::InitForContent(Move(aVideoManager));
+  VideoDecoderManagerChild::InitForContent(std::move(aVideoManager));
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 ContentChild::RecvAudioDefaultDeviceChange()
 {
 #ifdef XP_WIN
   audio::AudioNotificationReceiver::NotifyDefaultDeviceChanged();
@@ -2564,17 +2564,17 @@ ContentChild::RecvUpdateDictionaryList(I
   mAvailableDictionaries = aDictionaries;
   mozInlineSpellChecker::UpdateCanEnableInlineSpellChecking();
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 ContentChild::RecvUpdateFontList(InfallibleTArray<SystemFontListEntry>&& aFontList)
 {
-  mFontList = Move(aFontList);
+  mFontList = std::move(aFontList);
   gfxPlatform::GetPlatform()->UpdateFontList();
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 ContentChild::RecvUpdateAppLocales(nsTArray<nsCString>&& aAppLocales)
 {
   LocaleService::GetInstance()->AssignAppLocales(aAppLocales);
@@ -3626,17 +3626,17 @@ ContentChild::RecvSetPermissionsWithKey(
   permissionManager->SetPermissionsWithKey(aPermissionKey, aPerms);
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 ContentChild::RecvRefreshScreens(nsTArray<ScreenDetails>&& aScreens)
 {
   ScreenManager& screenManager = ScreenManager::GetSingleton();
-  screenManager.Refresh(Move(aScreens));
+  screenManager.Refresh(std::move(aScreens));
   return IPC_OK();
 }
 
 already_AddRefed<nsIEventTarget>
 ContentChild::GetEventTargetFor(TabChild* aTabChild)
 {
   return IToplevelProtocol::GetActorEventTarget(aTabChild);
 }
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -977,19 +977,19 @@ ContentParent::RecvBridgeToChildProcess(
     Endpoint<PContentBridgeParent> parent;
     Endpoint<PContentBridgeChild> child;
 
     if (NS_FAILED(PContentBridge::CreateEndpoints(OtherPid(), cp->OtherPid(),
                                                   &parent, &child))) {
       return IPC_FAIL(this, "CreateEndpoints failed");
     }
 
-    *aEndpoint = Move(parent);
-
-    if (!cp->SendInitContentBridgeChild(Move(child))) {
+    *aEndpoint = std::move(parent);
+
+    if (!cp->SendInitContentBridgeChild(std::move(child))) {
       return IPC_FAIL(this, "SendInitContentBridgeChild failed");
     }
 
     return IPC_OK();
   }
 
   // You can't bridge to a process you didn't open!
   KillHard("BridgeToChildProcess");
@@ -1026,22 +1026,22 @@ ContentParent::RecvCreateGMPService()
   rv = PGMPService::CreateEndpoints(base::GetCurrentProcId(),
                                     OtherPid(),
                                     &parent, &child);
   if (NS_FAILED(rv)) {
     MOZ_ASSERT(false, "CreateEndpoints failed");
     return IPC_FAIL_NO_REASON(this);
   }
 
-  if (!GMPServiceParent::Create(Move(parent))) {
+  if (!GMPServiceParent::Create(std::move(parent))) {
     MOZ_ASSERT(false, "GMPServiceParent::Create failed");
     return IPC_FAIL_NO_REASON(this);
   }
 
-  if (!SendInitGMPService(Move(child))) {
+  if (!SendInitGMPService(std::move(child))) {
     MOZ_ASSERT(false, "SendInitGMPService failed");
     return IPC_FAIL_NO_REASON(this);
   }
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
@@ -1242,17 +1242,17 @@ ContentParent::CreateContentBridgeParent
   }
   if (cpId == 0) {
     return nullptr;
   }
   Endpoint<PContentBridgeParent> endpoint;
   if (!child->SendBridgeToChildProcess(cpId, &endpoint)) {
     return nullptr;
   }
-  ContentBridgeParent* parent = ContentBridgeParent::Create(Move(endpoint));
+  ContentBridgeParent* parent = ContentBridgeParent::Create(std::move(endpoint));
   parent->SetChildID(cpId);
   parent->SetIsForBrowser(isForBrowser);
   parent->SetIsForJSPlugin(aContext.IsJSPlugin());
   return parent;
 }
 
 void
 ContentParent::GetAll(nsTArray<ContentParent*>& aArray)
@@ -2363,20 +2363,20 @@ ContentParent::InitInternal(ProcessPrior
   DebugOnly<bool> opened = gpm->CreateContentBridges(OtherPid(),
                                                      &compositor,
                                                      &imageBridge,
                                                      &vrBridge,
                                                      &videoManager,
                                                      &namespaces);
   MOZ_ASSERT(opened);
 
-  Unused << SendInitRendering(Move(compositor),
-                              Move(imageBridge),
-                              Move(vrBridge),
-                              Move(videoManager),
+  Unused << SendInitRendering(std::move(compositor),
+                              std::move(imageBridge),
+                              std::move(vrBridge),
+                              std::move(videoManager),
                               namespaces);
 
   gpm->AddListener(this);
 
   nsStyleSheetService *sheetService = nsStyleSheetService::GetInstance();
   if (sheetService) {
     // This looks like a lot of work, but in a normal browser session we just
     // send two loads.
@@ -2427,17 +2427,17 @@ ContentParent::InitInternal(ProcessPrior
 #ifdef XP_LINUX
   if (shouldSandbox) {
     MOZ_ASSERT(!mSandboxBroker);
     bool isFileProcess = mRemoteType.EqualsLiteral(FILE_REMOTE_TYPE);
     UniquePtr<SandboxBroker::Policy> policy =
       sSandboxBrokerPolicyFactory->GetContentPolicy(Pid(), isFileProcess);
     if (policy) {
       brokerFd = FileDescriptor();
-      mSandboxBroker = SandboxBroker::Create(Move(policy), Pid(), brokerFd);
+      mSandboxBroker = SandboxBroker::Create(std::move(policy), Pid(), brokerFd);
       if (!mSandboxBroker) {
         KillHard("SandboxBroker::Create failed");
         return;
       }
       MOZ_ASSERT(static_cast<const FileDescriptor&>(brokerFd).IsValid());
     }
   }
 #endif
@@ -2530,20 +2530,20 @@ ContentParent::OnCompositorUnexpectedShu
     &compositor,
     &imageBridge,
     &vrBridge,
     &videoManager,
     &namespaces);
   MOZ_ASSERT(opened);
 
   Unused << SendReinitRendering(
-    Move(compositor),
-    Move(imageBridge),
-    Move(vrBridge),
-    Move(videoManager),
+    std::move(compositor),
+    std::move(imageBridge),
+    std::move(vrBridge),
+    std::move(videoManager),
     namespaces);
 }
 
 void
 ContentParent::OnCompositorDeviceReset()
 {
   Unused << SendReinitRenderingForDeviceReset();
 }
@@ -3025,17 +3025,17 @@ ContentParent::GetInterface(const nsIID&
   }
 
   return NS_NOINTERFACE;
 }
 
 mozilla::ipc::IPCResult
 ContentParent::RecvInitBackground(Endpoint<PBackgroundParent>&& aEndpoint)
 {
-  if (!BackgroundParent::Alloc(this, Move(aEndpoint))) {
+  if (!BackgroundParent::Alloc(this, std::move(aEndpoint))) {
     return IPC_FAIL(this, "BackgroundParent::Alloc failed");
   }
 
   return IPC_OK();
 }
 
 mozilla::jsipc::PJavaScriptParent *
 ContentParent::AllocPJavaScriptParent()
@@ -3174,17 +3174,17 @@ ContentParent::KillHard(const char* aRea
     RefPtr<ContentParent> self = this;
     std::function<void(bool)> callback = [self](bool aResult) {
       self->OnGenerateMinidumpComplete(aResult);
     };
     // Generate the report and insert into the queue for submittal.
     mCrashReporter->GenerateMinidumpAndPair(Process(),
                                             nullptr,
                                             NS_LITERAL_CSTRING("browser"),
-                                            Move(callback),
+                                            std::move(callback),
                                             true);
     return;
   }
 
   OnGenerateMinidumpComplete(false);
 }
 
 void
@@ -3435,17 +3435,17 @@ ContentParent::GetPrintingParent()
 mozilla::ipc::IPCResult
 ContentParent::RecvInitStreamFilter(const uint64_t& aChannelId,
                                     const nsString& aAddonId,
                                     InitStreamFilterResolver&& aResolver)
 {
   Endpoint<PStreamFilterChild> endpoint;
   Unused << extensions::StreamFilterParent::Create(this, aChannelId, aAddonId, &endpoint);
 
-  aResolver(Move(endpoint));
+  aResolver(std::move(endpoint));
 
   return IPC_OK();
 }
 
 PChildToParentStreamParent*
 ContentParent::AllocPChildToParentStreamParent()
 {
   return nsIContentParent::AllocPChildToParentStreamParent();
@@ -3801,38 +3801,38 @@ ContentParent::RecvOpenNotificationSetti
 
 mozilla::ipc::IPCResult
 ContentParent::RecvSyncMessage(const nsString& aMsg,
                                const ClonedMessageData& aData,
                                InfallibleTArray<CpowEntry>&& aCpows,
                                const IPC::Principal& aPrincipal,
                                nsTArray<StructuredCloneData>* aRetvals)
 {
-  return nsIContentParent::RecvSyncMessage(aMsg, aData, Move(aCpows),
+  return nsIContentParent::RecvSyncMessage(aMsg, aData, std::move(aCpows),
                                            aPrincipal, aRetvals);
 }
 
 mozilla::ipc::IPCResult
 ContentParent::RecvRpcMessage(const nsString& aMsg,
                               const ClonedMessageData& aData,
                               InfallibleTArray<CpowEntry>&& aCpows,
                               const IPC::Principal& aPrincipal,
                               nsTArray<StructuredCloneData>* aRetvals)
 {
-  return nsIContentParent::RecvRpcMessage(aMsg, aData, Move(aCpows), aPrincipal,
+  return nsIContentParent::RecvRpcMessage(aMsg, aData, std::move(aCpows), aPrincipal,
                                           aRetvals);
 }
 
 mozilla::ipc::IPCResult
 ContentParent::RecvAsyncMessage(const nsString& aMsg,
                                 InfallibleTArray<CpowEntry>&& aCpows,
                                 const IPC::Principal& aPrincipal,
                                 const ClonedMessageData& aData)
 {
-  return nsIContentParent::RecvAsyncMessage(aMsg, Move(aCpows), aPrincipal,
+  return nsIContentParent::RecvAsyncMessage(aMsg, std::move(aCpows), aPrincipal,
                                             aData);
 }
 
 static int32_t
 AddGeolocationListener(nsIDOMGeoPositionCallback* watcher,
                        nsIDOMGeoPositionErrorCallback* errorCallBack,
                        bool highAccuracy)
 {
@@ -3841,17 +3841,17 @@ AddGeolocationListener(nsIDOMGeoPosition
     return -1;
   }
 
   UniquePtr<PositionOptions> options = MakeUnique<PositionOptions>();
   options->mTimeout = 0;
   options->mMaximumAge = 0;
   options->mEnableHighAccuracy = highAccuracy;
   int32_t retval = 1;
-  geo->WatchPosition(watcher, errorCallBack, Move(options), &retval);
+  geo->WatchPosition(watcher, errorCallBack, std::move(options), &retval);
   return retval;
 }
 
 mozilla::ipc::IPCResult
 ContentParent::RecvAddGeolocationListener(const IPC::Principal& aPrincipal,
                                           const bool& aHighAccuracy)
 {
   // To ensure no geolocation updates are skipped, we always force the
@@ -4330,17 +4330,17 @@ ContentParent::RecvRequestAnonymousTempo
 
 mozilla::ipc::IPCResult
 ContentParent::RecvCreateAudioIPCConnection(CreateAudioIPCConnectionResolver&& aResolver)
 {
   FileDescriptor fd = CubebUtils::CreateAudioIPCConnection();
   if (!fd.IsValid()) {
     return IPC_FAIL(this, "CubebUtils::CreateAudioIPCConnection failed");
   }
-  aResolver(Move(fd));
+  aResolver(std::move(fd));
   return IPC_OK();
 }
 
 static NS_DEFINE_CID(kFormProcessorCID, NS_FORMPROCESSOR_CID);
 
 mozilla::ipc::IPCResult
 ContentParent::RecvKeygenProcessValue(const nsString& oldValue,
                                       const nsString& challenge,
@@ -4468,17 +4468,17 @@ ContentParent::RecvNotifyTabDestroying(c
 {
   NotifyTabDestroying(aTabId, aCpId);
   return IPC_OK();
 }
 
 nsTArray<TabContext>
 ContentParent::GetManagedTabContext()
 {
-  return Move(ContentProcessManager::GetSingleton()->
+  return std::move(ContentProcessManager::GetSingleton()->
           GetTabContextByContentProcess(this->ChildID()));
 }
 
 mozilla::docshell::POfflineCacheUpdateParent*
 ContentParent::AllocPOfflineCacheUpdateParent(const URIParams& aManifestURI,
                                               const URIParams& aDocumentURI,
                                               const PrincipalInfo& aLoadingPrincipalInfo,
                                               const bool& aStickDocument)
@@ -5053,17 +5053,17 @@ ContentParent::RecvBeginDriverCrashGuard
   }
 
   if (guard->Crashed()) {
     *aOutCrashed = true;
     return IPC_OK();
   }
 
   *aOutCrashed = false;
-  mDriverCrashGuard = Move(guard);
+  mDriverCrashGuard = std::move(guard);
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 ContentParent::RecvEndDriverCrashGuard(const uint32_t& aGuardType)
 {
   mDriverCrashGuard = nullptr;
   return IPC_OK();
@@ -5233,17 +5233,17 @@ ContentParent::RecvGetA11yContentId(uint
 
 mozilla::ipc::IPCResult
 ContentParent::RecvA11yHandlerControl(const uint32_t& aPid,
                                       const IHandlerControlHolder& aHandlerControl)
 {
 #if defined(XP_WIN32) && defined(ACCESSIBILITY)
   MOZ_ASSERT(!aHandlerControl.IsNull());
   RefPtr<IHandlerControl> proxy(aHandlerControl.Get());
-  a11y::AccessibleWrap::SetHandlerControl(aPid, Move(proxy));
+  a11y::AccessibleWrap::SetHandlerControl(aPid, std::move(proxy));
   return IPC_OK();
 #else
   return IPC_FAIL_NO_REASON(this);
 #endif
 }
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/ipc/ContentProcessManager.cpp
+++ b/dom/ipc/ContentProcessManager.cpp
@@ -120,26 +120,26 @@ nsTArray<ContentParentId>
 ContentProcessManager::GetAllChildProcessById(const ContentParentId& aParentCpId)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   nsTArray<ContentParentId> cpIdArray;
   auto iter = mContentParentMap.find(aParentCpId);
   if (NS_WARN_IF(iter == mContentParentMap.end())) {
     ASSERT_UNLESS_FUZZING();
-    return Move(cpIdArray);
+    return std::move(cpIdArray);
   }
 
   for (auto cpIter = iter->second.mChildrenCpId.begin();
        cpIter != iter->second.mChildrenCpId.end();
        ++cpIter) {
     cpIdArray.AppendElement(*cpIter);
   }
 
-  return Move(cpIdArray);
+  return std::move(cpIdArray);
 }
 
 bool
 ContentProcessManager::RegisterRemoteFrame(const TabId& aTabId,
                                            const ContentParentId& aOpenerCpId,
                                            const TabId& aOpenerTabId,
                                            const IPCTabContext& aContext,
                                            const ContentParentId& aChildCpId)
@@ -231,26 +231,26 @@ nsTArray<TabContext>
 ContentProcessManager::GetTabContextByContentProcess(const ContentParentId& aChildCpId)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   nsTArray<TabContext> tabContextArray;
   auto iter = mContentParentMap.find(aChildCpId);
   if (NS_WARN_IF(iter == mContentParentMap.end())) {
     ASSERT_UNLESS_FUZZING();
-    return Move(tabContextArray);
+    return std::move(tabContextArray);
   }
 
   for (auto remoteFrameIter = iter->second.mRemoteFrames.begin();
        remoteFrameIter != iter->second.mRemoteFrames.end();
        ++remoteFrameIter) {
     tabContextArray.AppendElement(remoteFrameIter->second.mContext);
   }
 
-  return Move(tabContextArray);
+  return std::move(tabContextArray);
 }
 
 bool
 ContentProcessManager::GetRemoteFrameOpenerTabId(const ContentParentId& aChildCpId,
                                                  const TabId& aChildTabId,
                                                  /*out*/ContentParentId* aOpenerCpId,
                                                  /*out*/TabId* aOpenerTabId)
 {
@@ -332,26 +332,26 @@ nsTArray<TabId>
 ContentProcessManager::GetTabParentsByProcessId(const ContentParentId& aChildCpId)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   nsTArray<TabId> tabIdList;
   auto iter = mContentParentMap.find(aChildCpId);
   if (NS_WARN_IF(iter == mContentParentMap.end())) {
     ASSERT_UNLESS_FUZZING();
-    return Move(tabIdList);
+    return std::move(tabIdList);
   }
 
   for (auto remoteFrameIter = iter->second.mRemoteFrames.begin();
       remoteFrameIter != iter->second.mRemoteFrames.end();
       ++remoteFrameIter) {
     tabIdList.AppendElement(remoteFrameIter->first);
   }
 
-  return Move(tabIdList);
+  return std::move(tabIdList);
 }
 
 uint32_t
 ContentProcessManager::GetTabParentCountByProcessId(const ContentParentId& aChildCpId)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   auto iter = mContentParentMap.find(aChildCpId);
--- a/dom/ipc/ProcessHangMonitor.cpp
+++ b/dom/ipc/ProcessHangMonitor.cpp
@@ -116,17 +116,17 @@ class HangMonitorChild
 
   void InterruptCallback();
   void Shutdown();
 
   static HangMonitorChild* Get() { return sInstance; }
 
   void Dispatch(already_AddRefed<nsIRunnable> aRunnable)
   {
-    mHangMonitor->Dispatch(Move(aRunnable));
+    mHangMonitor->Dispatch(std::move(aRunnable));
   }
   bool IsOnThread() { return mHangMonitor->IsOnThread(); }
 
  private:
   void ShutdownOnThread();
 
   static Atomic<HangMonitorChild*> sInstance;
   UniquePtr<BackgroundHangMonitor> mPaintWhileInterruptingJSMonitor;
@@ -243,17 +243,17 @@ public:
    * Update the dump for the specified plugin. This method is thread-safe and
    * is used to replace a browser minidump with a full minidump. If aDumpId is
    * empty this is a no-op.
    */
   void UpdateMinidump(uint32_t aPluginId, const nsString& aDumpId);
 
   void Dispatch(already_AddRefed<nsIRunnable> aRunnable)
   {
-    mHangMonitor->Dispatch(Move(aRunnable));
+    mHangMonitor->Dispatch(std::move(aRunnable));
   }
   bool IsOnThread() { return mHangMonitor->IsOnThread(); }
 
 private:
   bool TakeBrowserMinidump(const PluginHangData& aPhd, nsString& aCrashId);
 
   void SendHangNotification(const HangData& aHangData,
                             const nsString& aBrowserDumpId,
@@ -749,17 +749,17 @@ HangMonitorParent::SendHangNotification(
         self->UpdateMinidump(aHangData.get_PluginHangData().pluginId(),
                        aResult);
         self->OnTakeFullMinidumpComplete(aHangData, aResult);
       };
 
     plugins::TakeFullMinidump(phd.pluginId(),
                               phd.contentProcessId(),
                               aBrowserDumpId,
-                              Move(callback),
+                              std::move(callback),
                               true);
   } else {
     // We already have a full minidump; go ahead and use it.
     OnTakeFullMinidumpComplete(aHangData, aBrowserDumpId);
   }
 }
 
 void
@@ -1118,17 +1118,17 @@ HangMonitoredProcess::TerminatePlugin()
         self->mActor->CleanupPluginHang(id, false);
       }
     };
 
   plugins::TerminatePlugin(id,
                            contentPid,
                            NS_LITERAL_CSTRING("HangMonitor"),
                            mDumpId,
-                           Move(callback));
+                           std::move(callback));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 HangMonitoredProcess::IsReportForBrowser(nsFrameLoader* aFrameLoader, bool* aResult)
 {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
 
@@ -1286,17 +1286,17 @@ CreateHangMonitorParent(ContentParent* a
   auto* process = new HangMonitoredProcess(parent, aContentParent);
   parent->SetProcess(process);
 
   monitor->Dispatch(
     NewNonOwningRunnableMethod<Endpoint<PProcessHangMonitorParent>&&>(
       "HangMonitorParent::Bind",
       parent,
       &HangMonitorParent::Bind,
-      Move(aEndpoint)));
+      std::move(aEndpoint)));
 
   return parent;
 }
 
 void
 mozilla::CreateHangMonitorChild(Endpoint<PProcessHangMonitorChild>&& aEndpoint)
 {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
@@ -1307,23 +1307,23 @@ mozilla::CreateHangMonitorChild(Endpoint
   ProcessHangMonitor* monitor = ProcessHangMonitor::GetOrCreate();
   auto* child = new HangMonitorChild(monitor);
 
   monitor->Dispatch(
     NewNonOwningRunnableMethod<Endpoint<PProcessHangMonitorChild>&&>(
       "HangMonitorChild::Bind",
       child,
       &HangMonitorChild::Bind,
-      Move(aEndpoint)));
+      std::move(aEndpoint)));
 }
 
 void
 ProcessHangMonitor::Dispatch(already_AddRefed<nsIRunnable> aRunnable)
 {
-  mThread->Dispatch(Move(aRunnable), nsIEventTarget::NS_DISPATCH_NORMAL);
+  mThread->Dispatch(std::move(aRunnable), nsIEventTarget::NS_DISPATCH_NORMAL);
 }
 
 bool
 ProcessHangMonitor::IsOnThread()
 {
   bool on;
   return NS_SUCCEEDED(mThread->IsOnCurrentThread(&on)) && on;
 }
@@ -1343,22 +1343,22 @@ ProcessHangMonitor::AddProcess(ContentPa
   rv = PProcessHangMonitor::CreateEndpoints(base::GetCurrentProcId(),
                                             aContentParent->OtherPid(),
                                             &parent, &child);
   if (NS_FAILED(rv)) {
     MOZ_ASSERT(false, "PProcessHangMonitor::CreateEndpoints failed");
     return nullptr;
   }
 
-  if (!aContentParent->SendInitProcessHangMonitor(Move(child))) {
+  if (!aContentParent->SendInitProcessHangMonitor(std::move(child))) {
     MOZ_ASSERT(false);
     return nullptr;
   }
 
-  return CreateHangMonitorParent(aContentParent, Move(parent));
+  return CreateHangMonitorParent(aContentParent, std::move(parent));
 }
 
 /* static */ void
 ProcessHangMonitor::RemoveProcess(PProcessHangMonitorParent* aParent)
 {
   MOZ_RELEASE_ASSERT(NS_IsMainThread());
   auto parent = static_cast<HangMonitorParent*>(aParent);
   parent->Shutdown();
--- a/dom/ipc/StructuredCloneData.cpp
+++ b/dom/ipc/StructuredCloneData.cpp
@@ -27,36 +27,36 @@ namespace ipc {
 
 StructuredCloneData::StructuredCloneData()
   : StructuredCloneData(StructuredCloneHolder::TransferringSupported)
 {}
 
 StructuredCloneData::StructuredCloneData(StructuredCloneData&& aOther)
   : StructuredCloneData(StructuredCloneHolder::TransferringSupported)
 {
-  *this = Move(aOther);
+  *this = std::move(aOther);
 }
 
 StructuredCloneData::StructuredCloneData(TransferringSupport aSupportsTransferring)
   : StructuredCloneHolder(StructuredCloneHolder::CloningSupported,
                           aSupportsTransferring,
                           StructuredCloneHolder::StructuredCloneScope::DifferentProcess)
   , mExternalData(JS::StructuredCloneScope::DifferentProcess)
   , mInitialized(false)
 {}
 
 StructuredCloneData::~StructuredCloneData()
 {}
 
 StructuredCloneData&
 StructuredCloneData::operator=(StructuredCloneData&& aOther)
 {
-  mExternalData = Move(aOther.mExternalData);
-  mSharedData = Move(aOther.mSharedData);
-  mIPCStreams = Move(aOther.mIPCStreams);
+  mExternalData = std::move(aOther.mExternalData);
+  mSharedData = std::move(aOther.mSharedData);
+  mIPCStreams = std::move(aOther.mIPCStreams);
   mInitialized = aOther.mInitialized;
 
   return *this;
 }
 
 bool
 StructuredCloneData::Copy(const StructuredCloneData& aData)
 {
@@ -124,17 +124,17 @@ StructuredCloneData::Write(JSContext* aC
   if (NS_WARN_IF(aRv.Failed())) {
     return;
   }
 
   JSStructuredCloneData data(mBuffer->scope());
   mBuffer->abandon();
   mBuffer->steal(&data);
   mBuffer = nullptr;
-  mSharedData = new SharedJSAllocatedData(Move(data));
+  mSharedData = new SharedJSAllocatedData(std::move(data));
   mInitialized = true;
 }
 
 enum ActorFlavorEnum {
   Parent = 0,
   Child,
 };
 
@@ -422,17 +422,17 @@ bool
 StructuredCloneData::ReadIPCParams(const IPC::Message* aMsg,
                                    PickleIterator* aIter)
 {
   MOZ_ASSERT(!mInitialized);
   JSStructuredCloneData data(JS::StructuredCloneScope::DifferentProcess);
   if (!ReadParam(aMsg, aIter, &data)) {
     return false;
   }
-  mSharedData = new SharedJSAllocatedData(Move(data));
+  mSharedData = new SharedJSAllocatedData(std::move(data));
   mInitialized = true;
   return true;
 }
 
 bool
 StructuredCloneData::CopyExternalData(const char* aData,
                                       size_t aDataLength)
 {
@@ -453,16 +453,16 @@ StructuredCloneData::CopyExternalData(co
   mInitialized = true;
   return true;
 }
 
 bool
 StructuredCloneData::StealExternalData(JSStructuredCloneData& aData)
 {
   MOZ_ASSERT(!mInitialized);
-  mSharedData = new SharedJSAllocatedData(Move(aData));
+  mSharedData = new SharedJSAllocatedData(std::move(aData));
   mInitialized = true;
   return true;
 }
 
 } // namespace ipc
 } // namespace dom
 } // namespace mozilla
--- a/dom/ipc/StructuredCloneData.h
+++ b/dom/ipc/StructuredCloneData.h
@@ -43,36 +43,36 @@ namespace ipc {
  * JSStructuredCloneData owns its buffers.  (For the non-owning case,
  * StructuredCloneData uses mExternalData which holds a BufferList::Borrow()ed
  * read-only view of the data.)
  */
 class SharedJSAllocatedData final
 {
 public:
   explicit SharedJSAllocatedData(JSStructuredCloneData&& aData)
-    : mData(Move(aData))
+    : mData(std::move(aData))
   { }
 
   static already_AddRefed<SharedJSAllocatedData>
   CreateFromExternalData(const char* aData, size_t aDataLength)
   {
     JSStructuredCloneData buf(JS::StructuredCloneScope::DifferentProcess);
     buf.AppendBytes(aData, aDataLength);
     RefPtr<SharedJSAllocatedData> sharedData =
-      new SharedJSAllocatedData(Move(buf));
+      new SharedJSAllocatedData(std::move(buf));
     return sharedData.forget();
   }
 
   static already_AddRefed<SharedJSAllocatedData>
   CreateFromExternalData(const JSStructuredCloneData& aData)
   {
     JSStructuredCloneData buf(aData.scope());
     buf.Append(aData);
     RefPtr<SharedJSAllocatedData> sharedData =
-      new SharedJSAllocatedData(Move(buf));
+      new SharedJSAllocatedData(std::move(buf));
     return sharedData.forget();
   }
 
   NS_INLINE_DECL_REFCOUNTING(SharedJSAllocatedData)
 
   JSStructuredCloneData& Data() { return mData; }
   size_t DataLength() const { return mData.Size(); }
 
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -640,17 +640,17 @@ TabChild::Init()
       [weakPtrThis](const ScrollableLayerGuid& aGuid,
                     uint64_t aInputBlockId,
                     bool aPreventDefault)
       {
         if (nsCOMPtr<nsITabChild> tabChild = do_QueryReferent(weakPtrThis)) {
           static_cast<TabChild*>(tabChild.get())->ContentReceivedInputBlock(aGuid, aInputBlockId, aPreventDefault);
         }
       });
-  mAPZEventState = new APZEventState(mPuppetWidget, Move(callback));
+  mAPZEventState = new APZEventState(mPuppetWidget, std::move(callback));
 
   mIPCOpen = true;
   return NS_OK;
 }
 
 void
 TabChild::NotifyTabContextUpdated(bool aIsPreallocated)
 {
@@ -3607,19 +3607,19 @@ TabChildGlobal::GetGlobalJSObject()
   return GetWrapper();
 }
 
 nsresult
 TabChildGlobal::Dispatch(TaskCategory aCategory,
                          already_AddRefed<nsIRunnable>&& aRunnable)
 {
   if (mTabChild && mTabChild->TabGroup()) {
-    return mTabChild->TabGroup()->Dispatch(aCategory, Move(aRunnable));
+    return mTabChild->TabGroup()->Dispatch(aCategory, std::move(aRunnable));
   }
-  return DispatcherTrait::Dispatch(aCategory, Move(aRunnable));
+  return DispatcherTrait::Dispatch(aCategory, std::move(aRunnable));
 }
 
 nsISerialEventTarget*
 TabChildGlobal::EventTargetFor(TaskCategory aCategory) const
 {
   if (mTabChild && mTabChild->TabGroup()) {
     return mTabChild->TabGroup()->EventTargetFor(aCategory);
   }
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -3333,17 +3333,17 @@ TabParent::RecvInvokeDragSession(nsTArra
       // session.
       Manager()->AsContentParent()->SetInputPriorityEventEnabled(true);
     }
     return IPC_OK();
   }
 
   EventStateManager* esm = shell->GetPresContext()->EventStateManager();
   for (uint32_t i = 0; i < aTransfers.Length(); ++i) {
-    mInitialDataTransferItems.AppendElement(mozilla::Move(aTransfers[i].items()));
+    mInitialDataTransferItems.AppendElement(std::move(aTransfers[i].items()));
   }
   if (Manager()->IsContentParent()) {
     nsCOMPtr<nsIDragService> dragService =
       do_GetService("@mozilla.org/widget/dragservice;1");
     if (dragService) {
       dragService->MaybeAddChildProcess(Manager()->AsContentParent());
     }
   }
--- a/dom/media/AudioBufferUtils.h
+++ b/dom/media/AudioBufferUtils.h
@@ -167,17 +167,17 @@ public:
   {
     MOZ_ASSERT(aOther.mPosition == 0,
         "Don't use this ctor after AudioCallbackDriver::Init");
     MOZ_ASSERT(aOther.mChannels != 0);
     MOZ_ASSERT(aOther.mBuffer);
 
     mPosition = aOther.mPosition;
     mChannels = aOther.mChannels;
-    mBuffer = Move(aOther.mBuffer);
+    mBuffer = std::move(aOther.mBuffer);
 
     return *this;
   }
 
   SpillBuffer& operator=(SpillBuffer&& aOther)
   {
     return this->operator=(aOther);
   }
--- a/dom/media/AudioCompactor.h
+++ b/dom/media/AudioCompactor.h
@@ -69,17 +69,17 @@ public:
       if (!duration.IsValid()) {
         return false;
       }
 
       mQueue.Push(new AudioData(aOffset,
                                 time,
                                 duration,
                                 framesCopied,
-                                Move(buffer),
+                                std::move(buffer),
                                 aChannels,
                                 aSampleRate));
 
       // Remove the frames we just pushed into the queue and loop if there is
       // more to be done.
       time += duration;
       aFrames -= framesCopied;
 
--- a/dom/media/AudioConverter.h
+++ b/dom/media/AudioConverter.h
@@ -37,17 +37,17 @@ public:
   AudioDataBuffer() {}
   AudioDataBuffer(Value* aBuffer, size_t aLength)
     : mBuffer(aBuffer, aLength)
   {}
   explicit AudioDataBuffer(const AudioDataBuffer& aOther)
     : mBuffer(aOther.mBuffer)
   {}
   AudioDataBuffer(AudioDataBuffer&& aOther)
-    : mBuffer(Move(aOther.mBuffer))
+    : mBuffer(std::move(aOther.mBuffer))
   {}
   template <AudioConfig::SampleFormat OtherFormat, typename OtherValue>
   explicit AudioDataBuffer(const AudioDataBuffer<OtherFormat, OtherValue>& other)
   {
     // TODO: Convert from different type, may use asm routines.
     MOZ_CRASH("Conversion not implemented yet");
   }
 
@@ -68,51 +68,51 @@ public:
   }
   explicit AudioDataBuffer(const AlignedFloatBuffer& aBuffer)
     : mBuffer(aBuffer)
   {
     static_assert(Format == AudioConfig::FORMAT_FLT,
                   "Conversion not implemented yet");
   }
   explicit AudioDataBuffer(AlignedByteBuffer&& aBuffer)
-    : mBuffer(Move(aBuffer))
+    : mBuffer(std::move(aBuffer))
   {
     static_assert(Format == AudioConfig::FORMAT_U8,
                   "Conversion not implemented yet");
   }
   explicit AudioDataBuffer(AlignedShortBuffer&& aBuffer)
-    : mBuffer(Move(aBuffer))
+    : mBuffer(std::move(aBuffer))
   {
     static_assert(Format == AudioConfig::FORMAT_S16,
                   "Conversion not implemented yet");
   }
   explicit AudioDataBuffer(AlignedFloatBuffer&& aBuffer)
-    : mBuffer(Move(aBuffer))
+    : mBuffer(std::move(aBuffer))
   {
     static_assert(Format == AudioConfig::FORMAT_FLT,
                   "Conversion not implemented yet");
   }
   AudioDataBuffer& operator=(AudioDataBuffer&& aOther)
   {
-    mBuffer = Move(aOther.mBuffer);
+    mBuffer = std::move(aOther.mBuffer);
     return *this;
   }
   AudioDataBuffer& operator=(const AudioDataBuffer& aOther)
   {
     mBuffer = aOther.mBuffer;
     return *this;
   }
 
   Value* Data() const { return mBuffer.Data(); }
   size_t Length() const { return mBuffer.Length(); }
   size_t Size() const { return mBuffer.Size(); }
   AlignedBuffer<Value> Forget()
   {
     // Correct type -> Just give values as-is.
-    return Move(mBuffer);
+    return std::move(mBuffer);
   }
 private:
   AlignedBuffer<Value> mBuffer;
 };
 
 typedef AudioDataBuffer<AudioConfig::FORMAT_DEFAULT> AudioSampleBuffer;
 
 class AudioConverter {
@@ -124,60 +124,60 @@ public:
   // Conversion will be done in place if possible. Otherwise a new buffer will
   // be returned.
   // Providing an empty buffer and resampling is expected, the resampler
   // will be drained.
   template <AudioConfig::SampleFormat Format, typename Value>
   AudioDataBuffer<Format, Value> Process(AudioDataBuffer<Format, Value>&& aBuffer)
   {
     MOZ_DIAGNOSTIC_ASSERT(mIn.Format() == mOut.Format() && mIn.Format() == Format);
-    AudioDataBuffer<Format, Value> buffer = Move(aBuffer);
+    AudioDataBuffer<Format, Value> buffer = std::move(aBuffer);
     if (CanWorkInPlace()) {
       AlignedBuffer<Value> temp = buffer.Forget();
       Process(temp, temp.Data(), SamplesInToFrames(temp.Length()));
-      return AudioDataBuffer<Format, Value>(Move(temp));;
+      return AudioDataBuffer<Format, Value>(std::move(temp));;
     }
     return Process(buffer);
   }
 
   template <AudioConfig::SampleFormat Format, typename Value>
   AudioDataBuffer<Format, Value> Process(const AudioDataBuffer<Format, Value>& aBuffer)
   {
     MOZ_DIAGNOSTIC_ASSERT(mIn.Format() == mOut.Format() && mIn.Format() == Format);
     // Perform the downmixing / reordering in temporary buffer.
     size_t frames = SamplesInToFrames(aBuffer.Length());
     AlignedBuffer<Value> temp1;
     if (!temp1.SetLength(FramesOutToSamples(frames))) {
-      return AudioDataBuffer<Format, Value>(Move(temp1));
+      return AudioDataBuffer<Format, Value>(std::move(temp1));
     }
     frames = ProcessInternal(temp1.Data(), aBuffer.Data(), frames);
     if (mIn.Rate() == mOut.Rate()) {
       MOZ_ALWAYS_TRUE(temp1.SetLength(FramesOutToSamples(frames)));
-      return AudioDataBuffer<Format, Value>(Move(temp1));
+      return AudioDataBuffer<Format, Value>(std::move(temp1));
     }
 
     // At this point, temp1 contains the buffer reordered and downmixed.
     // If we are downsampling we can re-use it.
     AlignedBuffer<Value>* outputBuffer = &temp1;
     AlignedBuffer<Value> temp2;
     if (!frames || mOut.Rate() > mIn.Rate()) {
       // We are upsampling or about to drain, we can't work in place.
       // Allocate another temporary buffer where the upsampling will occur.
       if (!temp2.SetLength(FramesOutToSamples(ResampleRecipientFrames(frames)))) {
-        return AudioDataBuffer<Format, Value>(Move(temp2));
+        return AudioDataBuffer<Format, Value>(std::move(temp2));
       }
       outputBuffer = &temp2;
     }
     if (!frames) {
       frames = DrainResampler(outputBuffer->Data());
     } else {
       frames = ResampleAudio(outputBuffer->Data(), temp1.Data(), frames);
     }
     MOZ_ALWAYS_TRUE(outputBuffer->SetLength(FramesOutToSamples(frames)));
-    return AudioDataBuffer<Format, Value>(Move(*outputBuffer));
+    return AudioDataBuffer<Format, Value>(std::move(*outputBuffer));
   }
 
   // Attempt to convert the AudioDataBuffer in place.
   // Will return 0 if the conversion wasn't possible.
   template <typename Value>
   size_t Process(Value* aBuffer, size_t aFrames)
   {
     MOZ_DIAGNOSTIC_ASSERT(mIn.Format() == mOut.Format());
--- a/dom/media/AudioPacketizer.h
+++ b/dom/media/AudioPacketizer.h
@@ -57,17 +57,17 @@ public:
     // array has the right size.
     if (inputSamples > EmptySlots()) {
       // Calls to Input and Output are roughtly interleaved
       // (Input,Output,Input,Output, etc.), or balanced
       // (Input,Input,Input,Output,Output,Output), so we update the buffer to
       // the exact right size in order to not waste space.
       uint32_t newLength = AvailableSamples() + inputSamples;
       uint32_t toCopy = AvailableSamples();
-      UniquePtr<InputType[]> oldStorage = mozilla::Move(mStorage);
+      UniquePtr<InputType[]> oldStorage = std::move(mStorage);
       mStorage = mozilla::MakeUnique<InputType[]>(newLength);
       // Copy the old data at the beginning of the new storage.
       if (WriteIndex() >= ReadIndex()) {
         PodCopy(mStorage.get(),
                 oldStorage.get() + ReadIndex(),
                 AvailableSamples());
       } else {
         uint32_t firstPartLength = mLength - ReadIndex();
--- a/dom/media/AudioSegment.h
+++ b/dom/media/AudioSegment.h
@@ -286,17 +286,17 @@ struct AudioChunk {
  */
 class AudioSegment : public MediaSegmentBase<AudioSegment, AudioChunk> {
 public:
   typedef mozilla::AudioSampleFormat SampleFormat;
 
   AudioSegment() : MediaSegmentBase<AudioSegment, AudioChunk>(AUDIO) {}
 
   AudioSegment(AudioSegment&& aSegment)
-    : MediaSegmentBase<AudioSegment, AudioChunk>(Move(aSegment))
+    : MediaSegmentBase<AudioSegment, AudioChunk>(std::move(aSegment))
   {}
 
   AudioSegment(const AudioSegment&)=delete;
   AudioSegment& operator= (const AudioSegment&)=delete;
 
   ~AudioSegment() {}
 
   // Resample the whole segment in place.
--- a/dom/media/Benchmark.cpp
+++ b/dom/media/Benchmark.cpp
@@ -202,29 +202,29 @@ BenchmarkPlayback::DemuxNextSample()
 {
   MOZ_ASSERT(OnThread());
 
   RefPtr<Benchmark> ref(mMainThreadState);
   RefPtr<MediaTrackDemuxer::SamplesPromise> promise = mTrackDemuxer->GetSamples();
   promise->Then(
     Thread(), __func__,
     [this, ref](RefPtr<MediaTrackDemuxer::SamplesHolder> aHolder) {
-      mSamples.AppendElements(Move(aHolder->mSamples));
+      mSamples.AppendElements(std::move(aHolder->mSamples));
       if (ref->mParameters.mStopAtFrame &&
           mSamples.Length() == (size_t)ref->mParameters.mStopAtFrame.ref()) {
-        InitDecoder(Move(*mTrackDemuxer->GetInfo()));
+        InitDecoder(std::move(*mTrackDemuxer->GetInfo()));
       } else {
         Dispatch(NS_NewRunnableFunction("BenchmarkPlayback::DemuxNextSample",
                                         [this, ref]() { DemuxNextSample(); }));
       }
     },
     [this, ref](const MediaResult& aError) {
       switch (aError.Code()) {
         case NS_ERROR_DOM_MEDIA_END_OF_STREAM:
-          InitDecoder(Move(*mTrackDemuxer->GetInfo()));
+          InitDecoder(std::move(*mTrackDemuxer->GetInfo()));
           break;
         default:
           Error(aError);
           break;
       }
     });
 }
 
--- a/dom/media/ChannelMediaDecoder.cpp
+++ b/dom/media/ChannelMediaDecoder.cpp
@@ -402,17 +402,17 @@ ChannelMediaDecoder::OnPlaybackEvent(Med
       mPlaybackStatistics.AddBytes(newPos - mPlaybackPosition);
       mPlaybackPosition = newPos;
       mPlaybackStatistics.Stop();
       break;
     }
     default:
       break;
   }
-  MediaDecoder::OnPlaybackEvent(Move(aEvent));
+  MediaDecoder::OnPlaybackEvent(std::move(aEvent));
 }
 
 void
 ChannelMediaDecoder::DurationChanged()
 {
   MOZ_ASSERT(NS_IsMainThread());
   AbstractThread::AutoEnter context(AbstractMainThread());
   MediaDecoder::DurationChanged();
@@ -605,17 +605,17 @@ ChannelMediaDecoder::Resume()
 }
 
 void
 ChannelMediaDecoder::MetadataLoaded(
   UniquePtr<MediaInfo> aInfo,
   UniquePtr<MetadataTags> aTags,
   MediaDecoderEventVisibility aEventVisibility)
 {
-  MediaDecoder::MetadataLoaded(Move(aInfo), Move(aTags), aEventVisibility);
+  MediaDecoder::MetadataLoaded(std::move(aInfo), std::move(aTags), aEventVisibility);
   // Set mode to PLAYBACK after reading metadata.
   mResource->SetReadMode(MediaCacheStream::MODE_PLAYBACK);
 }
 
 nsCString
 ChannelMediaDecoder::GetDebugInfo()
 {
   nsCString str = MediaDecoder::GetDebugInfo();
--- a/dom/media/ChannelMediaResource.cpp
+++ b/dom/media/ChannelMediaResource.cpp
@@ -461,17 +461,17 @@ ChannelMediaResource::CopySegmentToCache
   }
 
   RefPtr<ChannelMediaResource> self = closure->mResource;
   uint32_t loadID = closure->mLoadID;
   UniquePtr<uint8_t[]> data = MakeUnique<uint8_t[]>(aCount);
   memcpy(data.get(), aFromSegment, aCount);
   cacheStream->OwnerThread()->Dispatch(NS_NewRunnableFunction(
     "MediaCacheStream::NotifyDataReceived",
-    [ self, loadID, data = Move(data), aCount ]() {
+    [ self, loadID, data = std::move(data), aCount ]() {
       self->mCacheStream.NotifyDataReceived(loadID, aCount, data.get());
     }));
 
   return NS_OK;
 }
 
 nsresult
 ChannelMediaResource::OnDataAvailable(uint32_t aLoadID,
--- a/dom/media/Intervals.h
+++ b/dom/media/Intervals.h
@@ -67,34 +67,34 @@ public:
 
   Interval(const SelfType& aOther)
     : mStart(aOther.mStart)
     , mEnd(aOther.mEnd)
     , mFuzz(aOther.mFuzz)
   { }
 
   Interval(SelfType&& aOther)
-    : mStart(Move(aOther.mStart))
-    , mEnd(Move(aOther.mEnd))
-    , mFuzz(Move(aOther.mFuzz))
+    : mStart(std::move(aOther.mStart))
+    , mEnd(std::move(aOther.mEnd))
+    , mFuzz(std::move(aOther.mFuzz))
   { }
 
   SelfType& operator= (const SelfType& aOther)
   {
     mStart = aOther.mStart;
     mEnd = aOther.mEnd;
     mFuzz = aOther.mFuzz;
     return *this;
   }
 
   SelfType& operator= (SelfType&& aOther)
   {
     MOZ_ASSERT(&aOther != this, "self-moves are prohibited");
     this->~Interval();
-    new(this) Interval(Move(aOther));
+    new(this) Interval(std::move(aOther));
     return *this;
   }
 
   // Basic interval arithmetic operator definition.
   SelfType operator+ (const SelfType& aOther) const
   {
     return SelfType(mStart + aOther.mStart,
                     mEnd + aOther.mEnd,
@@ -277,30 +277,30 @@ public:
 
   IntervalSet(const SelfType& aOther)
     : mIntervals(aOther.mIntervals)
   {
   }
 
   IntervalSet(SelfType&& aOther)
   {
-    mIntervals.AppendElements(Move(aOther.mIntervals));
+    mIntervals.AppendElements(std::move(aOther.mIntervals));
   }
 
   explicit IntervalSet(const ElemType& aOther)
   {
     if (!aOther.IsEmpty()) {
       mIntervals.AppendElement(aOther);
     }
   }
 
   explicit IntervalSet(ElemType&& aOther)
   {
     if (!aOther.IsEmpty()) {
-      mIntervals.AppendElement(Move(aOther));
+      mIntervals.AppendElement(std::move(aOther));
     }
   }
 
   bool operator== (const SelfType& aOther) const
   {
     return mIntervals == aOther.mIntervals;
   }
 
@@ -314,34 +314,34 @@ public:
     mIntervals = aOther.mIntervals;
     return *this;
   }
 
   SelfType& operator= (SelfType&& aOther)
   {
     MOZ_ASSERT(&aOther != this, "self-moves are prohibited");
     this->~IntervalSet();
-    new(this) IntervalSet(Move(aOther));
+    new(this) IntervalSet(std::move(aOther));
     return *this;
   }
 
   SelfType& operator= (const ElemType& aInterval)
   {
     mIntervals.Clear();
     if (!aInterval.IsEmpty()) {
       mIntervals.AppendElement(aInterval);
     }
     return *this;
   }
 
   SelfType& operator= (ElemType&& aInterval)
   {
     mIntervals.Clear();
     if (!aInterval.IsEmpty()) {
-      mIntervals.AppendElement(Move(aInterval));
+      mIntervals.AppendElement(std::move(aInterval));
     }
     return *this;
   }
 
   SelfType& Add(const SelfType& aIntervals)
   {
     mIntervals.AppendElements(aIntervals.mIntervals);
     Normalize();
@@ -374,25 +374,25 @@ public:
     IndexType i = 0;
     for (; i < mIntervals.Length(); i++) {
       ElemType& interval = mIntervals[i];
       if (current.Touches(interval)) {
         current = current.Span(interval);
       } else if (current.LeftOf(interval)) {
         break;
       } else {
-        normalized.AppendElement(Move(interval));
+        normalized.AppendElement(std::move(interval));
       }
     }
-    normalized.AppendElement(Move(current));
+    normalized.AppendElement(std::move(current));
     for (; i < mIntervals.Length(); i++) {
-      normalized.AppendElement(Move(mIntervals[i]));
+      normalized.AppendElement(std::move(mIntervals[i]));
     }
     mIntervals.Clear();
-    mIntervals.AppendElements(Move(normalized));
+    mIntervals.AppendElements(std::move(normalized));
 
     return *this;
   }
 
   SelfType& operator+= (const SelfType& aIntervals)
   {
     Add(aIntervals);
     return *this;
@@ -434,18 +434,18 @@ public:
   {
     if (aInterval.IsEmpty() || mIntervals.IsEmpty()) {
       return *this;
     }
     T firstEnd = std::max(mIntervals[0].mStart, aInterval.mStart);
     T secondStart = std::min(mIntervals.LastElement().mEnd, aInterval.mEnd);
     ElemType startInterval(mIntervals[0].mStart, firstEnd);
     ElemType endInterval(secondStart, mIntervals.LastElement().mEnd);
-    SelfType intervals(Move(startInterval));
-    intervals += Move(endInterval);
+    SelfType intervals(std::move(startInterval));
+    intervals += std::move(endInterval);
     return Intersection(intervals);
   }
 
   SelfType& operator-= (const SelfType& aIntervals)
   {
     for (const auto& interval : aIntervals.mIntervals) {
       *this -= interval;
     }
@@ -492,17 +492,17 @@ public:
       }
       if (mIntervals[i].mEnd < other[j].mEnd) {
         i++;
       } else {
         j++;
       }
     }
     mIntervals.Clear();
-    mIntervals.AppendElements(Move(intersection));
+    mIntervals.AppendElements(std::move(intersection));
     return *this;
   }
 
   SelfType& Intersection(const ElemType& aInterval)
   {
     SelfType intervals(aInterval);
     return Intersection(intervals);
   }
@@ -724,24 +724,24 @@ private:
 
       // This merges the intervals.
       ElemType current(mIntervals[0]);
       for (IndexType i = 1; i < mIntervals.Length(); i++) {
         ElemType& interval = mIntervals[i];
         if (current.Touches(interval)) {
           current = current.Span(interval);
         } else {
-          normalized.AppendElement(Move(current));
-          current = Move(interval);
+          normalized.AppendElement(std::move(current));
+          current = std::move(interval);
         }
       }
-      normalized.AppendElement(Move(current));
+      normalized.AppendElement(std::move(current));
 
       mIntervals.Clear();
-      mIntervals.AppendElements(Move(normalized));
+      mIntervals.AppendElements(std::move(normalized));
     }
   }
 
   struct CompareIntervals
   {
     bool Equals(const ElemType& aT1, const ElemType& aT2) const
     {
       return aT1.mStart == aT2.mStart && aT1.mEnd == aT2.mEnd;
--- a/dom/media/MediaContainerType.cpp
+++ b/dom/media/MediaContainerType.cpp
@@ -14,17 +14,17 @@ MediaContainerType::SizeOfExcludingThis(
   return mExtendedMIMEType.SizeOfExcludingThis(aMallocSizeOf);
 }
 
 Maybe<MediaContainerType>
 MakeMediaContainerType(const nsAString& aType)
 {
   Maybe<MediaExtendedMIMEType> mime = MakeMediaExtendedMIMEType(aType);
   if (mime) {
-    return Some(MediaContainerType(Move(*mime)));
+    return Some(MediaContainerType(std::move(*mime)));
   }
   return Nothing();
 }
 
 Maybe<MediaContainerType>
 MakeMediaContainerType(const nsACString& aType)
 {
   return MakeMediaContainerType(NS_ConvertUTF8toUTF16(aType));
--- a/dom/media/MediaContainerType.h
+++ b/dom/media/MediaContainerType.h
@@ -16,24 +16,24 @@ namespace mozilla {
 // Class containing media type information for containers.
 class MediaContainerType
 {
 public:
   explicit MediaContainerType(const MediaMIMEType& aType)
     : mExtendedMIMEType(aType)
   {}
   explicit MediaContainerType(MediaMIMEType&& aType)
-    : mExtendedMIMEType(Move(aType))
+    : mExtendedMIMEType(std::move(aType))
   {}
   explicit MediaContainerType(const MediaExtendedMIMEType& aType)
     : mExtendedMIMEType(aType)
   {
   }
   explicit MediaContainerType(MediaExtendedMIMEType&& aType)
-    : mExtendedMIMEType(Move(aType))
+    : mExtendedMIMEType(std::move(aType))
   {
   }
 
   const MediaMIMEType& Type() const { return mExtendedMIMEType.Type(); }
   const MediaExtendedMIMEType& ExtendedType() const { return mExtendedMIMEType; }
 
   // Original string. Note that "type/subtype" may not be lowercase,
   // use Type().AsString() instead to get the normalized "type/subtype".
--- a/dom/media/MediaData.cpp
+++ b/dom/media/MediaData.cpp
@@ -91,17 +91,17 @@ AudioData::TransferAndUpdateTimestampAnd
                                                  const TimeUnit& aTimestamp,
                                                  const TimeUnit& aDuration)
 {
   NS_ENSURE_TRUE(aOther, nullptr);
   RefPtr<AudioData> v = new AudioData(aOther->mOffset,
                                       aTimestamp,
                                       aDuration,
                                       aOther->mFrames,
-                                      Move(aOther->mAudioData),
+                                      std::move(aOther->mAudioData),
                                       aOther->mChannels,
                                       aOther->mRate,
                                       aOther->mChannelMap);
   return v.forget();
 }
 
 static bool
 ValidatePlane(const VideoData::YCbCrBuffer::Plane& aPlane)
@@ -173,17 +173,17 @@ VideoData::~VideoData()
 }
 
 void
 VideoData::SetListener(UniquePtr<Listener> aListener)
 {
   MOZ_ASSERT(!mSentToCompositor,
              "Listener should be registered before sending data");
 
-  mListener = Move(aListener);
+  mListener = std::move(aListener);
 }
 
 void
 VideoData::MarkSentToCompositor()
 {
   if (mSentToCompositor) {
     return;
   }
--- a/dom/media/MediaData.h
+++ b/dom/media/MediaData.h
@@ -94,28 +94,28 @@ public:
   AlignedBuffer(const AlignedBuffer& aOther)
     : AlignedBuffer(aOther.Data(), aOther.Length())
   {
   }
 
   AlignedBuffer(AlignedBuffer&& aOther)
     : mData(aOther.mData)
     , mLength(aOther.mLength)
-    , mBuffer(Move(aOther.mBuffer))
+    , mBuffer(std::move(aOther.mBuffer))
     , mCapacity(aOther.mCapacity)
   {
     aOther.mData = nullptr;
     aOther.mLength = 0;
     aOther.mCapacity = 0;
   }
 
   AlignedBuffer& operator=(AlignedBuffer&& aOther)
   {
     this->~AlignedBuffer();
-    new (this) AlignedBuffer(Move(aOther));
+    new (this) AlignedBuffer(std::move(aOther));
     return *this;
   }
 
   Type* Data() const { return mData; }
   size_t Length() const { return mLength; }
   size_t Size() const { return mLength * sizeof(Type); }
   Type& operator[](size_t aIndex)
   {
@@ -258,17 +258,17 @@ private:
 
     MOZ_ASSERT(!mLength || mData);
 
     PodZero(newData + mLength, aLength - mLength);
     if (mLength) {
       PodCopy(newData, mData, mLength);
     }
 
-    mBuffer = Move(newBuffer);
+    mBuffer = std::move(newBuffer);
     mCapacity = sizeNeeded.value();
     mData = newData;
 
     return true;
   }
   Type* mData;
   size_t mLength;
   UniquePtr<uint8_t[]> mBuffer;
@@ -396,17 +396,17 @@ public:
             AlignedAudioBuffer&& aData,
             uint32_t aChannels,
             uint32_t aRate,
             uint32_t aChannelMap = AudioConfig::ChannelLayout::UNKNOWN_MAP)
     : MediaData(sType, aOffset, aTime, aDuration, aFrames)
     , mChannels(aChannels)
     , mChannelMap(aChannelMap)
     , mRate(aRate)
-    , mAudioData(Move(aData))
+    , mAudioData(std::move(aData))
   {
   }
 
   static const Type sType = AUDIO_DATA;
   static const char* sTypeName;
 
   // Creates a new AudioData identical to aOther, but with a different
   // specified timestamp and duration. All data from aOther is copied
--- a/dom/media/MediaDecoder.cpp
+++ b/dom/media/MediaDecoder.cpp
@@ -576,17 +576,17 @@ void
 MediaDecoder::OnMetadataUpdate(TimedMetadata&& aMetadata)
 {
   MOZ_ASSERT(NS_IsMainThread());
   AbstractThread::AutoEnter context(AbstractMainThread());
   GetOwner()->RemoveMediaTracks();
   MetadataLoaded(MakeUnique<MediaInfo>(*aMetadata.mInfo),
                  UniquePtr<MetadataTags>(aMetadata.mTags.forget()),
                  MediaDecoderEventVisibility::Observable);
-  FirstFrameLoaded(Move(aMetadata.mInfo),
+  FirstFrameLoaded(std::move(aMetadata.mInfo),
                    MediaDecoderEventVisibility::Observable);
 }
 
 void
 MediaDecoder::MetadataLoaded(UniquePtr<MediaInfo> aInfo,
                              UniquePtr<MetadataTags> aTags,
                              MediaDecoderEventVisibility aEventVisibility)
 {
@@ -602,17 +602,17 @@ MediaDecoder::MetadataLoaded(UniquePtr<M
   mMediaSeekableOnlyInBufferedRanges = aInfo->mMediaSeekableOnlyInBufferedRanges;
   mInfo = aInfo.release();
   GetOwner()->ConstructMediaTracks(mInfo);
 
   // Make sure the element and the frame (if any) are told about
   // our new size.
   if (aEventVisibility != MediaDecoderEventVisibility::Suppressed) {
     mFiredMetadataLoaded = true;
-    GetOwner()->MetadataLoaded(mInfo, Move(aTags));
+    GetOwner()->MetadataLoaded(mInfo, std::move(aTags));
   }
   // Invalidate() will end up calling GetOwner()->UpdateMediaSize with the last
   // dimensions retrieved from the video frame container. The video frame
   // container contains more up to date dimensions than aInfo.
   // So we call Invalidate() after calling GetOwner()->MetadataLoaded to ensure
   // the media element has the latest dimensions.
   Invalidate();
 
--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -255,17 +255,17 @@ protected:
 
   template <class S, typename... Args, size_t... Indexes>
   auto
   CallEnterMemberFunction(S* aS,
                           Tuple<Args...>& aTuple,
                           std::index_sequence<Indexes...>)
     -> decltype(ReturnTypeHelper(&S::Enter))
   {
-    return aS->Enter(Move(Get<Indexes>(aTuple))...);
+    return aS->Enter(std::move(Get<Indexes>(aTuple))...);
   }
 
   // Note this function will delete the current state object.
   // Don't access members to avoid UAF after this call.
   template <class S, typename... Ts>
   auto SetState(Ts&&... aArgs)
     -> decltype(ReturnTypeHelper(&S::Enter))
   {
@@ -288,17 +288,17 @@ protected:
     SLOG("change state to: %s", ToStateStr(s->GetState()));
 
     Exit();
 
     // Delete the old state asynchronously to avoid UAF if the caller tries to
     // access its members after SetState() returns.
     master->OwnerThread()->DispatchDirectTask(
       NS_NewRunnableFunction("MDSM::StateObject::DeleteOldState",
-                             [toDelete = Move(master->mStateObj)](){}));
+                             [toDelete = std::move(master->mStateObj)](){}));
     // Also reset mMaster to catch potentail UAF.
     mMaster = nullptr;
 
     master->mStateObj.reset(s);
     return CallEnterMemberFunction(s, copiedArgs,
                                    std::index_sequence_for<Ts...>{});
   }
 
@@ -329,17 +329,17 @@ public:
     MOZ_ASSERT(!mMetadataRequest.Exists());
     SLOG("Dispatching AsyncReadMetadata");
 
     // We disconnect mMetadataRequest in Exit() so it is fine to capture
     // a raw pointer here.
     Reader()->ReadMetadata()
       ->Then(OwnerThread(), __func__,
         [this] (MetadataHolder&& aMetadata) {
-          OnMetadataRead(Move(aMetadata));
+          OnMetadataRead(std::move(aMetadata));
         },
         [this] (const MediaResult& aError) {
           OnMetadataNotRead(aError);
         })
       ->Track(mMetadataRequest);
   }
 
   void Exit() override { mMetadataRequest.DisconnectIfExists(); }
@@ -820,17 +820,17 @@ class MediaDecoderStateMachine::SeekingS
   : public MediaDecoderStateMachine::StateObject
 {
 public:
   explicit SeekingState(Master* aPtr) : StateObject(aPtr) { }
 
   RefPtr<MediaDecoder::SeekPromise> Enter(SeekJob&& aSeekJob,
                                           EventVisibility aVisibility)
   {
-    mSeekJob = Move(aSeekJob);
+    mSeekJob = std::move(aSeekJob);
     mVisibility = aVisibility;
 
     // Suppressed visibility comes from two cases: (1) leaving dormant state,
     // and (2) resuming suspended video decoder. We want both cases to be
     // transparent to the user. So we only notify the change when the seek
     // request is from the user.
     if (mVisibility == EventVisibility::Observable) {
       // Don't stop playback for a video-only seek since we want to keep playing
@@ -890,17 +890,17 @@ class MediaDecoderStateMachine::Accurate
 public:
   explicit AccurateSeekingState(Master* aPtr) : SeekingState(aPtr) { }
 
   RefPtr<MediaDecoder::SeekPromise> Enter(SeekJob&& aSeekJob,
                                           EventVisibility aVisibility)
   {
     MOZ_ASSERT(aSeekJob.mTarget->IsAccurate() || aSeekJob.mTarget->IsFast());
     mCurrentTimeBeforeSeek = mMaster->GetMediaTime();
-    return SeekingState::Enter(Move(aSeekJob), aVisibility);
+    return SeekingState::Enter(std::move(aSeekJob), aVisibility);
   }
 
   void Exit() override
   {
     // Disconnect MediaDecoder.
     mSeekJob.RejectIfExists(__func__);
 
     // Disconnect ReaderProxy.
@@ -1228,17 +1228,17 @@ protected:
            aAudio->mAudioData.get() + (framesToPrune.value() * channels),
            frames * channels * sizeof(AudioDataValue));
     auto duration = FramesToTimeUnit(frames, Info().mAudio.mRate);
     if (!duration.IsValid()) {
       return NS_ERROR_DOM_MEDIA_OVERFLOW_ERR;
     }
     RefPtr<AudioData> data(new AudioData(
       aAudio->mOffset, mSeekJob.mTarget->GetTime(),
-      duration, frames, Move(audioData), channels,
+      duration, frames, std::move(audioData), channels,
       aAudio->mRate, aAudio->mChannelMap));
     MOZ_ASSERT(AudioQueue().GetSize() == 0,
                "Should be the 1st sample after seeking");
     mMaster->PushAudio(data);
     mDoneAudioSeeking = true;
 
     return NS_OK;
   }
@@ -1360,17 +1360,17 @@ public:
   explicit NextFrameSeekingState(Master* aPtr) : SeekingState(aPtr) { }
 
   RefPtr<MediaDecoder::SeekPromise> Enter(SeekJob&& aSeekJob,
                                           EventVisibility aVisibility)
   {
     MOZ_ASSERT(aSeekJob.mTarget->IsNextFrame());
     mCurrentTime = mMaster->GetMediaTime();
     mDuration = mMaster->Duration();
-    return SeekingState::Enter(Move(aSeekJob), aVisibility);
+    return SeekingState::Enter(std::move(aSeekJob), aVisibility);
   }
 
   void Exit() override
   {
     // Disconnect my async seek operation.
     if (mAsyncSeekTask) { mAsyncSeekTask->Cancel(); }
 
     // Disconnect MediaDecoder.
@@ -1581,19 +1581,19 @@ public:
   explicit NextFrameSeekingFromDormantState(Master* aPtr)
     : AccurateSeekingState(aPtr)
   {
   }
 
   RefPtr<MediaDecoder::SeekPromise> Enter(SeekJob&& aCurrentSeekJob,
                                           SeekJob&& aFutureSeekJob)
   {
-    mFutureSeekJob = Move(aFutureSeekJob);
-
-    AccurateSeekingState::Enter(Move(aCurrentSeekJob),
+    mFutureSeekJob = std::move(aFutureSeekJob);
+
+    AccurateSeekingState::Enter(std::move(aCurrentSeekJob),
                                 EventVisibility::Suppressed);
 
     // Once seekToNextFrame() is called, we assume the user is likely to keep
     // calling seekToNextFrame() repeatedly, and so, we should prevent the MDSM
     // from getting into Dormant state.
     mMaster->mMinimizePreroll = false;
 
     return mFutureSeekJob.mPromise.Ensure(__func__);
@@ -1607,17 +1607,17 @@ public:
 
 private:
   SeekJob mFutureSeekJob;
 
   // We don't want to transition to DecodingState once this seek completes,
   // instead, we transition to NextFrameSeekingState.
   void GoToNextState() override
   {
-    SetState<NextFrameSeekingState>(Move(mFutureSeekJob),
+    SetState<NextFrameSeekingState>(std::move(mFutureSeekJob),
                                     EventVisibility::Observable);
   }
 };
 
 class MediaDecoderStateMachine::VideoOnlySeekingState
   : public MediaDecoderStateMachine::AccurateSeekingState
 {
 public:
@@ -1625,17 +1625,17 @@ public:
 
   RefPtr<MediaDecoder::SeekPromise> Enter(SeekJob&& aSeekJob,
                                           EventVisibility aVisibility)
   {
     MOZ_ASSERT(aSeekJob.mTarget->IsVideoOnly());
     MOZ_ASSERT(aVisibility == EventVisibility::Suppressed);
 
     RefPtr<MediaDecoder::SeekPromise> p =
-      AccurateSeekingState::Enter(Move(aSeekJob), aVisibility);
+      AccurateSeekingState::Enter(std::move(aSeekJob), aVisibility);
 
     // Dispatch a mozvideoonlyseekbegin event to indicate UI for corresponding
     // changes.
     mMaster->mOnPlaybackEvent.Notify(MediaPlaybackEvent::VideoOnlySeekBegin);
 
     return p.forget();
   }
 
@@ -1749,17 +1749,17 @@ MediaDecoderStateMachine::DormantState::
     // NextFrameSeekingState doesn't reset the decoder unlike
     // AccurateSeekingState. So we first must come out of dormant by seeking to
     // mPendingSeek and continue later with the NextFrameSeek
     SLOG("Changed state to SEEKING (to %" PRId64 ")",
         aTarget.GetTime().ToMicroseconds());
     SeekJob seekJob;
     seekJob.mTarget = Some(aTarget);
     return StateObject::SetState<NextFrameSeekingFromDormantState>(
-      Move(mPendingSeek), Move(seekJob));
+      std::move(mPendingSeek), std::move(seekJob));
   }
 
   return StateObject::HandleSeek(aTarget);
 }
 
 /**
  * Purpose: stop playback until enough data is decoded to continue playback.
  *
@@ -2040,17 +2040,17 @@ public:
 
 RefPtr<MediaDecoder::SeekPromise>
 MediaDecoderStateMachine::
 StateObject::HandleSeek(SeekTarget aTarget)
 {
   SLOG("Changed state to SEEKING (to %" PRId64 ")", aTarget.GetTime().ToMicroseconds());
   SeekJob seekJob;
   seekJob.mTarget = Some(aTarget);
-  return SetSeekingState(Move(seekJob), EventVisibility::Observable);
+  return SetSeekingState(std::move(seekJob), EventVisibility::Observable);
 }
 
 RefPtr<ShutdownPromise>
 MediaDecoderStateMachine::
 StateObject::HandleShutdown()
 {
   return SetState<ShutdownState>();
 }
@@ -2128,35 +2128,35 @@ StateObject::HandleResumeVideoDecoding(c
                     : SeekTarget::Type::PrevSyncPoint;
 
   seekJob.mTarget.emplace(aTarget, type, true /* aVideoOnly */);
 
   // Hold mMaster->mAbstractMainThread here because this->mMaster will be
   // invalid after the current state object is deleted in SetState();
   RefPtr<AbstractThread> mainThread = mMaster->mAbstractMainThread;
 
-  SetSeekingState(Move(seekJob), EventVisibility::Suppressed)->Then(
+  SetSeekingState(std::move(seekJob), EventVisibility::Suppressed)->Then(
     mainThread, __func__,
     [start, info, hw](){ ReportRecoveryTelemetry(start, info, hw); },
     [](){});
 }
 
 RefPtr<MediaDecoder::SeekPromise>
 MediaDecoderStateMachine::
 StateObject::SetSeekingState(SeekJob&& aSeekJob, EventVisibility aVisibility)
 {
   if (aSeekJob.mTarget->IsAccurate() || aSeekJob.mTarget->IsFast()) {
     if (aSeekJob.mTarget->IsVideoOnly()) {
-      return SetState<VideoOnlySeekingState>(Move(aSeekJob), aVisibility);
+      return SetState<VideoOnlySeekingState>(std::move(aSeekJob), aVisibility);
     }
-    return SetState<AccurateSeekingState>(Move(aSeekJob), aVisibility);
+    return SetState<AccurateSeekingState>(std::move(aSeekJob), aVisibility);
   }
 
   if (aSeekJob.mTarget->IsNextFrame()) {
-    return SetState<NextFrameSeekingState>(Move(aSeekJob), aVisibility);
+    return SetState<NextFrameSeekingState>(std::move(aSeekJob), aVisibility);
   }
 
   MOZ_ASSERT_UNREACHABLE("Unknown SeekTarget::Type.");
   return nullptr;
 }
 
 void
 MediaDecoderStateMachine::
@@ -2192,18 +2192,18 @@ DecodeMetadataState::OnMetadataRead(Meta
     SLOG("Video decode HWAccel=%d videoQueueSize=%d",
          Reader()->VideoIsHardwareAccelerated(),
          mMaster->GetAmpleVideoFrames());
   }
 
   MOZ_ASSERT(mMaster->mDuration.Ref().isSome());
 
   mMaster->mMetadataLoadedEvent.Notify(
-    Move(aMetadata.mInfo),
-    Move(aMetadata.mTags),
+    std::move(aMetadata.mInfo),
+    std::move(aMetadata.mTags),
     MediaDecoderEventVisibility::Observable);
 
   // Check whether the media satisfies the requirement of seamless looing.
   // (Before checking the media is audio only, we need to get metadata first.)
   mMaster->mSeamlessLoopingAllowed = StaticPrefs::MediaSeamlessLooping() &&
                                      mMaster->HasAudio() &&
                                      !mMaster->HasVideo();
   mMaster->LoopingChanged();
@@ -2213,17 +2213,17 @@ DecodeMetadataState::OnMetadataRead(Meta
 
 void
 MediaDecoderStateMachine::
 DormantState::HandlePlayStateChanged(MediaDecoder::PlayState aPlayState)
 {
   if (aPlayState == MediaDecoder::PLAY_STATE_PLAYING) {
     // Exit dormant when the user wants to play.
     MOZ_ASSERT(mMaster->mSentFirstFrameLoadedEvent);
-    SetSeekingState(Move(mPendingSeek), EventVisibility::Suppressed);
+    SetSeekingState(std::move(mPendingSeek), EventVisibility::Suppressed);
   }
 }
 
 void
 MediaDecoderStateMachine::
 DecodingFirstFrameState::Enter()
 {
   // Transition to DECODING if we've decoded first frames.
@@ -2251,17 +2251,17 @@ DecodingFirstFrameState::MaybeFinishDeco
 
   if ((mMaster->IsAudioDecoding() && AudioQueue().GetSize() == 0) ||
       (mMaster->IsVideoDecoding() && VideoQueue().GetSize() == 0)) {
     return;
   }
 
   mMaster->FinishDecodeFirstFrame();
   if (mPendingSeek.Exists()) {
-    SetSeekingState(Move(mPendingSeek), EventVisibility::Observable);
+    SetSeekingState(std::move(mPendingSeek), EventVisibility::Observable);
   } else {
     SetState<DecodingState>();
   }
 }
 
 void
 MediaDecoderStateMachine::
 DecodingState::Enter()
@@ -3801,17 +3801,17 @@ MediaDecoderStateMachine::GetDebugInfo()
     mDecodedAudioEndTime.ToMicroseconds(),
     mDecodedVideoEndTime.ToMicroseconds(),
     mAudioCompleted,
     mVideoCompleted,
     mStateObj->GetDebugInfo().get());
 
   AppendStringIfNotEmpty(str, mMediaSink->GetDebugInfo());
 
-  return Move(str);
+  return std::move(str);
 }
 
 RefPtr<MediaDecoder::DebugInfoPromise>
 MediaDecoderStateMachine::RequestDebugInfo()
 {
   using PromiseType = MediaDecoder::DebugInfoPromise;
   RefPtr<PromiseType::Private> p = new PromiseType::Private(__func__);
   RefPtr<MediaDecoderStateMachine> self = this;
--- a/dom/media/MediaEventSource.h
+++ b/dom/media/MediaEventSource.h
@@ -96,25 +96,25 @@ template <typename T>
 struct TakeArgs : public TakeArgsHelper<T>::Type {};
 
 template <typename T> struct EventTarget;
 
 template <>
 struct EventTarget<nsIEventTarget> {
   static void
   Dispatch(nsIEventTarget* aTarget, already_AddRefed<nsIRunnable> aTask) {
-    aTarget->Dispatch(Move(aTask), NS_DISPATCH_NORMAL);
+    aTarget->Dispatch(std::move(aTask), NS_DISPATCH_NORMAL);
   }
 };
 
 template <>
 struct EventTarget<AbstractThread> {
   static void
   Dispatch(AbstractThread* aTarget, already_AddRefed<nsIRunnable> aTask) {
-    Unused << aTarget->Dispatch(Move(aTask));
+    Unused << aTarget->Dispatch(std::move(aTask));
   }
 };
 
 /**
  * Encapsulate a raw pointer to be captured by a lambda without causing
  * static-analysis errors.
  */
 template <typename T>
@@ -180,46 +180,46 @@ public:
     : mTarget(aTarget)
     , mFunction(Forward<F>(aFunction))
   {
   }
 
 private:
   void DispatchTask(already_AddRefed<nsIRunnable> aTask) override
   {
-    EventTarget<Target>::Dispatch(mTarget.get(), Move(aTask));
+    EventTarget<Target>::Dispatch(mTarget.get(), std::move(aTask));
   }
 
   bool CanTakeArgs() const override
   {
     return TakeArgs<FunctionStorage>::value;
   }
 
   // |F| takes one or more arguments.
   template <typename F>
   typename EnableIf<TakeArgs<F>::value, void>::Type
   ApplyWithArgsImpl(const F& aFunc, As&&... aEvents)
   {
-    aFunc(Move(aEvents)...);
+    aFunc(std::move(aEvents)...);
   }
 
   // |F| takes no arguments.
   template <typename F>
   typename EnableIf<!TakeArgs<F>::value, void>::Type
   ApplyWithArgsImpl(const F& aFunc, As&&... aEvents)
   {
     MOZ_CRASH("Call ApplyWithNoArgs instead.");
   }
 
   void ApplyWithArgs(As&&... aEvents) override
   {
     MOZ_RELEASE_ASSERT(TakeArgs<Function>::value);
     // Don't call the listener if it is disconnected.
     if (!RevocableToken::IsRevoked()) {
-      ApplyWithArgsImpl(mFunction, Move(aEvents)...);
+      ApplyWithArgsImpl(mFunction, std::move(aEvents)...);
     }
   }
 
   // |F| takes one or more arguments.
   template <typename F>
   typename EnableIf<TakeArgs<F>::value, void>::Type
   ApplyWithNoArgsImpl(const F& aFunc)
   {
@@ -274,21 +274,21 @@ template <ListenerPolicy, typename... Ts
 class MediaEventListener {
   template <ListenerPolicy, typename... Ts>
   friend class MediaEventSourceImpl;
 
 public:
   MediaEventListener() {}
 
   MediaEventListener(MediaEventListener&& aOther)
-    : mToken(Move(aOther.mToken)) {}
+    : mToken(std::move(aOther.mToken)) {}
 
   MediaEventListener& operator=(MediaEventListener&& aOther) {
     MOZ_ASSERT(!mToken, "Must disconnect the listener.");
-    mToken = Move(aOther.mToken);
+    mToken = std::move(aOther.mToken);
     return *this;
   }
 
   ~MediaEventListener() {
     MOZ_ASSERT(!mToken, "Must disconnect the listener.");
   }
 
   void Disconnect() {
@@ -351,17 +351,17 @@ class MediaEventSourceImpl {
 
   // |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);
     return ConnectInternal(aTarget,
       [=](ArgType<Es>&&... aEvents) {
-        (thiz.get()->*aMethod)(Move(aEvents)...);
+        (thiz.get()->*aMethod)(std::move(aEvents)...);
       });
   }
 
   // |Method| takes no arguments. Don't bother passing the event data.
   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);
--- a/dom/media/MediaFormatReader.cpp
+++ b/dom/media/MediaFormatReader.cpp
@@ -1564,17 +1564,17 @@ MediaFormatReader::AsyncReadMetadata()
   MOZ_ASSERT(OnTaskQueue());
 
   MOZ_DIAGNOSTIC_ASSERT(mMetadataPromise.IsEmpty());
 
   if (mInitDone) {
     // We are returning from dormant.
     MetadataHolder metadata;
     metadata.mInfo = MakeUnique<MediaInfo>(mInfo);
-    return MetadataPromise::CreateAndResolve(Move(metadata), __func__);
+    return MetadataPromise::CreateAndResolve(std::move(metadata), __func__);
   }
 
   RefPtr<MetadataPromise> p = mMetadataPromise.Ensure(__func__);
 
   mDemuxer->Init()
     ->Then(OwnerThread(), __func__, this,
            &MediaFormatReader::OnDemuxerInitDone,
            &MediaFormatReader::OnDemuxerInitFailed)
@@ -1625,17 +1625,17 @@ MediaFormatReader::OnDemuxerInitDone(con
       }
       {
         MutexAutoLock lock(mVideo.mMutex);
         mInfo.mVideo = *videoInfo->GetAsVideoInfo();
       }
       for (const MetadataTag& tag : videoInfo->mTags) {
         tags->Put(tag.mKey, tag.mValue);
       }
-      mVideo.mOriginalInfo = Move(videoInfo);
+      mVideo.mOriginalInfo = std::move(videoInfo);
       mTrackDemuxersMayBlock |= mVideo.mTrackDemuxer->GetSamplesMayBlock();
     } else {
       mVideo.mTrackDemuxer->BreakCycles();
       mVideo.mTrackDemuxer = nullptr;
     }
   }
 
   bool audioActive = !!mDemuxer->GetNumberTracks(TrackInfo::kAudioTrack);
@@ -1655,17 +1655,17 @@ MediaFormatReader::OnDemuxerInitDone(con
     if (audioActive) {
       {
         MutexAutoLock lock(mAudio.mMutex);
         mInfo.mAudio = *audioInfo->GetAsAudioInfo();
       }
       for (const MetadataTag& tag : audioInfo->mTags) {
         tags->Put(tag.mKey, tag.mValue);
       }
-      mAudio.mOriginalInfo = Move(audioInfo);
+      mAudio.mOriginalInfo = std::move(audioInfo);
       mTrackDemuxersMayBlock |= mAudio.mTrackDemuxer->GetSamplesMayBlock();
     } else {
       mAudio.mTrackDemuxer->BreakCycles();
       mAudio.mTrackDemuxer = nullptr;
     }
   }
 
   UniquePtr<EncryptionInfo> crypto = mDemuxer->GetCrypto();
@@ -1690,17 +1690,17 @@ MediaFormatReader::OnDemuxerInitDone(con
   mInfo.mMediaSeekableOnlyInBufferedRanges =
     mDemuxer->IsSeekableOnlyInBufferedRanges();
 
   if (!videoActive && !audioActive) {
     mMetadataPromise.Reject(NS_ERROR_DOM_MEDIA_METADATA_ERR, __func__);
     return;
   }
 
-  mTags = Move(tags);
+  mTags = std::move(tags);
   mInitDone = true;
 
   // Try to get the start time.
   // For MSE case, the start time of each track is assumed to be 0.
   // For others, we must demux the first sample to know the start time for each
   // track.
   if (!mDemuxer->ShouldComputeStartTime()) {
     mAudio.mFirstDemuxedSampleTime.emplace(TimeUnit::Zero());
@@ -1737,24 +1737,24 @@ MediaFormatReader::MaybeResolveMetadataP
              mVideo.mFirstDemuxedSampleTime.refOr(TimeUnit::FromInfinity()));
 
   if (!startTime.IsInfinite()) {
     mInfo.mStartTime = startTime; // mInfo.mStartTime is initialized to 0.
   }
 
   MetadataHolder metadata;
   metadata.mInfo = MakeUnique<MediaInfo>(mInfo);
-  metadata.mTags = mTags->Count() ? Move(mTags) : nullptr;
+  metadata.mTags = mTags->Count() ? std::move(mTags) : nullptr;
 
   // We now have all the informations required to calculate the initial buffered
   // range.
   mHasStartTime = true;
   UpdateBuffered();
 
-  mMetadataPromise.Resolve(Move(metadata), __func__);
+  mMetadataPromise.Resolve(std::move(metadata), __func__);
 }
 
 bool
 MediaFormatReader::IsEncrypted() const
 {
   return (HasAudio() && mAudio.GetCurrentInfo()->mCrypto.mValid) ||
          (HasVideo() && mVideo.GetCurrentInfo()->mCrypto.mValid);
 }
@@ -2445,17 +2445,17 @@ MediaFormatReader::HandleDemuxedSamples(
     decoder.mNextStreamSourceID.reset();
     decoder.mLastStreamSourceID = info->GetID();
     decoder.mInfo = info;
 
     decoder.mMeanRate.Reset();
 
     if (sample->mKeyframe) {
       if (samples.Length()) {
-        decoder.mQueuedSamples = Move(samples);
+        decoder.mQueuedSamples = std::move(samples);
       }
     } else {
       auto time = TimeInterval(sample->mTime, sample->GetEndTime());
       InternalSeekTarget seekTarget =
         decoder.mTimeThreshold.refOr(InternalSeekTarget(time, false));
       LOG("Stream change occurred on a non-keyframe. Seeking to:%" PRId64,
           sample->mTime.ToMicroseconds());
       InternalSeek(aTrack, seekTarget);
--- a/dom/media/MediaMIMETypes.cpp
+++ b/dom/media/MediaMIMETypes.cpp
@@ -164,17 +164,17 @@ MediaExtendedMIMEType::MediaExtendedMIME
 MediaExtendedMIMEType::MediaExtendedMIMEType(const MediaMIMEType& aType)
   : mOriginalString(aType.AsString())
   , mMIMEType(aType)
 {
 }
 
 MediaExtendedMIMEType::MediaExtendedMIMEType(MediaMIMEType&& aType)
   : mOriginalString(aType.AsString())
-  , mMIMEType(Move(aType))
+  , mMIMEType(std::move(aType))
 {
 }
 
 Maybe<MediaExtendedMIMEType>
 MakeMediaExtendedMIMEType(const nsAString& aType)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
--- a/dom/media/MediaManager.cpp
+++ b/dom/media/MediaManager.cpp
@@ -1445,17 +1445,17 @@ public:
         LOG(("GetUserMediaStreamRunnable::Run: starting success callback "
              "following InitializeAsync()"));
         // Initiating and starting devices succeeded.
         // onTracksAvailableCallback must be added to domStream on main thread.
         domStream->OnTracksAvailable(callback->release());
         windowListener->ChromeAffectingStateChanged();
         manager->SendPendingGUMRequest();
       },[manager = mManager, windowID = mWindowID,
-         onFailure = Move(mOnFailure)](const RefPtr<MediaMgrError>& error)
+         onFailure = std::move(mOnFailure)](const RefPtr<MediaMgrError>& error)
       {
         LOG(("GetUserMediaStreamRunnable::Run: starting failure callback "
              "following InitializeAsync()"));
         // Initiating and starting devices failed.
 
         // Only run if the window is still active for our window listener.
         if (!(manager->IsWindowStillActive(windowID))) {
           return;
@@ -1962,17 +1962,17 @@ MediaManager::EnumerateRawDevices(uint64
       LOG(("EnumerateRawDevices Task: Getting audio sources with %s backend",
            aVideoEnumType == DeviceEnumerationType::Fake ? "fake" : "real"));
       GetSources(aAudioEnumType == DeviceEnumerationType::Fake ? fakeBackend : realBackend,
                  aWindowId, aAudioType, audios, audioLoopDev.get());
       for (auto& source : audios) {
         result->AppendElement(source);
       }
     }
-    NS_DispatchToMainThread(NewRunnableFrom([id, result = Move(result)]() mutable {
+    NS_DispatchToMainThread(NewRunnableFrom([id, result = std::move(result)]() mutable {
       MediaManager* mgr = MediaManager::GetIfExists();
       if (!mgr) {
         return NS_OK;
       }
       RefPtr<PledgeSourceSet> p = mgr->mOutstandingPledges.Remove(id);
       if (p) {
         p->Resolve(result.release());
       }
@@ -2228,27 +2228,27 @@ MediaManager::PostTask(already_AddRefed<
     // thread-release requirements.
     // XXXkhuey well then who is supposed to delete it?! We don't signal
     // that we failed ...
     MOZ_CRASH();
     return;
   }
   NS_ASSERTION(Get(), "MediaManager singleton?");
   NS_ASSERTION(Get()->mMediaThread, "No thread yet");
-  Get()->mMediaThread->message_loop()->PostTask(Move(task));
+  Get()->mMediaThread->message_loop()->PostTask(std::move(task));
 }
 
 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 = Move(holder), func = Forward<FunctionType>(aFunction)]() mutable
+        [h = std::move(holder), func = Forward<FunctionType>(aFunction)]() mutable
         {
           func(h);
         }));
   return promise;
 }
 
 /* static */ nsresult
 MediaManager::NotifyRecordingStatusChange(nsPIDOMWindowInner* aWindow)
@@ -4098,31 +4098,31 @@ SourceListener::InitializeAsync()
         state->mDeviceEnabled = true;
         state->mTrackEnabled = true;
         state->mTrackEnabledTime = TimeStamp::Now();
       }
       return InitPromise::CreateAndResolve(true, __func__);
     }, [self = RefPtr<SourceListener>(this), this](RefPtr<MediaMgrError>&& aResult)
     {
       if (mStopped) {
-        return InitPromise::CreateAndReject(Move(aResult), __func__);
+        return InitPromise::CreateAndReject(std::move(aResult), __func__);
       }
 
       for (DeviceState* state : {mAudioDeviceState.get(),
                                  mVideoDeviceState.get()}) {
         if (!state) {
           continue;
         }
         MOZ_DIAGNOSTIC_ASSERT(!state->mTrackEnabled);
         MOZ_DIAGNOSTIC_ASSERT(!state->mDeviceEnabled);
         MOZ_DIAGNOSTIC_ASSERT(!state->mStopped);
 
         state->mStopped = true;
       }
-      return InitPromise::CreateAndReject(Move(aResult), __func__);
+      return InitPromise::CreateAndReject(std::move(aResult), __func__);
     });
 }
 
 void
 SourceListener::Stop()
 {
   MOZ_ASSERT(NS_IsMainThread(), "Only call on main thread");
 
--- a/dom/media/MediaMetadataManager.h
+++ b/dom/media/MediaMetadataManager.h
@@ -24,25 +24,25 @@ typedef MediaEventSourceExc<TimedMetadat
 // A struct that contains the metadata of a media, and the time at which those
 // metadata should start to be reported.
 class TimedMetadata : public LinkedListElement<TimedMetadata> {
 public:
   TimedMetadata(const media::TimeUnit& aPublishTime,
                 nsAutoPtr<MetadataTags>&& aTags,
                 nsAutoPtr<MediaInfo>&& aInfo)
     : mPublishTime(aPublishTime)
-    , mTags(Move(aTags))
-    , mInfo(Move(aInfo)) {}
+    , mTags(std::move(aTags))
+    , mInfo(std::move(aInfo)) {}
 
   // Define our move constructor because we don't want to move the members of
   // LinkedListElement to change the list.
   TimedMetadata(TimedMetadata&& aOther)
     : mPublishTime(aOther.mPublishTime)
-    , mTags(Move(aOther.mTags))
-    , mInfo(Move(aOther.mInfo)) {}
+    , mTags(std::move(aOther.mTags))
+    , mInfo(std::move(aOther.mInfo)) {}
 
   // The time, in microseconds, at which those metadata should be available.
   media::TimeUnit mPublishTime;
   // The metadata. The ownership is transfered to the element when dispatching to
   // the main threads.
   nsAutoPtr<MetadataTags> mTags;
   // The media info, including the info of audio tracks and video tracks.
   // The ownership is transfered to MediaDecoder when dispatching to the
@@ -77,25 +77,25 @@ public:
   TimedMetadataEventSource& TimedMetadataEvent() {
     return mTimedMetadataEvent;
   }
 
   void DispatchMetadataIfNeeded(const media::TimeUnit& aCurrentTime) {
     TimedMetadata* metadata = mMetadataQueue.getFirst();
     while (metadata && aCurrentTime >= metadata->mPublishTime) {
       // Our listener will figure out what to do with TimedMetadata.
-      mTimedMetadataEvent.Notify(Move(*metadata));
+      mTimedMetadataEvent.Notify(std::move(*metadata));
       delete mMetadataQueue.popFirst();
       metadata = mMetadataQueue.getFirst();
     }
   }
 
 protected:
   void OnMetadataQueued(TimedMetadata&& aMetadata) {
-    mMetadataQueue.insertBack(new TimedMetadata(Move(aMetadata)));
+    mMetadataQueue.insertBack(new TimedMetadata(std::move(aMetadata)));
   }
 
   LinkedList<TimedMetadata> mMetadataQueue;
   MediaEventListener mListener;
   TimedMetadataEventProducer mTimedMetadataEvent;
 };
 
 } // namespace mozilla
--- a/dom/media/MediaRecorder.cpp
+++ b/dom/media/MediaRecorder.cpp
@@ -283,17 +283,17 @@ class MediaRecorder::Session: public Pri
     RefPtr<Session> mSession;
     nsTArray<nsTArray<uint8_t>> mBuffer;
 
   public:
     StoreEncodedBufferRunnable(Session* aSession,
                                nsTArray<nsTArray<uint8_t>>&& aBuffer)
       : Runnable("StoreEncodedBufferRunnable")
       , mSession(aSession)
-      , mBuffer(Move(aBuffer))
+      , mBuffer(std::move(aBuffer))
     {}
 
     NS_IMETHOD
     Run() override
     {
       MOZ_ASSERT(NS_IsMainThread());
       mSession->MaybeCreateMutableBlobStorage();
       for (uint32_t i = 0; i < mBuffer.Length(); i++) {
@@ -714,17 +714,17 @@ private:
     if (NS_FAILED(rv)) {
       MOZ_RELEASE_ASSERT(encodedBuf.IsEmpty());
       // Even if we failed to encode more data, it might be time to push a blob
       // with already encoded data.
     }
 
     // Append pulled data into cache buffer.
     NS_DispatchToMainThread(new StoreEncodedBufferRunnable(this,
-                                                           Move(encodedBuf)));
+                                                           std::move(encodedBuf)));
 
     // Whether push encoded data back to onDataAvailable automatically or we
     // need a flush.
     bool pushBlob = aForceFlush;
     if (!pushBlob &&
         mTimeSlice > 0 &&
         (TimeStamp::Now()-mLastBlobTimeStamp).ToMilliseconds() > mTimeSlice) {
       pushBlob = true;
@@ -1054,17 +1054,17 @@ private:
 
     if (NS_FAILED(rv)) {
       MOZ_ASSERT(false);
       return;
     }
 
     // Append pulled data into cache buffer.
     NS_DispatchToMainThread(new StoreEncodedBufferRunnable(this,
-                                                           Move(encodedBuf)));
+                                                           std::move(encodedBuf)));
 
     RefPtr<Session> self = this;
     NS_DispatchToMainThread(NewRunnableFrom([self, mime]() {
       if (!self->mRecorder) {
         MOZ_ASSERT_UNREACHABLE("Recorder should be live");
         return NS_OK;
       }
       if (self->mRunningState.isOk()) {
@@ -1154,17 +1154,17 @@ private:
 
     // Remove main thread state.
     if (mMediaStream) {
       mMediaStream->UnregisterTrackListener(this);
       mMediaStream = nullptr;
     }
 
     {
-      auto tracks(Move(mMediaStreamTracks));
+      auto tracks(std::move(mMediaStreamTracks));
       for (RefPtr<MediaStreamTrack>& track : tracks) {
         track->RemovePrincipalChangeObserver(this);
       }
     }
 
     // Break the cycle reference between Session and MediaRecorder.
     if (mRecorder) {
       mShutdownPromise = mShutdownPromise->Then(
--- a/dom/media/MediaSegment.h
+++ b/dom/media/MediaSegment.h
@@ -218,19 +218,19 @@ public:
 protected:
   explicit MediaSegment(Type aType)
     : mDuration(0), mType(aType), mLastPrincipalHandle(PRINCIPAL_HANDLE_NONE)
   {
     MOZ_COUNT_CTOR(MediaSegment);
   }
 
   MediaSegment(MediaSegment&& aSegment)
-    : mDuration(Move(aSegment.mDuration))
-    , mType(Move(aSegment.mType))
-    , mLastPrincipalHandle(Move(aSegment.mLastPrincipalHandle))
+    : mDuration(std::move(aSegment.mDuration))
+    , mType(std::move(aSegment.mType))
+    , mLastPrincipalHandle(std::move(aSegment.mLastPrincipalHandle))
   {
     MOZ_COUNT_CTOR(MediaSegment);
   }
 
   StreamTime mDuration; // total of mDurations of all chunks
   Type mType;
 
   // The latest principal handle that the MediaStreamGraph has processed for
@@ -448,20 +448,20 @@ public:
 
 protected:
   explicit MediaSegmentBase(Type aType)
     : MediaSegment(aType)
     , mChunks()
   {}
 
   MediaSegmentBase(MediaSegmentBase&& aSegment)
-    : MediaSegment(Move(aSegment))
+    : MediaSegment(std::move(aSegment))
     , mChunks()
 #ifdef MOZILLA_INTERNAL_API
-    , mTimeStamp(Move(aSegment.mTimeStamp))
+    , mTimeStamp(std::move(aSegment.mTimeStamp))
 #endif
   {
     mChunks.SwapElements(aSegment.mChunks);
     MOZ_ASSERT(mChunks.Capacity() >= DEFAULT_SEGMENT_CAPACITY,
                "Capacity must be retained in self after swap");
     MOZ_ASSERT(aSegment.mChunks.Capacity() >= DEFAULT_SEGMENT_CAPACITY,
                "Capacity must be retained in other after swap");
   }
@@ -477,17 +477,17 @@ protected:
     size_t offset = 0;
     if (!mChunks.IsEmpty() && !aSource->mChunks.IsEmpty() &&
         mChunks[mChunks.Length() - 1].CanCombineWithFollowing(aSource->mChunks[0])) {
       mChunks[mChunks.Length() - 1].mDuration += aSource->mChunks[0].mDuration;
       offset = 1;
     }
 
     for (; offset < aSource->mChunks.Length(); ++offset) {
-      mChunks.AppendElement(Move(aSource->mChunks[offset]));
+      mChunks.AppendElement(std::move(aSource->mChunks[offset]));
     }
 
     aSource->mChunks.ClearAndRetainStorage();
     MOZ_ASSERT(aSource->mChunks.Capacity() >= DEFAULT_SEGMENT_CAPACITY,
                "Capacity must be retained after appending from aSource");
   }
 
   void AppendSliceInternal(const MediaSegmentBase<C, Chunk>& aSource,
--- a/dom/media/MediaStreamGraph.cpp
+++ b/dom/media/MediaStreamGraph.cpp
@@ -1012,17 +1012,17 @@ MediaStreamGraphImpl::PrepareUpdatesToMa
       // streams that are removed from the graph.
       MOZ_ASSERT(!stream || stream->GraphImpl() == this);
       if (!stream || stream->MainThreadNeedsUpdates()) {
         // Discard this update as it has either been cleared when the stream
         // was destroyed or there will be a newer update below.
         continue;
       }
       if (keptUpdateCount != i) {
-        mStreamUpdates[keptUpdateCount] = Move(mStreamUpdates[i]);
+        mStreamUpdates[keptUpdateCount] = std::move(mStreamUpdates[i]);
         MOZ_ASSERT(!mStreamUpdates[i].mStream);
       }
       ++keptUpdateCount;
     }
     mStreamUpdates.TruncateLength(keptUpdateCount);
 
     mStreamUpdates.SetCapacity(mStreamUpdates.Length() + mStreams.Length() +
         mSuspendedStreams.Length());
@@ -1034,17 +1034,17 @@ MediaStreamGraphImpl::PrepareUpdatesToMa
       update->mStream = stream;
       // No blocking to worry about here, since we've passed
       // UpdateCurrentTimeForStreams.
       update->mNextMainThreadCurrentTime =
         stream->GraphTimeToStreamTime(mProcessedTime);
       update->mNextMainThreadFinished = stream->mNotifiedFinished;
     }
     if (!mPendingUpdateRunnables.IsEmpty()) {
-      mUpdateRunnables.AppendElements(Move(mPendingUpdateRunnables));
+      mUpdateRunnables.AppendElements(std::move(mPendingUpdateRunnables));
     }
   }
 
   // If this is the final update, then a stable state event will soon be
   // posted just before this thread finishes, and so there is no need to also
   // post here.
   if (!aFinalUpdate &&
       // Don't send the message to the main thread if it's not going to have
@@ -1118,17 +1118,17 @@ MediaStreamGraphImpl::RunMessageAfterPro
   MOZ_ASSERT(OnGraphThread());
 
   if (mFrontMessageQueue.IsEmpty()) {
     mFrontMessageQueue.AppendElement();
   }
 
   // Only one block is used for messages from the graph thread.
   MOZ_ASSERT(mFrontMessageQueue.Length() == 1);
-  mFrontMessageQueue[0].mMessages.AppendElement(Move(aMessage));
+  mFrontMessageQueue[0].mMessages.AppendElement(std::move(aMessage));
 }
 
 void
 MediaStreamGraphImpl::RunMessagesInQueue()
 {
   TRACE_AUDIO_CALLBACK();
   MOZ_ASSERT(OnGraphThread());
   // Calculate independent action times for each batch of messages (each
@@ -1696,17 +1696,17 @@ MediaStreamGraphImpl::RunInStableState(b
       }
     }
 
     if ((mForceShutDown || !mRealtime) &&
         LifecycleStateRef() == LIFECYCLE_WAITING_FOR_MAIN_THREAD_CLEANUP) {
       // Defer calls to RunDuringShutdown() to happen while mMonitor is not held.
       for (uint32_t i = 0; i < mBackMessageQueue.Length(); ++i) {
         MessageBlock& mb = mBackMessageQueue[i];
-        controlMessagesToRunDuringShutdown.AppendElements(Move(mb.mMessages));
+        controlMessagesToRunDuringShutdown.AppendElements(std::move(mb.mMessages));
       }
       mBackMessageQueue.Clear();
       MOZ_ASSERT(mCurrentTaskMessageQueue.IsEmpty());
       // Stop MediaStreamGraph threads. Do not clear gGraph since
       // we have outstanding DOM objects that may need it.
       LifecycleStateRef() = LIFECYCLE_WAITING_FOR_THREAD_SHUTDOWN;
       nsCOMPtr<nsIRunnable> event = new MediaStreamGraphShutDownRunnable(this);
       mAbstractMainThread->Dispatch(event.forget());
@@ -1812,24 +1812,24 @@ MediaStreamGraphImpl::AppendMessage(Uniq
         }
       }
 
       Destroy();
     }
     return;
   }
 
-  mCurrentTaskMessageQueue.AppendElement(Move(aMessage));
+  mCurrentTaskMessageQueue.AppendElement(std::move(aMessage));
   EnsureRunInStableState();
 }
 
 void
 MediaStreamGraphImpl::Dispatch(already_AddRefed<nsIRunnable>&& aRunnable)
 {
-  mAbstractMainThread->Dispatch(Move(aRunnable));
+  mAbstractMainThread->Dispatch(std::move(aRunnable));
 }
 
 MediaStream::MediaStream()
   : mTracksStartTime(0)
   , mStartBlocking(GRAPH_TIME_MAX)
   , mSuspendedCount(0)
   , mFinished(false)
   , mNotifiedFinished(false)
@@ -2587,17 +2587,17 @@ MediaStream::SetTrackEnabledImpl(TrackID
     }
   } else {
     for (const DisabledTrack& t : mDisabledTracks) {
       if (aTrackID == t.mTrackID) {
         NS_ERROR("Changing disabled track mode for a track is not allowed");
         return;
       }
     }
-    mDisabledTracks.AppendElement(Move(DisabledTrack(aTrackID, aMode)));
+    mDisabledTracks.AppendElement(std::move(DisabledTrack(aTrackID, aMode)));
   }
 }
 
 DisabledTrackMode
 MediaStream::GetDisabledTrackMode(TrackID aTrackID)
 {
   for (const DisabledTrack& t : mDisabledTracks) {
     if (t.mTrackID == aTrackID) {
@@ -2951,17 +2951,17 @@ SourceMediaStream::AddAudioTrack(TrackID
 {
   AddTrackInternal(aID, aRate, aStart, aSegment, aFlags);
 }
 
 void
 SourceMediaStream::FinishAddTracks()
 {
   MutexAutoLock lock(mMutex);
-  mUpdateTracks.AppendElements(Move(mPendingTracks));
+  mUpdateTracks.AppendElements(std::move(mPendingTracks));
   LOG(LogLevel::Debug,
       ("FinishAddTracks: %lu/%lu",
        (long)mPendingTracks.Length(),
        (long)mUpdateTracks.Length()));
   if (GraphImpl()) {
     GraphImpl()->EnsureNextIteration();
   }
 }
@@ -3859,34 +3859,34 @@ MediaStreamGraphImpl::CollectSizesForMem
       : mozilla::Runnable("FinishCollectRunnable")
       , mHandleReport(aHandleReport)
       , mHandlerData(aHandlerData)
     {}
 
     NS_IMETHOD Run() override
     {
       MediaStreamGraphImpl::FinishCollectReports(mHandleReport, mHandlerData,
-                                                 Move(mAudioStreamSizes));
+                                                 std::move(mAudioStreamSizes));
       return NS_OK;
     }
 
     nsTArray<AudioNodeSizes> mAudioStreamSizes;
 
   private:
     ~FinishCollectRunnable() {}
 
     // Avoiding nsCOMPtr because NSCAP_ASSERT_NO_QUERY_NEEDED in its
     // constructor modifies the ref-count, which cannot be done off main
     // thread.
     RefPtr<nsIHandleReportCallback> mHandleReport;
     RefPtr<nsISupports> mHandlerData;
   };
 
   RefPtr<FinishCollectRunnable> runnable =
-    new FinishCollectRunnable(Move(aHandleReport), Move(aHandlerData));
+    new FinishCollectRunnable(std::move(aHandleReport), std::move(aHandlerData));
 
   auto audioStreamSizes = &runnable->mAudioStreamSizes;
 
   for (MediaStream* s : AllStreams()) {
     AudioNodeStream* stream = s->AsAudioNodeStream();
     if (stream) {
       AudioNodeSizes* usage = audioStreamSizes->AppendElement();
       stream->SizeOfAudioNodesIncludingThis(MallocSizeOf, *usage);
@@ -4378,12 +4378,12 @@ MediaStreamGraphImpl::ConnectToCaptureSt
 }
 
 void
 MediaStreamGraph::DispatchToMainThreadAfterStreamStateUpdate(
   already_AddRefed<nsIRunnable> aRunnable)
 {
   AssertOnGraphThreadOrNotRunning();
   *mPendingUpdateRunnables.AppendElement() =
-    AbstractMainThread()->CreateDirectTaskDrainer(Move(aRunnable));
+    AbstractMainThread()->CreateDirectTaskDrainer(std::move(aRunnable));
 }
 
 } // namespace mozilla
--- a/dom/media/QueueObject.cpp
+++ b/dom/media/QueueObject.cpp
@@ -19,17 +19,17 @@ void
 QueueObject::Dispatch(nsIRunnable* aRunnable)
 {
   Dispatch(do_AddRef(aRunnable));
 }
 
 void
 QueueObject::Dispatch(already_AddRefed<nsIRunnable> aRunnable)
 {
-  mThread->Dispatch(Move(aRunnable));
+  mThread->Dispatch(std::move(aRunnable));
 }
 
 bool
 QueueObject::OnThread()
 {
   return mThread->IsCurrentThreadIn();
 }
 
--- a/dom/media/ReaderProxy.cpp
+++ b/dom/media/ReaderProxy.cpp
@@ -181,17 +181,17 @@ ReaderProxy::SeekInternal(const SeekTarg
 {
   MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
   SeekTarget adjustedTarget = aTarget;
   adjustedTarget.SetTime(adjustedTarget.GetTime() + StartTime());
   return InvokeAsync(mReader->OwnerThread(),
                      mReader.get(),
                      __func__,
                      &MediaFormatReader::Seek,
-                     Move(adjustedTarget));
+                     std::move(adjustedTarget));
 }
 
 RefPtr<ReaderProxy::WaitForDataPromise>
 ReaderProxy::WaitForData(MediaData::Type aType)
 {
   MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
   MOZ_ASSERT(mReader->IsWaitForDataSupported());
   return InvokeAsync(mReader->OwnerThread(),
@@ -248,17 +248,17 @@ ReaderProxy::OnMetadataRead(MetadataHold
   if (mShutdown) {
     return MetadataPromise::CreateAndReject(
       NS_ERROR_DOM_MEDIA_ABORT_ERR, __func__);
   }
 
   if (mStartTime.isNothing()) {
     mStartTime.emplace(aMetadata.mInfo->mStartTime);
   }
-  return MetadataPromise::CreateAndResolve(Move(aMetadata), __func__);
+  return MetadataPromise::CreateAndResolve(std::move(aMetadata), __func__);
 }
 
 RefPtr<ReaderProxy::MetadataPromise>
 ReaderProxy::OnMetadataNotRead(const MediaResult& aError)
 {
   return MetadataPromise::CreateAndReject(aError, __func__);
 }
 
--- a/dom/media/TimeUnits.h
+++ b/dom/media/TimeUnits.h
@@ -221,25 +221,25 @@ public:
 
   // MOZ_IMPLICIT as we want to enable initialization in the form:
   // TimeIntervals i = ... like we would do with IntervalSet<T> i = ...
   MOZ_IMPLICIT TimeIntervals(const BaseType& aOther)
     : BaseType(aOther)
   {
   }
   MOZ_IMPLICIT TimeIntervals(BaseType&& aOther)
-    : BaseType(Move(aOther))
+    : BaseType(std::move(aOther))
   {
   }
   explicit TimeIntervals(const BaseType::ElemType& aOther)
     : BaseType(aOther)
   {
   }
   explicit TimeIntervals(BaseType::ElemType&& aOther)
-    : BaseType(Move(aOther))
+    : BaseType(std::move(aOther))
   {
   }
 
   static TimeIntervals Invalid()
   {
     return TimeIntervals(TimeInterval(TimeUnit::FromMicroseconds(INT64_MIN),
                                       TimeUnit::FromMicroseconds(INT64_MIN)));
   }
--- a/dom/media/VideoSegment.cpp
+++ b/dom/media/VideoSegment.cpp
@@ -103,15 +103,15 @@ VideoSegment::AppendFrame(already_AddRef
   chunk->mFrame.TakeFrom(&frame);
 }
 
 VideoSegment::VideoSegment()
   : MediaSegmentBase<VideoSegment, VideoChunk>(VIDEO)
 {}
 
 VideoSegment::VideoSegment(VideoSegment&& aSegment)
-  : MediaSegmentBase<VideoSegment, VideoChunk>(Move(aSegment))
+  : MediaSegmentBase<VideoSegment, VideoChunk>(std::move(aSegment))
 {}
 
 VideoSegment::~VideoSegment()
 {}
 
 } // namespace mozilla
--- a/dom/media/doctor/DDMediaLogs.cpp
+++ b/dom/media/doctor/DDMediaLogs.cpp
@@ -19,23 +19,23 @@ DDMediaLogs::New()
   nsresult rv = NS_NewNamedThread("DDMediaLogs",
                                   getter_AddRefs(mThread),
                                   nullptr,
                                   nsIThreadManager::kThreadPoolStackSize);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return { rv, nullptr };
   }
 
-  return { rv, new DDMediaLogs(Move(mThread)) };
+  return { rv, new DDMediaLogs(std::move(mThread)) };
 }
 
 DDMediaLogs::DDMediaLogs(nsCOMPtr<nsIThread>&& aThread)
   : mMediaLogs(1)
   , mMutex("DDMediaLogs")
-  , mThread(Move(aThread))
+  , mThread(std::move(aThread))
 {
   mMediaLogs.SetLength(1);
   mMediaLogs[0].mMediaElement = nullptr;
   DDL_INFO("DDMediaLogs constructed, processing thread: %p", mThread.get());
 }
 
 DDMediaLogs::~DDMediaLogs()
 {
@@ -196,17 +196,17 @@ DDMediaLogs::SetMediaElement(DDLifetime&
     bool found = false;
     for (const DDLifetime* lifetime : lifetimes) {
       if (lifetime->mObject == message.mObject) {
         found = true;
         break;
       }
     }
     if (found) {
-      messages.AppendElement(Move(message));
+      messages.AppendElement(std::move(message));
       messages0.RemoveElementAt(i);
       // No increment, as we've removed this element; next element is now at
       // the same index.
     } else {
       // Not touching this element, increment index to go to next element.
       ++i;
     }
   }
@@ -435,33 +435,33 @@ DDMediaLogs::FulfillPromises()
   {
     // Grab the first pending promise (if any).
     // Note that we don't pop it yet, so we don't potentially leave the list
     // empty and therefore allow another processing task to be dispatched.
     MutexAutoLock lock(mMutex);
     if (mPendingPromises.IsEmpty()) {
       return;
     }
-    promiseHolder = Move(mPendingPromises[0].mPromiseHolder);
+    promiseHolder = std::move(mPendingPromises[0].mPromiseHolder);
     mediaElement = mPendingPromises[0].mMediaElement;
   }
   for (;;) {
     DDMediaLog* log = GetLogFor(mediaElement);
     if (!log) {
       // No such media element -> Reject this promise.
       DDL_INFO("Rejecting promise for HTMLMediaElement[%p] - Cannot find log",
                mediaElement);
       promiseHolder.Reject(NS_ERROR_DOM_MEDIA_NOT_ALLOWED_ERR, __func__);
       // Pop this rejected promise, fetch next one.
       MutexAutoLock lock(mMutex);
       mPendingPromises.RemoveElementAt(0);
       if (mPendingPromises.IsEmpty()) {
         break;
       }
-      promiseHolder = Move(mPendingPromises[0].mPromiseHolder);
+      promiseHolder = std::move(mPendingPromises[0].mPromiseHolder);
       mediaElement = mPendingPromises[0].mMediaElement;
       continue;
     }
 
     nsCString json;
     JSONWriter jw{ MakeUnique<StringWriteFunc>(json) };
     jw.Start();
     jw.StartArrayProperty("messages");
@@ -536,28 +536,28 @@ DDMediaLogs::FulfillPromises()
     // This log exists (new messages or not) -> Resolve this promise.
     DDL_INFO("Resolving promise for HTMLMediaElement[%p] with messages %" PRImi
              "-%" PRImi,
              mediaElement,
              log->mMessages.IsEmpty() ? 0 : log->mMessages[0].mIndex.Value(),
              log->mMessages.IsEmpty()
                ? 0
                : log->mMessages[log->mMessages.Length() - 1].mIndex.Value());
-    promiseHolder.Resolve(Move(json), __func__);
+    promiseHolder.Resolve(std::move(json), __func__);
 
     // Remove exported messages.
     log->mMessages.Clear();
 
     // Pop this resolved promise, fetch next one.
     MutexAutoLock lock(mMutex);
     mPendingPromises.RemoveElementAt(0);
     if (mPendingPromises.IsEmpty()) {
       break;
     }
-    promiseHolder = Move(mPendingPromises[0].mPromiseHolder);
+    promiseHolder = std::move(mPendingPromises[0].mPromiseHolder);
     mediaElement = mPendingPromises[0].mMediaElement;
   }
 }
 
 void
 DDMediaLogs::CleanUpLogs()
 {
   MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
@@ -715,14 +715,14 @@ DDMediaLogs::RetrieveMessages(const dom:
     if (mPendingPromises.IsEmpty()) {
       // But if we're the first one, start processing.
       nsresult rv = DispatchProcessLog(lock);
       if (NS_FAILED(rv)) {
         holder.Reject(rv, __func__);
       }
     }
     mPendingPromises.AppendElement(
-      PendingPromise{ Move(holder), aMediaElement });
+      PendingPromise{ std::move(holder), aMediaElement });
   }
   return promise;
 }
 
 } // namespace mozilla
--- a/dom/media/doctor/DDMediaLogs.h
+++ b/dom/media/doctor/DDMediaLogs.h
@@ -42,17 +42,17 @@ public:
   {