Merge inbound to mozilla-central. a=merge
authorCsoregi Natalia <ncsoregi@mozilla.com>
Sat, 02 Jun 2018 01:01:33 +0300
changeset 420868 cbf9ea7c5531a1ab80ab716eae4c8eb71f6ebaae
parent 420859 69d43b0517a9a651dabe48fb6e9fb1ee4bdc7516 (current diff)
parent 420867 92f6a3f162e735951d9a9762338045586bbb9a54 (diff)
child 420869 8c926373039374cd1a47d92215e9efb4d5557983
child 420953 a153c2238eafc271da2ddc937f466ea37d1b4837
child 421071 aeea710872fef737c3a4fcef9925fe7c18058f21
push id34081
push userncsoregi@mozilla.com
push dateFri, 01 Jun 2018 22:02:59 +0000
treeherdermozilla-central@cbf9ea7c5531 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone62.0a1
first release with
nightly linux32
cbf9ea7c5531 / 62.0a1 / 20180601222241 / files
nightly linux64
cbf9ea7c5531 / 62.0a1 / 20180601222241 / files
nightly mac
cbf9ea7c5531 / 62.0a1 / 20180601222241 / files
nightly win32
cbf9ea7c5531 / 62.0a1 / 20180601222241 / files
nightly win64
cbf9ea7c5531 / 62.0a1 / 20180601222241 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge inbound to mozilla-central. a=merge
toolkit/components/telemetry/TelemetryEvent.cpp
toolkit/components/telemetry/geckoview/TelemetryGeckoViewPersistence.cpp
toolkit/components/telemetry/ipc/TelemetryIPCAccumulator.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:
   {
     if (mMessagesQueue.PushF(
           [&](DDLogMessage& aMessage, MessagesQueue::Index i) {
             aMessage.mIndex = i;
             aMessage.mTimeStamp = DDNow();
             aMessage.mObject.Set(aSubjectTypeName, aSubjectPointer);
             aMessage.mCategory = aCategory;
             aMessage.mLabel = aLabel;
-            aMessage.mValue = Move(aValue);
+            aMessage.mValue = std::move(aValue);
           })) {
       // Filled a buffer-full of messages, process it in another thread.
       DispatchProcessLog();
     }
   }
 
   // Process the log right now; should only be used on the processing thread,
   // or after shutdown for end-of-life log retrieval. Work includes:
--- a/dom/media/doctor/DecoderDoctorDiagnostics.cpp
+++ b/dom/media/doctor/DecoderDoctorDiagnostics.cpp
@@ -86,23 +86,23 @@ private:
   // Once nulled, no more actual work will happen, and the watcher will be
   // destroyed soon.
   nsIDocument* mDocument;
 
   struct Diagnostics
   {
     Diagnostics(DecoderDoctorDiagnostics&& aDiagnostics,
                 const char* aCallSite)
-      : mDecoderDoctorDiagnostics(Move(aDiagnostics))
+      : mDecoderDoctorDiagnostics(std::move(aDiagnostics))
       , mCallSite(aCallSite)
     {}
     Diagnostics(const Diagnostics&) = delete;
     Diagnostics(Diagnostics&& aOther)
-      : mDecoderDoctorDiagnostics(Move(aOther.mDecoderDoctorDiagnostics))
-      , mCallSite(Move(aOther.mCallSite))
+      : mDecoderDoctorDiagnostics(std::move(aOther.mDecoderDoctorDiagnostics))
+      , mCallSite(std::move(aOther.mCallSite))
     {}
 
     const DecoderDoctorDiagnostics mDecoderDoctorDiagnostics;
     const nsCString mCallSite;
   };
   typedef nsTArray<Diagnostics> DiagnosticsSequence;
   DiagnosticsSequence mDiagnosticsSequence;
 
@@ -770,17 +770,17 @@ DecoderDoctorDocumentWatcher::AddDiagnos
   MOZ_ASSERT(aDiagnostics.Type() != DecoderDoctorDiagnostics::eEvent);
 
   if (!mDocument) {
     return;
   }
 
   DD_DEBUG("DecoderDoctorDocumentWatcher[%p, doc=%p]::AddDiagnostics(DecoderDoctorDiagnostics{%s}, call site '%s')",
            this, mDocument, aDiagnostics.GetDescription().Data(), aCallSite);
-  mDiagnosticsSequence.AppendElement(Diagnostics(Move(aDiagnostics), aCallSite));
+  mDiagnosticsSequence.AppendElement(Diagnostics(std::move(aDiagnostics), aCallSite));
   EnsureTimerIsStarted();
 }
 
 NS_IMETHODIMP
 DecoderDoctorDocumentWatcher::Notify(nsITimer* timer)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(timer == mTimer);
@@ -850,18 +850,18 @@ DecoderDoctorDiagnostics::StoreFormatDia
             this, aDocument, NS_ConvertUTF16toUTF8(aFormat).get(), aCanPlay, aCallSite);
     return;
   }
 
   mFormat = aFormat;
   mCanPlay = aCanPlay;
 
   // StoreDiagnostics should only be called once, after all data is available,
-  // so it is safe to Move() from this object.
-  watcher->AddDiagnostics(Move(*this), aCallSite);
+  // so it is safe to std::move() from this object.
+  watcher->AddDiagnostics(std::move(*this), aCallSite);
   // Even though it's moved-from, the type should stay set
   // (Only used to ensure that we do store only once.)
   MOZ_ASSERT(mDiagnosticsType == eFormatSupportCheck);
 }
 
 void
 DecoderDoctorDiagnostics::StoreMediaKeySystemAccess(nsIDocument* aDocument,
                                                     const nsAString& aKeySystem,
@@ -892,18 +892,18 @@ DecoderDoctorDiagnostics::StoreMediaKeyS
             this, aDocument, NS_ConvertUTF16toUTF8(aKeySystem).get(), aIsSupported, aCallSite);
     return;
   }
 
   mKeySystem = aKeySystem;
   mIsKeySystemSupported = aIsSupported;
 
   // StoreMediaKeySystemAccess should only be called once, after all data is
-  // available, so it is safe to Move() from this object.
-  watcher->AddDiagnostics(Move(*this), aCallSite);
+  // available, so it is safe to std::move() from this object.
+  watcher->AddDiagnostics(std::move(*this), aCallSite);
   // Even though it's moved-from, the type should stay set
   // (Only used to ensure that we do store only once.)
   MOZ_ASSERT(mDiagnosticsType == eMediaKeySystemAccessRequest);
 }
 
 void
 DecoderDoctorDiagnostics::StoreEvent(nsIDocument* aDocument,
                                      const DecoderDoctorEvent& aEvent,
@@ -970,18 +970,18 @@ DecoderDoctorDiagnostics::StoreDecodeErr
             this, aDocument, aError.Description().get(), aCallSite);
     return;
   }
 
   mDecodeIssue = aError;
   mDecodeIssueMediaSrc = aMediaSrc;
 
   // StoreDecodeError should only be called once, after all data is
-  // available, so it is safe to Move() from this object.
-  watcher->AddDiagnostics(Move(*this), aCallSite);
+  // available, so it is safe to std::move() from this object.
+  watcher->AddDiagnostics(std::move(*this), aCallSite);
   // Even though it's moved-from, the type should stay set
   // (Only used to ensure that we do store only once.)
   MOZ_ASSERT(mDiagnosticsType == eDecodeError);
 }
 
 void
 DecoderDoctorDiagnostics::StoreDecodeWarning(nsIDocument* aDocument,
                                              const MediaResult& aWarning,
@@ -1011,18 +1011,18 @@ DecoderDoctorDiagnostics::StoreDecodeWar
             this, aDocument, aWarning.Description().get(), aCallSite);
     return;
   }
 
   mDecodeIssue = aWarning;
   mDecodeIssueMediaSrc = aMediaSrc;
 
   // StoreDecodeWarning should only be called once, after all data is
-  // available, so it is safe to Move() from this object.
-  watcher->AddDiagnostics(Move(*this), aCallSite);
+  // available, so it is safe to std::move() from this object.
+  watcher->AddDiagnostics(std::move(*this), aCallSite);
   // Even though it's moved-from, the type should stay set
   // (Only used to ensure that we do store only once.)
   MOZ_ASSERT(mDiagnosticsType == eDecodeWarning);
 }
 
 static const char*
 EventDomainString(DecoderDoctorEvent::Domain aDomain)
 {
--- a/dom/media/doctor/DecoderDoctorLogger.cpp
+++ b/dom/media/doctor/DecoderDoctorLogger.cpp
@@ -169,13 +169,13 @@ DecoderDoctorLogger::Log(const char* aSu
                          const void* aSubjectPointer,
                          DDLogCategory aCategory,
                          const char* aLabel,
                          DDLogValue&& aValue)
 {
   if (IsDDLoggingEnabled()) {
     MOZ_ASSERT(sMediaLogs);
     sMediaLogs->Log(
-      aSubjectTypeName, aSubjectPointer, aCategory, aLabel, Move(aValue));
+      aSubjectTypeName, aSubjectPointer, aCategory, aLabel, std::move(aValue));
   }
 }
 
 } // namespace mozilla
--- a/dom/media/doctor/MultiWriterQueue.h
+++ b/dom/media/doctor/MultiWriterQueue.h
@@ -203,17 +203,17 @@ public:
 
   // Push new element and move-assign it a value.
   // Atomically thread-safe; in the worst case some pushes may be blocked
   // while a new buffer is created/reused for them.
   // Returns whether that push reached the end of a buffer; useful if caller
   // wants to trigger processing regularly at the most efficient time.
   DidReachEndOfBuffer Push(T&& aT)
   {
-    return PushF([&aT](T& aElement, Index) { aElement = Move(aT); });
+    return PushF([&aT](T& aElement, Index) { aElement = std::move(aT); });
   }
 
   // Pop all elements before the first invalid one, running aF on each of them
   // in FIFO order.
   // Thread-safety with other PopAll calls is controlled by the `Locking`
   // template argument.
   // Concurrent pushes are always allowed, because:
   // - PopAll won't read elements until valid,
--- a/dom/media/eme/CDMProxy.h
+++ b/dom/media/eme/CDMProxy.h
@@ -107,17 +107,17 @@ public:
                     const nsAString& aTopLevelOrigin,
                     const nsAString& aName) = 0;
 
   virtual void OnSetDecryptorId(uint32_t aId) {}
 
   // Main thread only.
   // Uses the CDM to create a key session.
   // Calls MediaKeys::OnSessionActivated() when session is created.
-  // Assumes ownership of (Move()s) aInitData's contents.
+  // Assumes ownership of (std::move()s) aInitData's contents.
   virtual void CreateSession(uint32_t aCreateSessionToken,
                              MediaKeySessionType aSessionType,
                              PromiseId aPromiseId,
                              const nsAString& aInitDataType,
                              nsTArray<uint8_t>& aInitData) = 0;
 
   // Main thread only.
   // Uses the CDM to load a presistent session stored on disk.
@@ -125,25 +125,25 @@ public:
   virtual void LoadSession(PromiseId aPromiseId,
                            dom::MediaKeySessionType aSessionType,
                            const nsAString& aSessionId) = 0;
 
   // Main thread only.
   // Sends a new certificate to the CDM.
   // Calls MediaKeys->ResolvePromise(aPromiseId) after the CDM has
   // processed the request.
-  // Assumes ownership of (Move()s) aCert's contents.
+  // Assumes ownership of (std::move()s) aCert's contents.
   virtual void SetServerCertificate(PromiseId aPromiseId,
                                     nsTArray<uint8_t>& aCert) = 0;
 
   // Main thread only.
   // Sends an update to the CDM.
   // Calls MediaKeys->ResolvePromise(aPromiseId) after the CDM has
   // processed the request.
-  // Assumes ownership of (Move()s) aResponse's contents.
+  // Assumes ownership of (std::move()s) aResponse's contents.
   virtual void UpdateSession(const nsAString& aSessionId,
                              PromiseId aPromiseId,
                              nsTArray<uint8_t>& aResponse) = 0;
 
   // Main thread only.
   // Calls MediaKeys->ResolvePromise(aPromiseId